681 lines
23 KiB
C#
681 lines
23 KiB
C#
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
namespace EpicGames.Core.Tests
|
|
{
|
|
[TestClass]
|
|
public class JsonObjectTests
|
|
{
|
|
private string _testJsonText = null!;
|
|
private JsonObject _validTestObject = null!;
|
|
private Enemy _validJsonDataSource = null!;
|
|
private static DirectoryReference s_tempDirectory = null!;
|
|
private static JsonSerializerOptions s_jsonOptions = null!;
|
|
|
|
public JsonObjectTests()
|
|
{
|
|
s_tempDirectory = CreateTempDir();
|
|
// This is to make sure that enums are serialized as strings in the case that they were written as.
|
|
s_jsonOptions = new();
|
|
s_jsonOptions.Converters.Add(new JsonStringEnumConverter(null));
|
|
s_jsonOptions.WriteIndented = true;
|
|
}
|
|
|
|
[TestCleanup]
|
|
public void RemoveTempDir()
|
|
{
|
|
if (Directory.Exists(JsonObjectTests.s_tempDirectory.FullName))
|
|
{
|
|
Directory.Delete(JsonObjectTests.s_tempDirectory.FullName, true);
|
|
}
|
|
}
|
|
|
|
[TestInitialize]
|
|
public void InitializeTest()
|
|
{
|
|
Enemy enemy1 = CreateValidJsonDataSource();
|
|
_testJsonText = JsonSerializer.Serialize(enemy1, s_jsonOptions);
|
|
_validTestObject = CreateValidJsonObject();
|
|
_validJsonDataSource = enemy1;
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ParseValidJsonText()
|
|
{
|
|
JsonObject.Parse(_testJsonText);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(JsonException), AllowDerivedTypes = true)]
|
|
public void ParseInvalidJsonText()
|
|
{
|
|
MakeTestJsonTextInvalid();
|
|
JsonObject.Parse(_testJsonText);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(JsonException), AllowDerivedTypes = true)]
|
|
public void ParseEmptyText()
|
|
{
|
|
JsonObject.Parse("");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryParseValidJsonText()
|
|
{
|
|
JsonObject? testObject;
|
|
Assert.IsTrue(JsonObject.TryParse(_testJsonText, out testObject));
|
|
Assert.IsNotNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryParseInvalidJsonText()
|
|
{
|
|
MakeTestJsonTextInvalid();
|
|
JsonObject? testObject;
|
|
Assert.IsFalse(JsonObject.TryParse(_testJsonText, out testObject));
|
|
Assert.IsNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryParseEmptyJsonText()
|
|
{
|
|
JsonObject? testObject;
|
|
Assert.IsFalse(JsonObject.TryParse("", out testObject));
|
|
Assert.IsNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ReadValidJsonText()
|
|
{
|
|
FileReference inputFileReference = CreateTempJsonFile("Valid.json", _testJsonText);
|
|
JsonObject testObject = JsonObject.Read(inputFileReference);
|
|
Assert.IsNotNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(JsonException), AllowDerivedTypes = true)]
|
|
public void ReadInvalidJsonText()
|
|
{
|
|
MakeTestJsonTextInvalid();
|
|
FileReference inputFileReference = CreateTempJsonFile("Invalid.json", _testJsonText);
|
|
JsonObject.Read(inputFileReference);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(JsonException), AllowDerivedTypes = true)]
|
|
public void ReadEmptyJsonText()
|
|
{
|
|
FileReference inputFileReference = CreateTempJsonFile("Empty.json", "");
|
|
JsonObject.Read(inputFileReference);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryReadValidJsonText()
|
|
{
|
|
FileReference inputFileReference = CreateTempJsonFile("Valid.json", _testJsonText);
|
|
JsonObject? testObject;
|
|
Assert.IsTrue(JsonObject.TryRead(inputFileReference, out testObject));
|
|
Assert.IsNotNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryReadInvalidJsonText()
|
|
{
|
|
MakeTestJsonTextInvalid();
|
|
FileReference inputFileReference = CreateTempJsonFile("Invalid.json", _testJsonText);
|
|
JsonObject? testObject;
|
|
Assert.IsFalse(JsonObject.TryRead(inputFileReference, out testObject));
|
|
Assert.IsNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TryReadEmptyJsonText()
|
|
{
|
|
FileReference inputFileReference = CreateTempJsonFile("Empty.json", "");
|
|
JsonObject? testObject;
|
|
Assert.IsFalse(JsonObject.TryRead(inputFileReference, out testObject));
|
|
Assert.IsNull(testObject);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetIntegerValidField()
|
|
{
|
|
string fieldName = "Hp";
|
|
int correctValue = _validJsonDataSource.Hp;
|
|
Assert.AreEqual(correctValue, _validTestObject.GetIntegerField(fieldName));
|
|
int outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetIntegerField(fieldName, out outValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetIntegerInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
int correctValue = _validJsonDataSource.Hp;
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetIntegerField(fieldName));
|
|
int outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetIntegerField(fieldName, out outValue));
|
|
Assert.AreNotEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetStringValidField()
|
|
{
|
|
string fieldName = "Name";
|
|
string correctValue = _validJsonDataSource.Name;
|
|
Assert.AreEqual(correctValue, _validTestObject.GetStringField(fieldName));
|
|
string? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetStringField(fieldName, out outValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetStringInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
string correctValue = _validJsonDataSource.Name;
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetStringField(fieldName));
|
|
string? outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetStringField(fieldName, out outValue));
|
|
Assert.AreNotEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetObjectValidField()
|
|
{
|
|
string fieldName = "StrongestAttack";
|
|
JsonObject correctValue = _validJsonDataSource.StrongestAttack.ToJsonObject();
|
|
JsonObject returnValue = _validTestObject.GetObjectField(fieldName);
|
|
Assert.AreEqual(correctValue, returnValue);
|
|
JsonObject? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetObjectField(fieldName, out outValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetObjectInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetObjectField(fieldName));
|
|
JsonObject? outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetObjectField(fieldName, out outValue));
|
|
Assert.IsNull(outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetObjectArrayValidField()
|
|
{
|
|
string fieldName = "Attacks";
|
|
JsonObject[] correctValue = _validJsonDataSource.Attacks.Select(x => x.ToJsonObject()).ToArray();
|
|
JsonObject[] result = _validTestObject.GetObjectArrayField(fieldName);
|
|
CollectionAssert.AreEqual(correctValue, result);
|
|
JsonObject[]? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetObjectArrayField(fieldName, out outValue));
|
|
CollectionAssert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetObjectArrayInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetObjectArrayField(fieldName));
|
|
JsonObject[]? outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetObjectArrayField(fieldName, out outValue));
|
|
Assert.IsNull(outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetStringArrayValidField()
|
|
{
|
|
string fieldName = "Skills";
|
|
string[] correctValue = [.. _validJsonDataSource.Skills];
|
|
string[] result = _validTestObject.GetStringArrayField(fieldName);
|
|
CollectionAssert.AreEqual(correctValue, result);
|
|
string[]? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetStringArrayField(fieldName, out outValue));
|
|
CollectionAssert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetStringArrayInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
string[] correctValue = [.. _validJsonDataSource.Skills];
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetStringArrayField(fieldName));
|
|
string[]? outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetStringArrayField(fieldName, out outValue));
|
|
Assert.IsNull(outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetEnumValidField()
|
|
{
|
|
string fieldName = "CurrentStatusEffect";
|
|
StatusEffect correctValue = _validJsonDataSource.CurrentStatusEffect;
|
|
Assert.AreEqual(correctValue, _validTestObject.GetEnumField<StatusEffect>(fieldName));
|
|
StatusEffect outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetEnumField<StatusEffect>(fieldName, out outValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetEnumInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
StatusEffect correctValue = _validJsonDataSource.CurrentStatusEffect;
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetEnumField<StatusEffect>(fieldName));
|
|
StatusEffect outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetEnumField<StatusEffect>(fieldName, out outValue));
|
|
Assert.AreEqual(outValue, default);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetEnumArrayValidField()
|
|
{
|
|
string fieldName = "ImmuneStatusEffects";
|
|
StatusEffect[] correctValue = [.. _validJsonDataSource.ImmuneStatusEffects];
|
|
StatusEffect[]? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetEnumArrayField<StatusEffect>(fieldName, out outValue));
|
|
CollectionAssert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetEnumArrayInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
StatusEffect[] correctValu = [.. _validJsonDataSource.ImmuneStatusEffects];
|
|
StatusEffect[]? outValue;
|
|
Assert.IsFalse(_validTestObject.TryGetEnumArrayField(fieldName, out outValue));
|
|
Assert.IsNull(outValue);
|
|
CollectionAssert.AreNotEqual(correctValu, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetBoolValidField()
|
|
{
|
|
string fieldName = "IsAlive";
|
|
bool correctValue = _validJsonDataSource.IsAlive;
|
|
Assert.AreEqual(correctValue, _validTestObject.GetBoolField(fieldName));
|
|
bool outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetBoolField(fieldName, out outValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void GetBoolInvalidField()
|
|
{
|
|
string fieldName = "Invalid";
|
|
Assert.ThrowsException<JsonException>(() => _validTestObject.GetBoolField(fieldName));
|
|
bool outValue = false;
|
|
Assert.IsFalse(_validTestObject.TryGetBoolField(fieldName, out outValue));
|
|
Assert.IsFalse(outValue);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ContainsField()
|
|
{
|
|
string fieldName1 = "Name";
|
|
string fieldName2 = "Invalid";
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName1));
|
|
Assert.IsFalse(_validTestObject.ContainsField(fieldName2));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetIntegerField()
|
|
{
|
|
string fieldName = "Hp";
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
int setValue = 60;
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
Assert.AreEqual(setValue, _validTestObject.GetIntegerField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
Assert.AreEqual(setValue, _validTestObject.GetIntegerField(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetDoubleField()
|
|
{
|
|
string fieldName = "CriticalHitRate";
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
double setValue = 1.0;
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
Assert.AreEqual(setValue, _validTestObject.GetDoubleField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
Assert.AreEqual(setValue, _validTestObject.GetDoubleField(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetStringField()
|
|
{
|
|
string fieldName = "Name";
|
|
string setValue = "NewValue";
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
Assert.AreEqual(setValue, _validTestObject.GetStringField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
Assert.AreEqual(setValue, _validTestObject.GetStringField(newFieldName));
|
|
|
|
string nullFieldName = "Null";
|
|
string? nullString = null;
|
|
Assert.IsFalse(_validTestObject.ContainsField(nullFieldName));
|
|
_validTestObject.AddOrSetFieldValue(nullFieldName, nullString);
|
|
Assert.AreEqual("", _validTestObject.GetStringField(nullFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetStringArrayField()
|
|
{
|
|
string fieldName = "Skills";
|
|
string[] setValue = ["SetValue1", "SetValue2", "SetValue3", "SetValue4"];
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
CollectionAssert.AreEqual(setValue, _validTestObject.GetStringArrayField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
CollectionAssert.AreEqual(setValue, _validTestObject.GetStringArrayField(newFieldName));
|
|
|
|
// test array of strings that contains null. Null should be set as ""
|
|
string nullFieldName = "Null";
|
|
string?[] nullStringArray = ["String1", null, "String2"];
|
|
string[] correctNullStringArray = ["String1", "", "String2"];
|
|
Assert.IsFalse(_validTestObject.ContainsField(nullFieldName));
|
|
_validTestObject.AddOrSetFieldValue(nullFieldName, nullStringArray);
|
|
CollectionAssert.AreEqual(correctNullStringArray, _validTestObject.GetStringArrayField(nullFieldName));
|
|
|
|
// Test for passing in an empty string array. This should still be added and contained within the object
|
|
// This test is very important for ModuleDescriptor
|
|
string emptyFieldName = "Empty";
|
|
Assert.IsFalse(_validTestObject.ContainsField(emptyFieldName));
|
|
string[] emptyStringArray = [];
|
|
_validTestObject.AddOrSetFieldValue(emptyFieldName, emptyStringArray);
|
|
Assert.IsTrue(_validTestObject.ContainsField(emptyFieldName));
|
|
string[] returnArray = _validTestObject.GetStringArrayField(emptyFieldName);
|
|
Assert.IsTrue(returnArray.Length == 0);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetObjectField()
|
|
{
|
|
string fieldName = "StrongestAttack";
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
EnemyAttack setValue = new EnemyAttack("Ultima", 300, StatusEffect.None);
|
|
JsonObject setValueObject = setValue.ToJsonObject();
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue.ToJsonObject());
|
|
Assert.AreEqual(setValueObject, _validTestObject.GetObjectField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue.ToJsonObject());
|
|
Assert.AreEqual(setValueObject, _validTestObject.GetObjectField(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetObjectArrayField()
|
|
{
|
|
string fieldName = "Attacks";
|
|
EnemyAttack[] attacks =
|
|
[
|
|
new EnemyAttack("Attack1", 40, StatusEffect.Sleep),
|
|
new EnemyAttack("Attack2", 100, StatusEffect.Burn)
|
|
];
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
JsonObject[] setValue = attacks.Select(x => x.ToJsonObject()).ToArray();
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
CollectionAssert.AreEqual(setValue, _validTestObject.GetObjectArrayField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
CollectionAssert.AreEqual(setValue, _validTestObject.GetObjectArrayField(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetEnumField()
|
|
{
|
|
string fieldName = "CurrentStatusEffect";
|
|
StatusEffect setValue = StatusEffect.Burn;
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
Assert.AreEqual(setValue, _validTestObject.GetEnumField<StatusEffect>(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
Assert.AreEqual(setValue, _validTestObject.GetEnumField<StatusEffect>(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetEnumArrayField()
|
|
{
|
|
string fieldName = "ImmuneStatusEffects";
|
|
StatusEffect[] setValue = [StatusEffect.Sleep, StatusEffect.Poison, StatusEffect.Frozen, StatusEffect.Burn];
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
StatusEffect[]? outValue;
|
|
Assert.IsTrue(_validTestObject.TryGetEnumArrayField(fieldName, out outValue));
|
|
CollectionAssert.AreEqual(setValue, outValue);
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
StatusEffect[]? outValue2;
|
|
Assert.IsTrue(_validTestObject.TryGetEnumArrayField(newFieldName, out outValue2));
|
|
CollectionAssert.AreEqual(setValue, outValue2);
|
|
|
|
// Test passing in an empty array
|
|
string emptyFieldName = "Empty";
|
|
StatusEffect[] setValueEmpty = [];
|
|
Assert.IsFalse(_validTestObject.ContainsField(emptyFieldName));
|
|
_validTestObject.AddOrSetFieldValue(emptyFieldName, setValueEmpty);
|
|
Assert.IsTrue(_validTestObject.ContainsField(emptyFieldName));
|
|
StatusEffect[]? outValue4;
|
|
Assert.IsTrue(_validTestObject.TryGetEnumArrayField<StatusEffect>(emptyFieldName, out outValue4));
|
|
CollectionAssert.AreEqual(setValueEmpty, outValue4);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetEmptyArrayField()
|
|
{
|
|
string emptyFieldName = "Empty";
|
|
Assert.IsFalse(_validTestObject.ContainsField(emptyFieldName));
|
|
string[] setValue = [];
|
|
_validTestObject.AddOrSetFieldValue(emptyFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(emptyFieldName));
|
|
string[] returnValue = _validTestObject.GetStringArrayField(emptyFieldName);
|
|
CollectionAssert.AreEqual(setValue, returnValue);
|
|
Assert.IsTrue(returnValue.Length == 0);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void SetBoolField()
|
|
{
|
|
string fieldName = "IsAlive";
|
|
bool setValue = false;
|
|
Assert.IsTrue(_validTestObject.ContainsField(fieldName));
|
|
_validTestObject.AddOrSetFieldValue(fieldName, setValue);
|
|
Assert.AreEqual(setValue, _validTestObject.GetBoolField(fieldName));
|
|
|
|
string newFieldName = "New";
|
|
Assert.IsFalse(_validTestObject.ContainsField(newFieldName));
|
|
_validTestObject.AddOrSetFieldValue(newFieldName, setValue);
|
|
Assert.IsTrue(_validTestObject.ContainsField(newFieldName));
|
|
Assert.AreEqual(setValue, _validTestObject.GetBoolField(newFieldName));
|
|
}
|
|
|
|
[TestMethod]
|
|
public void Constructor()
|
|
{
|
|
JsonObject obj= new JsonObject();
|
|
Assert.AreEqual(0, obj.KeyNames.Count());
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToJsonString()
|
|
{
|
|
string stringToMatch = new string(_testJsonText.ToCharArray());
|
|
string[] lines = stringToMatch.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
|
|
StringBuilder jsonStringBuilder = new StringBuilder();
|
|
foreach (string line in lines)
|
|
{
|
|
// Utf8JsonWriter uses 2 spaces for indents, we replace them with tabs here
|
|
int numLeadingSpaces = line.TakeWhile(x => x == ' ').Count();
|
|
int numLeadingTabs = numLeadingSpaces / 2;
|
|
jsonStringBuilder.Append('\t', numLeadingTabs);
|
|
jsonStringBuilder.AppendLine(line.Substring(numLeadingSpaces));
|
|
}
|
|
stringToMatch = jsonStringBuilder.ToString();
|
|
|
|
string jsonObjectString = _validTestObject.ToJsonString();
|
|
Assert.AreEqual(stringToMatch, jsonObjectString);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void ToStringEscapeCharacters()
|
|
{
|
|
string escapeCharacterFieldName = "Escape";
|
|
// .NET Json serialization escapes certian characters like +,<,>,~,& for security reasons. We need to make sure those come through
|
|
string escapeString = "++MyTest+Test<>`&";
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.AppendLine("{");
|
|
builder.AppendLine($"\t\"{escapeCharacterFieldName}\": \"{escapeString}\"");
|
|
builder.AppendLine("}");
|
|
string correctString = builder.ToString();
|
|
JsonObject jsonObject = new JsonObject();
|
|
jsonObject.AddOrSetFieldValue(escapeCharacterFieldName, escapeString);
|
|
string jsonString = jsonObject.ToJsonString();
|
|
Assert.AreEqual(correctString , jsonString);
|
|
}
|
|
[TestMethod]
|
|
public void KeyNameCaseSensitivity()
|
|
{
|
|
// Legacy behavior is that we can look up keys in a case insensitive way
|
|
string fieldName = "Hp";
|
|
string caseInsensitiveFieldName = "hp";
|
|
int correctValue = _validJsonDataSource.Hp;
|
|
Assert.AreEqual(correctValue, _validTestObject.GetIntegerField(fieldName));
|
|
Assert.AreEqual(_validTestObject.GetIntegerField(fieldName), _validTestObject.GetIntegerField(caseInsensitiveFieldName));
|
|
int outValue;
|
|
int caseInsensitiveOutValue;
|
|
Assert.IsTrue(_validTestObject.TryGetIntegerField(fieldName, out outValue));
|
|
Assert.IsTrue(_validTestObject.TryGetIntegerField(caseInsensitiveFieldName, out caseInsensitiveOutValue));
|
|
Assert.AreEqual(correctValue, outValue);
|
|
Assert.AreEqual(outValue, caseInsensitiveOutValue);
|
|
}
|
|
|
|
private static Enemy CreateValidJsonDataSource()
|
|
{
|
|
Enemy enemy1 = new Enemy();
|
|
enemy1.Name = "Monster";
|
|
enemy1.Hp = 100;
|
|
enemy1.CriticalHitRate = 3.0;
|
|
|
|
// Add attacks
|
|
enemy1.Attacks.Add(new EnemyAttack("Slash", 10));
|
|
enemy1.Attacks.Add(new EnemyAttack("Ice Blade", 20, StatusEffect.Frozen));
|
|
|
|
enemy1.StrongestAttack = new EnemyAttack("Ultimate", 100, StatusEffect.Poison);
|
|
// Add skills
|
|
enemy1.Skills = ["Skill 1", "Skill 2"];
|
|
|
|
// Add status effects
|
|
enemy1.ImmuneStatusEffects.Add(StatusEffect.Frozen);
|
|
enemy1.ImmuneStatusEffects.Add(StatusEffect.Sleep);
|
|
|
|
enemy1.IsAlive = true;
|
|
enemy1.CurrentStatusEffect = StatusEffect.Poison;
|
|
|
|
return enemy1;
|
|
}
|
|
|
|
private JsonObject CreateValidJsonObject()
|
|
{
|
|
JsonObject validObject = JsonObject.Parse(_testJsonText);
|
|
return validObject;
|
|
}
|
|
|
|
private static FileReference CreateTempJsonFile(string fileName, string? fileContent)
|
|
{
|
|
string inputFile = Path.Join(s_tempDirectory.FullName, fileName);
|
|
FileReference inputFileReference = new FileReference(inputFile);
|
|
File.WriteAllText(inputFile, fileContent);
|
|
return inputFileReference;
|
|
}
|
|
|
|
private void MakeTestJsonTextInvalid()
|
|
{
|
|
_testJsonText += @"blah}blah";
|
|
}
|
|
|
|
private static DirectoryReference CreateTempDir()
|
|
{
|
|
string tempDir = Path.Join(Path.GetTempPath(), "epicgames-core-tests-" + Guid.NewGuid().ToString()[..8]);
|
|
Directory.CreateDirectory(tempDir);
|
|
return new DirectoryReference(tempDir);
|
|
}
|
|
}
|
|
|
|
enum StatusEffect
|
|
{
|
|
Frozen,
|
|
Poison,
|
|
Burn,
|
|
Sleep,
|
|
None
|
|
}
|
|
|
|
class Enemy
|
|
{
|
|
public string Name { get; set; } = "";
|
|
public int Hp { get; set; } = 0;
|
|
public double CriticalHitRate { get; set; } = 0.0;
|
|
public List<EnemyAttack> Attacks { get; set; } = [];
|
|
public EnemyAttack StrongestAttack { get; set; } = null!;
|
|
public List<StatusEffect> ImmuneStatusEffects { get; set; } = [];
|
|
public StatusEffect CurrentStatusEffect { get; set; } = StatusEffect.None;
|
|
public List<string> Skills { get; set; } = [];
|
|
public bool IsAlive { get; set; } = false;
|
|
}
|
|
|
|
class EnemyAttack(string name, int damage, StatusEffect effect = StatusEffect.None)
|
|
{
|
|
public JsonObject ToJsonObject()
|
|
{
|
|
JsonObject obj = new JsonObject();
|
|
obj.AddOrSetFieldValue("Name", Name);
|
|
obj.AddOrSetFieldValue("Damage", Damage);
|
|
obj.AddOrSetFieldValue<StatusEffect>("Effect", Effect);
|
|
return obj;
|
|
}
|
|
public string Name { get; set; } = name;
|
|
public int Damage { get; set; } = damage;
|
|
public StatusEffect Effect { get; set; } = effect;
|
|
}
|
|
}
|