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); }