public static void RunExample1()
{
Console.WriteLine("Example 1");
Console.WriteLine("=========");
Console.WriteLine();
string jsonExpression = @"
{
addressBook: [
{lastName: 'Average', firstName: 'Joe'},
{lastName: 'Doe', firstName: 'Jane'},
{lastName: 'Smith', firstName: 'John'}
]
}";
SLJsonNode root = SLJsonParser.Parse(jsonExpression);
SLJsonNode book = root["addressBook"];
if (book.IsArray)
{
int c = book.Count;
for (int i = 0; i < c; i++)
{
SLJsonNode entry = book[i];
string ln = entry["lastName"];
string fn = entry["firstName"];
Console.WriteLine(fn + " " + ln);
}
}
Console.WriteLine();
}
void Check(
string json,
bool isNull, bool isArray, bool isObject, bool isValue, SLJsonNodeType valueType,
bool valueBoolean, int valueInt32, long valueInt64, double valueNumber, string valueString)
{
SLJsonNode parsed = SLJsonParser.Parse(json);
SLJsonNode n = parsed["value"];
Test.Assert(() => n.IsArray == isArray);
Test.Assert(() => n.IsNull == isNull);
Test.Assert(() => n.IsObject == isObject);
Test.Assert(() => n.IsValue == isValue);
Test.Assert(() => n.NodeType == valueType);
Test.Assert(() => n.IsValue == (n.IsBoolean || n.IsNumber || n.IsString));
Test.Assert(() => n.IsBoolean == (valueType == SLJsonNodeType.Boolean));
Test.Assert(() => n.IsNumber == (valueType == SLJsonNodeType.Number));
Test.Assert(() => n.IsString == (valueType == SLJsonNodeType.String));
Test.Assert(() => n.AsBoolean == valueBoolean);
Test.Assert(() => n.AsInt32 == valueInt32);
Test.Assert(() => n.AsInt64 == valueInt64);
Test.Assert(() => Math.Abs(n.AsDouble - valueNumber) <= 1e-7);
Test.Assert(() => n.AsString == valueString);
}
void ParseAndSerialize(string jsonExpression, bool allowArraysAndValues, SLJsonNodeType nodeType)
{
SLJsonNode n = SLJsonParser.Parse(jsonExpression, allowArraysAndValues);
Test.Assert(() => n.NodeType == nodeType);
string s = RemoveWhitespace(jsonExpression);
Test.Assert(() => n.AsJsonCompact == s);
}
//------------------------------------------------------------------------
public static void RunExample2()
{
Console.WriteLine("Example 2");
Console.WriteLine("=========");
Console.WriteLine();
string jsonExpression = RetrieveJsonExample();
PrintNode(SLJsonParser.Parse(jsonExpression), 0);
Console.WriteLine();
}
//------------------------------------------------------------------------
void ParseInvalid(string jsonExpression, string expectedErrorMessage)
{
try
{
SLJsonParser.Parse(jsonExpression, true);
Test.Assert(() => false);
}
catch (SLJsonException e)
{
Test.Assert(() => e.Message == expectedErrorMessage);
}
}
void TestReadWrite()
{
string s = RetrieveJsonExpression();
SLJsonNode n = SLJsonParser.Parse(s);
SLJsonMonitor m = n.CreateMonitor();
// Try to read some properties
Test.Assert(() => n["person"]["firstName"].AsString == "Jane");
Test.Assert(() => n["person"]["lastName"].AsString == "Doe");
Test.Assert(() => n["person"]["zipCode"].AsString == "12345");
Test.Assert(() => !m.IsModified);
try
{
m.IsReadOnly = true;
n["abc"]["def"][100] = 0;
Test.Assert(() => false);
}
catch (InvalidOperationException)
{
m.IsReadOnly = false;
Test.Assert(() => true);
}
Test.Assert(() => !m.IsModified);
// Try to change an existing property
n["person"]["firstName"].AsString = "John";
Test.Assert(() => n["person"]["firstName"].AsString == "John");
Test.Assert(() => m.IsModified);
// Try to add a new property
int c = n["person"].Count;
Test.Assert(() => n["person"]["newProperty"].NodeType == SLJsonNodeType.Missing);
n["person"]["newProperty"].AsInt32 = 333;
Test.Assert(() => n["person"].Count == c + 1);
Test.Assert(() => n["person"]["newProperty"].NodeType == SLJsonNodeType.Number);
Test.Assert(() => n["person"]["newProperty"].AsString == "333");
// Try to delete a property
c = n["person"].Count;
Test.Assert(() => n["person"]["lastName"].NodeType == SLJsonNodeType.String);
n["person"]["lastName"].Remove();
Test.Assert(() => n["person"].Count == c - 1);
Test.Assert(() => n["person"]["lastName"].NodeType == SLJsonNodeType.Missing);
Test.Assert(() => n["person"]["lastName"].AsString == null);
}
public void Run()
{
Test = new UnitTestHelper();
Test.PrintHeadline("UnitTest3 - Reflection-based Serialization");
var o1 = new ExampleOuter()
{
ValueString = "Test",
ValueStringArray = new string[] { "A", "B,", "C" },
ValueDoubleArray = new double[] { 2, 3.14, 10000 },
PropertyInteger = 27,
PropertyDateTime = new DateTime(2017, 12, 27, 14, 30, 0),
};
o1.ValueObject = new ExampleInner(2);
o1.ValueObjectArray = new ExampleInner[] { new ExampleInner(4), new ExampleInner(6) };
o1.ChangePrivateValue(2.345f);
string s1 = Serialize(o1);
//Console.WriteLine(s1);
var d = new SLJsonDeserializer();
ExampleOuter o2 = d.Deserialize <ExampleOuter>(s1);
string s2 = Serialize(o1);
Test.Assert(() => s1 == s2);
SLJsonNode n1 = SLJsonParser.Parse(s1);
SLJsonNode n2 = n1.Clone();
SLJsonNode n3 = SLJsonParser.Parse(n2.AsJson);
SLJsonNode n4 = SLJsonParser.Parse(n3.AsJsonCompact);
Test.Assert(() => n1 != n2);
CompareNodes(n1, n1);
CompareNodes(n1, n2);
CompareNodes(n1, n3);
CompareNodes(n1, n4);
//Console.WriteLine();
Test.PrintSummary();
Test = null;
}
//------------------------------------------------------------------------
public static void RunExample4()
{
Console.WriteLine("Example 4");
Console.WriteLine("=========");
Console.WriteLine();
string s = @"
{
options: { logging: true },
sensors: [
{ name: 'Button', value: 1 },
{ name: 'Temperature', value: 17.5 }
],
actors: [
{ name: 'Lamp', value: 0 }
]
}";
/*
* Console.WriteLine(s.Trim());
* Console.WriteLine();
* //*/
SLJsonNode n = SLJsonParser.Parse(s);
Console.WriteLine("n.AsJsonCompact => " + n.AsJsonCompact);
Console.WriteLine();
Console.WriteLine("n[\"options\"].NodeType => " + n["options"].NodeType);
Console.WriteLine("n[\"options\"][\"logging\"] => " + n["options"]["logging"]);
Console.WriteLine("n[\"sensors\"].NodeType => " + n["sensors"].NodeType);
Console.WriteLine("n[\"sensors\"].Count => " + n["sensors"].Count);
Console.WriteLine("n[\"sensors\"][0][\"name\"] => " + n["sensors"][0]["name"]);
Console.WriteLine("n[\"sensors\"][1][\"value\"] => " + n["sensors"][1]["value"]);
Console.WriteLine("n[\"missing\"][33][\"foo\"] => " + n["missing"][33]["foo"]);
Console.WriteLine();
}
void TestSerialization()
{
string s = RetrieveJsonExpression();
SLJsonNode n = SLJsonParser.Parse(s);
n["newProperty"]["value"].AsInt32 = 27;
Test.Assert(() => n["newProperty"]["value"].NodeType == SLJsonNodeType.Number);
Test.Assert(() => n["newProperty"]["value"].AsJson == "27");
Test.Assert(() => RemoveWhitespace(n["newProperty"].AsJson) == "{\"value\":27}");
n["newProperty"]["value"][0].AsInt32 = 100;
n["newProperty"]["value"][3].AsInt32 = 333;
Test.Assert(() => n["newProperty"]["value"].NodeType == SLJsonNodeType.Array);
Test.Assert(() => n["newProperty"].AsJsonCompact == "{\"value\":[100,null,null,333]}");
n["newProperty"]["value"].AsString = "Text";
Test.Assert(() => n["newProperty"]["value"].NodeType == SLJsonNodeType.String);
n["newProperty"]["value"].AsString = null;
Test.Assert(() => n["newProperty"]["value"].NodeType == SLJsonNodeType.Null);
Test.Assert(() => n["newProperty"]["value"].Remove());
Test.Assert(() => n["newProperty"]["value"].NodeType == SLJsonNodeType.Missing);
}
public static SLJsonNode Parse(string jsonExpression)
{
return(SLJsonParser.Parse(jsonExpression, true));
}
public T Deserialize <T>(string jsonExpression) where T : new()
{
SLJsonNode n = SLJsonParser.Parse(jsonExpression);
return(Deserialize <T>(n));
}
//------------------------------------------------------------------------
void TestReadOnly()
{
string s = RetrieveJsonExpression();
SLJsonNode n = SLJsonParser.Parse(s);
Test.Assert(() => n["person"]["firstName"].AsString == "Jane");
Test.Assert(() => n["person"]["lastName"].AsString == "Doe");
Test.Assert(() => n["person"]["zipCode"].AsString == "12345");
Test.Assert(() => !n["person"]["street"].IsReadOnly);
SLJsonMonitor m = n.CreateMonitor();
Test.Assert(() => !m.IsModified);
Test.Assert(() => !m.IsReadOnly);
m.IsReadOnly = true;
Test.Assert(() => n["person"]["street"].IsReadOnly);
Test.Assert(() => n["test"]["emptyArray"].IsArray);
Test.Assert(() => n["test"]["emptyArray"].Count == 0);
Test.Assert(() => n["test"]["emptyObject"].IsObject);
Test.Assert(() => n["test"]["emptyObject"].Count == 0);
Test.Assert(() => n["test"]["testArray"].IsArray);
Test.Assert(() => n["test"]["testArray"].Count == 4);
Test.Assert(() => n["test"]["testArray"][0].AsInt32 == 10);
Test.Assert(() => n["test"]["testArray"][1].AsInt32 == 20);
Test.Assert(() => n["test"]["testArray"][2].AsInt32 == 30);
Test.Assert(() => n["test"]["testArray"][3].AsInt32 == 40);
Test.Assert(() => n["test"]["testArray"][4].AsInt32 == 0); // Access to missing entry
Test.Assert(() => !n["test"]["testArray"][4].IsValue); // Check missing entry
Test.Assert(() => n["test"]["testArray"].Count == 4); // Check count again
Test.Assert(() => n["test"]["testObject"].NodeType == SLJsonNodeType.Object);
Test.Assert(() => n["test"]["testObject"].Count == 2);
Test.Assert(() => n["test"]["testObject"].AsString == null);
Test.Assert(() => n["test"]["testValueMissing__"].NodeType == SLJsonNodeType.Missing);
Test.Assert(() => !n["test"]["testValueMissing__"].AsBoolean);
Test.Assert(() => n["test"]["testValueMissing__"].AsInt32 == 0);
Test.Assert(() => n["test"]["testValueMissing__"].AsString == null);
Test.Assert(() => n["test"]["testValueNull"].NodeType == SLJsonNodeType.Null);
Test.Assert(() => !n["test"]["testValueNull"].AsBoolean);
Test.Assert(() => n["test"]["testValueNull"].AsInt32 == 0);
Test.Assert(() => n["test"]["testValueNull"].AsString == null);
Test.Assert(() => n["test"]["testValueTrue"].NodeType == SLJsonNodeType.Boolean);
Test.Assert(() => n["test"]["testValueTrue"].AsBoolean);
Test.Assert(() => n["test"]["testValueTrue"].AsInt32 == 0);
Test.Assert(() => n["test"]["testValueTrue"].AsString == "true");
Test.Assert(() => n["test"]["testValue32"].NodeType == SLJsonNodeType.Number);
Test.Assert(() => n["test"]["testValue32"].AsInt32 == 256);
Test.Assert(() => n["test"]["testValue32"].AsString == "+256");
Test.Assert(() => n["test"]["testValueString1"].NodeType == SLJsonNodeType.String);
Test.Assert(() => n["test"]["testValueString1"].AsString == "abc 'def' ghi");
Test.Assert(() => n["test"]["testValueString2"].NodeType == SLJsonNodeType.String);
Test.Assert(() => n["test"]["testValueString2"].AsString == "ABC 'DEF' GHI");
Test.Assert(() => n["test"]["testValueString3"].NodeType == SLJsonNodeType.String);
Test.Assert(() => n["test"]["testValueString3"].AsString == "First Line\r\nSecond Line\r\nThird Line\0");
// .NET MF seems to work internally with zero-terminated strings. As a result the test case fails.
if ("123\0".Length == 4)
{
Test.Assert(() => n["test"]["testValueString3"].AsJsonCompact == @"""First Line\r\nSecond Line\r\nThird Line\u0000""");
}
Test.Assert(() => !m.IsModified);
Test.Assert(() => m.IsReadOnly);
}
