void CompareNodes(SLJsonNode n1, SLJsonNode n2)
{
Assert.AreEqual(n1.NodeType, n2.NodeType);
Assert.AreEqual(n1.AsString, n2.AsString);
if (n1.IsArray && n2.IsArray)
{
int c1 = n1.Count;
int c2 = n2.Count;
Assert.AreEqual(c1, c2);
if (c1 == c2)
{
for (int i = 0; i < c1; i++)
{
CompareNodes(n1[i], n2[i]);
}
}
}
if (n1.IsObject && n2.IsObject)
{
int c1 = n1.Count;
int c2 = n2.Count;
Assert.AreEqual(c1, c2);
if (c1 == c2)
{
foreach (string k in n1.Names)
{
CompareNodes(n1[k], n2[k]);
}
}
}
}
public void TestReflection()
{
ExampleOuter o1 = CreateExample();
string s1 = new SLJsonSerializer().Serialize(o1);
var d = new SLJsonDeserializer();
ExampleOuter o2 = d.Deserialize <ExampleOuter>(s1);
CompareSomeFields(o1, o2);
Assert.AreEqual(2.345f, o1.RetrievePrivateValue());
Assert.AreEqual(0, o2.RetrievePrivateValue());
string s2 = new SLJsonSerializer().Serialize(o2);
Assert.AreEqual(s1, s2);
SLJsonNode n1 = SLJsonParser.Parse(s1);
SLJsonNode n2 = n1.Clone();
SLJsonNode n3 = SLJsonParser.Parse(n2.AsJson);
SLJsonNode n4 = SLJsonParser.Parse(n3.AsJsonCompact);
Assert.IsTrue(n1 != n2);
CompareNodes(n1, n1);
CompareNodes(n1, n2);
CompareNodes(n1, n3);
CompareNodes(n1, n4);
}
public void TestStandardParseForObject()
{
var n = SLJsonNode.Parse("{\"value\": true}");
Assert.IsTrue(n.IsObject);
Assert.IsTrue(n["value"].IsBoolean);
Assert.IsTrue(n["value"].AsBoolean);
}
void Check2(
SLJsonNode n,
bool isNull, bool isArray, bool isObject, bool isValue, SLJsonNodeType valueType,
bool valueBoolean, int valueInt32, long valueInt64, double valueNumber, string valueString)
{
CheckInternal(n, isNull, isArray, isObject, isValue, valueType, valueBoolean, valueInt32, valueInt64, valueNumber, valueString);
CheckInternal(n.AsString, isNull, isArray, isObject, isValue, SLJsonNodeType.String, valueBoolean, valueInt32, valueInt64, valueNumber, valueString);
}
public void TestOperatorsForStringDouble()
{
SLJsonNode n = "123.456";
Assert.IsTrue(n);
Assert.IsTrue(n == 123);
Assert.IsTrue(n == 123L);
Assert.IsTrue(Math.Abs(n - 123.456) <= 1e-7);
Assert.IsTrue(n == "123.456");
}
public void TestOperatorsForStringTrue()
{
SLJsonNode n = "true";
Assert.IsTrue(n);
Assert.IsTrue(n == 1);
Assert.IsTrue(n == 1L);
Assert.IsTrue(Math.Abs(n - 1.0) <= 1e-7);
Assert.IsTrue(n == "true");
}
public void TestOperatorsForStringFalse()
{
SLJsonNode n = "false";
Assert.IsFalse(n);
Assert.IsTrue(n == 0);
Assert.IsTrue(n == 0L);
Assert.IsTrue(Math.Abs(n - 0.0) <= 1e-7);
Assert.IsTrue(n == "false");
}
public void TestOperatorsForInteger()
{
SLJsonNode n = 123;
Assert.IsTrue(n);
Assert.IsTrue(n == 123);
Assert.IsTrue(n == 123L);
Assert.IsTrue(Math.Abs(n - 123.0) <= 1e-7);
Assert.IsTrue(n == "123");
}
public void TestOperatorsForNull()
{
SLJsonNode n = null;
Assert.IsFalse(n);
Assert.IsTrue(n == 0);
Assert.IsTrue(n == 0L);
Assert.IsTrue(Math.Abs(n - 0.0) <= 1e-7);
Assert.IsTrue((string)n == null);
}
void ParseAndSerialize(string jsonExpression, bool allowArraysAndValues, SLJsonNodeType nodeType)
{
SLJsonNode n = SLJsonParser.Parse(jsonExpression, allowArraysAndValues);
Assert.AreEqual(nodeType, n.NodeType);
string s = RemoveWhitespace(jsonExpression);
Assert.AreEqual(s, n.AsJsonCompact);
}
SLJsonNode ParseObject(SLJsonTokenizer tokenizer)
{
var res = new SLJsonNode();
res.MakeObject();
bool needSep = false;
while (true)
{
tokenizer.ReadNext();
if (tokenizer.SpecialChar == '}')
{
return(res);
}
if (needSep)
{
if (tokenizer.SpecialChar != ',')
{
throw new SLJsonException("Separator expected");
}
tokenizer.ReadNext();
}
if (tokenizer.HasSpecialChar)
{
throw new SLJsonException("Unexpected token");
}
if (!AreUnquotedNamesAllowed && !tokenizer.TokenIsString)
{
throw new SLJsonException("String expected");
}
string field = tokenizer.Token;
tokenizer.ReadNext();
if (tokenizer.SpecialChar != ':')
{
throw new SLJsonException("Colon expected");
}
tokenizer.ReadNext();
SLJsonNode value = ParseValue(tokenizer);
res.m_Object[field] = value; // No exception for multiple fields with the same name
value.AssignParent(res);
needSep = true;
}
}
public void TestOperatorsWithInt64Overflow()
{
double v = long.MaxValue + 1.0;
SLJsonNode n = v;
Assert.IsTrue(n);
Assert.IsTrue(n == 0); // 0 because of overflow for int
Assert.IsTrue(n == 0L); // 0 because of overflow for long
Assert.IsTrue(n - v == 0);
Assert.IsTrue(n == v.ToString("R", CultureInfo.InvariantCulture));
}
public void TestOperatorsWithInt32Overflow()
{
long v = int.MaxValue + 1L;
SLJsonNode n = v;
Assert.IsTrue(n);
Assert.IsTrue(n == 0); // 0 because of overflow for int
Assert.IsTrue(n == v);
Assert.IsTrue(n - v == 0);
Assert.IsTrue(n == v.ToString(CultureInfo.InvariantCulture));
}
public void TestCreateNew()
{
var n = new SLJsonNode();
n["person"]["firstName"].AsString = "John";
n["person"]["lastName"].AsString = "Doe";
Assert.AreEqual(1, n.Count);
Assert.AreEqual(2, n["person"].Count);
Assert.AreEqual("John", n["person"]["firstName"].AsString);
Assert.AreEqual("Doe", n["person"]["lastName"].AsString);
n["intValue"].AsInt32 = 27;
Assert.IsTrue(n["intValue"].IsNumber);
Assert.AreEqual("27", n["intValue"].AsString);
Assert.IsTrue(n["intValue"].Remove());
Assert.IsFalse(n["intValue"].Remove());
Assert.IsTrue(n["intValue"].IsMissing);
Assert.IsNull(n["intValue"].AsString);
Assert.IsTrue(n["testArray"].IsMissing);
n["testArray"][0].AsInt32 = 11;
Assert.IsTrue(n["testArray"].IsArray);
Assert.AreEqual(1, n["testArray"].Count);
n["testArray"][0].AsInt32 = 77;
Assert.AreEqual(1, n["testArray"].Count);
Assert.AreEqual(77, n["testArray"][0].AsInt32);
Assert.IsTrue(n["testArray"][1].IsMissing);
n["testArray"][2].AsInt32 = 200;
Assert.IsTrue(n["testArray"][1].IsNull);
Assert.IsTrue(n["testArray"][2].IsNumber);
Assert.IsTrue(n["testArray"][3].IsMissing);
n["testArray"][3].AsInt32 = 300;
Assert.IsTrue(n["testArray"][3].IsNumber);
Assert.AreEqual(4, n["testArray"].Count);
Assert.IsFalse(n["testArray"][100].Remove());
Assert.IsFalse(n["testArray"][100].Remove());
Assert.AreEqual(4, n["testArray"].Count);
Assert.IsTrue(n["testArray"][1].Remove());
Assert.AreEqual(3, n["testArray"].Count);
Assert.IsTrue(n["emptyArray"].IsMissing);
n["emptyArray"].CreateEmptyArray();
Assert.IsTrue(n["emptyArray"].IsArray);
Assert.AreEqual(0, n["emptyArray"].Count);
Assert.AreEqual("[]", n["emptyArray"].AsJsonCompact);
Assert.IsTrue(n["emptyObject"].IsMissing);
n["emptyObject"].CreateEmptyObject();
Assert.IsTrue(n["emptyObject"].IsObject);
Assert.AreEqual(0, n["emptyObject"].Count);
Assert.AreEqual("{}", n["emptyObject"].AsJsonCompact);
}
public void TestStandardParseForArray()
{
var n = SLJsonNode.Parse("[null, false, true, 16, 3.14159265359, \"test\"]");
Assert.IsTrue(n[0].IsNull);
Assert.IsTrue(n[1].IsBoolean);
Assert.IsTrue(n[2].IsBoolean);
Assert.IsTrue(n[3].IsNumber);
Assert.IsTrue(n[4].IsNumber);
Assert.IsTrue(n[5].IsString);
Assert.IsTrue(n[6].IsMissing);
}
void Check1(
string json,
bool isNull, bool isArray, bool isObject, bool isValue, SLJsonNodeType valueType,
bool valueBoolean, int valueInt32, long valueInt64, double valueNumber, string valueString)
{
SLJsonNode parsed = ParseObject(json);
SLJsonNode n = parsed["value"];
CheckInternal(n, isNull, isArray, isObject, isValue, valueType, valueBoolean, valueInt32, valueInt64, valueNumber, valueString);
if (n.NodeType >= SLJsonNodeType.Boolean && n.NodeType <= SLJsonNodeType.String)
{
CheckInternal(n.AsString, isNull, isArray, isObject, isValue, SLJsonNodeType.String, valueBoolean, valueInt32, valueInt64, valueNumber, valueString);
}
}
public void TestReadWrite()
{
string s = RetrieveJsonExpression();
SLJsonNode n = ParseAny(s);
SLJsonMonitor m = n.CreateMonitor();
// Try to read some properties
Assert.AreEqual("Jane", n["person"]["firstName"].AsString);
Assert.AreEqual("Doe", n["person"]["lastName"].AsString);
Assert.AreEqual("12345", n["person"]["zipCode"].AsString);
Assert.IsFalse(m.IsModified);
try
{
m.IsReadOnly = true;
n["abc"]["def"][100] = 0;
Assert.Fail();
}
catch (InvalidOperationException)
{
m.IsReadOnly = false;
}
Assert.IsFalse(m.IsModified);
// Try to change an existing property
n["person"]["firstName"].AsString = "John";
Assert.AreEqual("John", n["person"]["firstName"].AsString);
Assert.IsTrue(m.IsModified);
// Try to add a new property
int c = n["person"].Count;
Assert.AreEqual(SLJsonNodeType.Missing, n["person"]["newProperty"].NodeType);
n["person"]["newProperty"].AsInt32 = 333;
Assert.AreEqual(c + 1, n["person"].Count);
Assert.AreEqual(SLJsonNodeType.Number, n["person"]["newProperty"].NodeType);
Assert.AreEqual("333", n["person"]["newProperty"].AsString);
// Try to delete a property
c = n["person"].Count;
Assert.AreEqual(SLJsonNodeType.String, n["person"]["lastName"].NodeType);
n["person"]["lastName"].Remove();
Assert.AreEqual(c - 1, n["person"].Count);
Assert.AreEqual(SLJsonNodeType.Missing, n["person"]["lastName"].NodeType);
Assert.IsNull(n["person"]["lastName"].AsString);
}
static void CheckInternal(
SLJsonNode n,
bool isNull, bool isArray, bool isObject, bool isValue, SLJsonNodeType valueType,
bool valueBoolean, int valueInt32, long valueInt64, double valueNumber, string valueString)
{
Assert.AreEqual(isArray, n.IsArray);
Assert.AreEqual(isNull, n.IsNull);
Assert.AreEqual(isObject, n.IsObject);
Assert.AreEqual(isValue, n.IsValue);
Assert.AreEqual(valueType, n.NodeType);
Assert.AreEqual(n.IsBoolean || n.IsNumber || n.IsString, n.IsValue);
Assert.AreEqual(valueType == SLJsonNodeType.Boolean, n.IsBoolean);
Assert.AreEqual(valueType == SLJsonNodeType.Number, n.IsNumber);
Assert.AreEqual(valueType == SLJsonNodeType.String, n.IsString);
Assert.AreEqual(valueBoolean, n.AsBoolean);
Assert.AreEqual(valueInt32, n.AsInt32);
Assert.AreEqual(valueInt64, n.AsInt64);
Assert.IsTrue(Math.Abs(n.AsDouble - valueNumber) <= 1e-7);
Assert.AreEqual(valueString, n.AsString);
}
public void TestSerialization()
{
string s = RetrieveJsonExpression();
SLJsonNode n = ParseAny(s);
n["newProperty"]["value"].AsInt32 = 27;
Assert.AreEqual(SLJsonNodeType.Number, n["newProperty"]["value"].NodeType);
Assert.AreEqual("27", n["newProperty"]["value"].AsJson);
Assert.AreEqual("{\"value\":27}", RemoveWhitespace(n["newProperty"].AsJson));
n["newProperty"]["value"][0].AsInt32 = 100;
n["newProperty"]["value"][3].AsInt32 = 333;
Assert.AreEqual(SLJsonNodeType.Array, n["newProperty"]["value"].NodeType);
Assert.AreEqual("{\"value\":[100,null,null,333]}", n["newProperty"].AsJsonCompact);
n["newProperty"]["value"].AsString = "Text";
Assert.AreEqual(SLJsonNodeType.String, n["newProperty"]["value"].NodeType);
n["newProperty"]["value"].AsString = null;
Assert.AreEqual(SLJsonNodeType.Null, n["newProperty"]["value"].NodeType);
Assert.IsTrue(n["newProperty"]["value"].Remove());
Assert.AreEqual(SLJsonNodeType.Missing, n["newProperty"]["value"].NodeType);
}
static void TestAsJsonCompact(string expected, SLJsonNode node)
{
Assert.AreEqual(expected, node.AsJsonCompact);
}
public void TestReadOnly()
{
string s = RetrieveJsonExpression();
SLJsonNode n = ParseAny(s);
Assert.AreEqual("Jane", n["person"]["firstName"].AsString);
Assert.AreEqual("Doe", n["person"]["lastName"].AsString);
Assert.AreEqual("12345", n["person"]["zipCode"].AsString);
Assert.IsFalse(n["person"]["street"].IsReadOnly);
SLJsonMonitor m = n.CreateMonitor();
Assert.IsFalse(m.IsModified);
Assert.IsFalse(m.IsReadOnly);
m.IsReadOnly = true;
Assert.IsTrue(n["person"]["street"].IsReadOnly);
Assert.IsTrue(n["test"]["emptyArray"].IsArray);
Assert.AreEqual(0, n["test"]["emptyArray"].Count);
Assert.IsTrue(n["test"]["emptyObject"].IsObject);
Assert.AreEqual(0, n["test"]["emptyObject"].Count);
Assert.IsTrue(n["test"]["testArray"].IsArray);
Assert.AreEqual(4, n["test"]["testArray"].Count);
Assert.AreEqual(10, n["test"]["testArray"][0].AsInt32);
Assert.AreEqual(20, n["test"]["testArray"][1].AsInt32);
Assert.AreEqual(30, n["test"]["testArray"][2].AsInt32);
Assert.AreEqual(40, n["test"]["testArray"][3].AsInt32);
Assert.AreEqual(0, n["test"]["testArray"][4].AsInt32); // Access to missing entry
Assert.IsFalse(n["test"]["testArray"][4].IsValue); // Check missing entry
Assert.AreEqual(4, n["test"]["testArray"].Count); // Check count again
Assert.AreEqual(SLJsonNodeType.Object, n["test"]["testObject"].NodeType);
Assert.AreEqual(2, n["test"]["testObject"].Count);
Assert.IsNull(n["test"]["testObject"].AsString);
Assert.AreEqual(SLJsonNodeType.Missing, n["test"]["testValueMissing__"].NodeType);
Assert.IsFalse(n["test"]["testValueMissing__"].AsBoolean);
Assert.AreEqual(0, n["test"]["testValueMissing__"].AsInt32);
Assert.IsNull(n["test"]["testValueMissing__"].AsString);
Assert.AreEqual(SLJsonNodeType.Null, n["test"]["testValueNull"].NodeType);
Assert.IsFalse(n["test"]["testValueNull"].AsBoolean);
Assert.AreEqual(0, n["test"]["testValueNull"].AsInt32);
Assert.IsNull(n["test"]["testValueNull"].AsString);
Assert.AreEqual(SLJsonNodeType.Boolean, n["test"]["testValueTrue"].NodeType);
Assert.IsTrue(n["test"]["testValueTrue"].AsBoolean);
Assert.AreEqual(1, n["test"]["testValueTrue"].AsInt32);
Assert.AreEqual("true", n["test"]["testValueTrue"].AsString);
Assert.AreEqual(SLJsonNodeType.Number, n["test"]["testValue32"].NodeType);
Assert.AreEqual(256, n["test"]["testValue32"].AsInt32);
Assert.AreEqual("256", n["test"]["testValue32"].AsString);
Assert.AreEqual(SLJsonNodeType.String, n["test"]["testValueString1"].NodeType);
Assert.AreEqual("abc 'def' ghi", n["test"]["testValueString1"].AsString);
Assert.AreEqual(SLJsonNodeType.String, n["test"]["testValueString2"].NodeType);
Assert.AreEqual("ABC 'DEF' GHI", n["test"]["testValueString2"].AsString);
Assert.AreEqual(SLJsonNodeType.String, n["test"]["testValueString3"].NodeType);
Assert.AreEqual("First Line\r\nSecond Line\r\nThird Line\0", n["test"]["testValueString3"].AsString);
// .NET MF seems to work internally with zero-terminated strings. As a result the test case fails.
if ("123\0".Length == 4)
{
Assert.AreEqual(@"""First Line\r\nSecond Line\r\nThird Line\u0000""", n["test"]["testValueString3"].AsJsonCompact);
}
Assert.IsFalse(m.IsModified);
Assert.IsTrue(m.IsReadOnly);
}
public void TestOperators()
{
var n = new SLJsonNode();
n["person"]["age"] = 27;
Assert.IsTrue(n["person"]["age"].IsNumber);
Assert.IsTrue(n["person"]["age"] == 27);
Assert.IsTrue(n["person"]["age"] == "27");
n["person"]["age"].AsInt32 = 28;
Assert.IsTrue(n["person"]["age"].IsNumber);
Assert.IsTrue(n["person"]["age"] == 28);
Assert.IsTrue(n["person"]["age"] == "28");
Assert.IsTrue(n["person"]["age"].Remove());
Assert.IsNotNull(n["person"]["age"]);
Assert.IsTrue(n["person"]["age"].IsMissing);
n["person"]["age"].AsString = "29";
Assert.IsTrue(n["person"]["age"].IsString);
Assert.IsTrue(n["person"]["age"] == 29);
Assert.IsTrue(n["person"]["age"] == "29");
n["person"]["age"] = "30";
Assert.IsTrue(n["person"]["age"].IsString);
Assert.IsTrue(n["person"]["age"] == 30);
Assert.IsTrue(n["person"]["age"] == "30");
n["person"]["age"] = null;
Assert.IsTrue(n["person"]["age"].IsNull);
Assert.IsFalse(n["person"]["age"].IsString);
n["person"]["age"] = (string)null;
Assert.IsTrue(n["person"]["age"].IsNull);
Assert.IsFalse(n["person"]["age"].IsString);
n["person"]["age"].AsString = null;
Assert.IsTrue(n["person"]["age"].IsNull);
Assert.IsFalse(n["person"]["age"].IsString);
n["person"]["other"]["property"] = "test_1";
SLJsonNode o = n["person"]["other"]["property"];
Assert.IsTrue(o.IsString);
Assert.AreEqual("test_1", o.AsString);
o.AsString = "test_2";
Assert.AreEqual("test_2", n["person"]["other"]["property"].AsString);
n["person"]["other"][2] = 300;
n["person"]["other"][1] = 200;
n["person"]["other"][0] = 100;
Assert.AreEqual("test_2", o.AsString);
o.AsString = "test_3";
Assert.AreEqual("test_3", o.AsString);
Assert.AreEqual(100, n["person"]["other"][0].AsInt32);
Assert.AreEqual(200, n["person"]["other"][1].AsInt32);
Assert.AreEqual(300, n["person"]["other"][2].AsInt32);
Assert.AreEqual(null, n["person"]["other"]["property"].AsString);
Assert.IsTrue(n["person"]["other"]["property"].IsMissing);
}
