From 9bb471bdf4a0eff68a3a67452347b947154d756f Mon Sep 17 00:00:00 2001 From: Anton Tarasenko Date: Mon, 6 Mar 2023 03:17:04 +0700 Subject: [PATCH] Add tests for new `JSONPointer` methods --- sources/Text/Tests/TEST_JSON.uc | 514 +++++++++++++++++++++++++++++++- 1 file changed, 513 insertions(+), 1 deletion(-) diff --git a/sources/Text/Tests/TEST_JSON.uc b/sources/Text/Tests/TEST_JSON.uc index ac5de65..79534a8 100644 --- a/sources/Text/Tests/TEST_JSON.uc +++ b/sources/Text/Tests/TEST_JSON.uc @@ -1,6 +1,6 @@ /** * Set of tests for functionality of JSON printing/parsing. - * Copyright 2021-2022 Anton Tarasenko + * Copyright 2021-2023 Anton Tarasenko *------------------------------------------------------------------------------ * This file is part of Acedia. * @@ -22,11 +22,18 @@ class TEST_JSON extends TestCase var string simpleJSONObject, complexJSONObject; +protected static function JSONPointer MakePtr(string str) +{ + return __().json.Pointer(__().text.FromString(str)); +} + protected static function TESTS() { Test_Pointer(); Test_Print(); Test_Parse(); + Test_Copy(); + Test_Incrementing(); } protected static function Test_Pointer() @@ -37,6 +44,10 @@ protected static function Test_Pointer() SubTest_PointerPushPop(); SubTest_PointerNumeric(); SubTest_PopWithoutRemoving(); + SubTest_Append(); + SubText_Copy(); + SubTest_StartsWith(); + SubTest_IsComponentArrayApplicable(); } protected static function SubTest_PointerCreate() @@ -187,6 +198,114 @@ protected static function SubTest_PopWithoutRemoving() TEST_ExpectTrue(pointer.Pop(true).ToString() == "simple"); } +protected static function SubTest_Append() +{ + local JSONPointer pointer, append; + Issue("Appending another JSON pointer is not working correctly."); + pointer = __().json.Pointer(P("/object/hey/1/there/")); + append = __().json.Pointer(P("/A/B/7/C")); + pointer.Append(append); + TEST_ExpectTrue( + pointer.ToText().ToString() + == "/object/hey/1/there//A/B/7/C"); + pointer = __().json.Pointer(P("")); + append = __().json.Pointer(P("/A/B/7/C")); + pointer.Append(append); + TEST_ExpectTrue(pointer.ToText().ToString() == "/A/B/7/C"); + pointer = __().json.Pointer(P("/object/hey/1/there/")); + append = __().json.Pointer(P("")); + pointer.Append(append); + TEST_ExpectTrue(pointer.ToText().ToString() == "/object/hey/1/there/"); + pointer = __().json.Pointer(P("/object/hey/1/there/")); + pointer.Append(none); + TEST_ExpectTrue(pointer.ToText().ToString() == "/object/hey/1/there/"); +} + +protected static function SubText_Copy() +{ + Issue("JSON pointer's `Copy()` method does not correctly copy the whole" + @ "pointer."); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy().ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("/").Copy().ToText().ToString() == "/"); + TEST_ExpectTrue(MakePtr("").Copy().ToText().ToString() == ""); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(0, 4).ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(-2).ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(0, 7).ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(-3, 7).ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(-5, 20).ToText().ToString() + == "/A/B/3/D"); + TEST_ExpectTrue(MakePtr("").Copy(-1).ToText().ToString() == ""); + + Issue("JSON pointer's `Copy()` method does not correctly copy empty range" + @ "of the pointer."); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(-5, 4).ToText().ToString() == ""); + TEST_ExpectTrue(MakePtr("/A/B/3/D").Copy(4, 11).ToText().ToString() == ""); + + Issue("JSON pointer's `Copy()` method does not correctly copy partial" + @ "intersection range of the pointer."); + TEST_ExpectTrue(MakePtr("/A//3/D").Copy(-5, 8).ToText().ToString() + == "/A//3"); // left + TEST_ExpectTrue(MakePtr("/A//3/D").Copy(1, 11).ToText().ToString() + == "//3/D"); // right +} + +protected static function SubTest_StartsWith() +{ + local JSONPointer pointer; + + Issue("Any pointers start with `none` JSON pointer."); + TEST_ExpectTrue(__().json.Pointer(P("/A/B/C")).StartsWith(none)); + TEST_ExpectTrue(__().json.Pointer(P("/")).StartsWith(none)); + TEST_ExpectTrue(__().json.Pointer(P("")).StartsWith(none)); + + Issue("`StartsWith()` correctly detects JSON pointers that are actually" + @ "their prefixes."); + TEST_ExpectTrue(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("/A/7/C")))); + // Same, but constructed manually to handle components added as numeric + pointer = __().json.Pointer().Push(P("A")).PushNumeric(7).Push(P("C")); + TEST_ExpectTrue(pointer.StartsWith(__().json.Pointer(P("/A/7/C")))); + TEST_ExpectTrue(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("/A/7")))); + TEST_ExpectTrue(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("")))); + TEST_ExpectTrue(__().json.Pointer(P("")) + .StartsWith(__().json.Pointer(P("")))); + + Issue("`StartsWith()` correctly detects JSON pointers that aren't actually" + @ "their prefixes."); + TEST_ExpectFalse(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("/A/3/C")))); + // Constructed manually to handle components added as numeric + pointer = __().json.Pointer().Push(P("A")).PushNumeric(8).Push(P("C")); + TEST_ExpectFalse(pointer.StartsWith(__().json.Pointer(P("/A/3/C")))); + TEST_ExpectFalse(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("/A/7/")))); + TEST_ExpectFalse(__().json.Pointer(P("/A/7/C")) + .StartsWith(__().json.Pointer(P("/")))); +} + +protected static function SubTest_IsComponentArrayApplicable() +{ + Issue("`IsComponentArrayApplicable()` method wrongly detects numeric" + @ "components."); + TEST_ExpectFalse( + __().json.Pointer(P("/A/B/C")).IsComponentArrayApplicable(0)); + TEST_ExpectTrue( + __().json.Pointer(P("/A/2/C")).IsComponentArrayApplicable(1)); + TEST_ExpectTrue( + __().json.Pointer(P("/A/B/-")).IsComponentArrayApplicable(2)); + TEST_ExpectFalse( + __().json.Pointer(P("/A/7/C")).IsComponentArrayApplicable(-2)); + TEST_ExpectFalse( + __().json.Pointer(P("/A/7/C")).IsComponentArrayApplicable(10)); +} + protected static function Test_Print() { Context("Testing printing simple JSON values."); @@ -651,6 +770,399 @@ protected static function SubTest_ParseComplex() TEST_ExpectTrue(FloatBox(inner.GetItem(P("maybe"))).Get() == 0.003); } +protected static function Test_Copy() +{ + Context("Testing method for copying JSON values."); + SubTest_CopySimple(); + SubTest_CopyComplex(); +} + +protected static function SubTest_CopySimple() +{ + Issue("JSON's `Copy()` method incorrectly copies copy boxed built-in" + @ "types."); + TEST_ExpectNone(__().json.Copy(none)); + TEST_ExpectTrue( + BoolBox(__().json.Copy(__().box.bool(true))).Get() + == true); + TEST_ExpectTrue( + BoolRef(__().json.Copy(__().ref.bool(false))).Get() + == false); + TEST_ExpectTrue(IntBox(__().json.Copy(__().box.int(-7))).Get() == -7); + TEST_ExpectTrue( + IntRef(__().json.Copy(__().ref.int(234234))).Get() + == 234234); + TEST_ExpectTrue( + FloatBox(__().json.Copy(__().box.float(3.76))).Get() + == 3.76); + TEST_ExpectTrue( + FloatRef(__().json.Copy(__().ref.float(-213.1))).Get() + == -213.1); + TEST_ExpectTrue(Text(__().json.Copy(P("Hey!"))).ToString() == "Hey!"); + TEST_ExpectTrue( + MutableText(__().json.Copy(__().text.FromStringM("Hey!"))) + .ToString() + == "Hey!"); +} + +protected static function HashTable ConstructComplexJSONObject() +{ + local HashTable result, innerObject, deepObject, oneMoreObject; + local ArrayList innerArray; + + deepObject = __().collections.EmptyHashTable(); + deepObject.SetItem(P("something \"here\""), P("yes")); + deepObject.SetFloat(P("maybe"), 0.003); + innerArray = __().collections.EmptyArrayList(); + innerArray.AddString("Engine.Actor"); + innerArray.AddBool(false); + innerArray.AddItem(none); + innerArray.AddItem(deepObject); + innerArray.AddFloat(56.6); + oneMoreObject = __().collections.EmptyHashTable(); + oneMoreObject.SetInt(P("nope"), 324532); + oneMoreObject.SetBool(P("whatever"), false); + oneMoreObject.SetString(P("o rly?"), "ya rly"); + innerObject = __().collections.EmptyHashTable(); + innerObject.SetBool(P("my_bool"), true); + innerObject.SetItem(P("array"), innerArray); + innerObject.SetItem(P("one more"), oneMoreObject); + innerObject.SetInt(P("my_int"), -9823452); + result = __().collections.EmptyHashTable(); + result.SetItem(P("innerObject"), innerObject); + result.SetFloat(P("some_var"), -7.32); + result.SetString(P("another_var"), "aye!"); + return result; +} + +protected static function SubTest_CopyComplex() +{ + local HashTable complexCopy; + + complexCopy = HashTable(__().json.Copy(ConstructComplexJSONObject())); + TEST_ExpectTrue(complexCopy.GetBoolBy(P("/innerObject/my_bool")) == true); + TEST_ExpectTrue( + complexCopy.GetStringBy(P("/innerObject/array/0")) == "Engine.Actor"); + TEST_ExpectTrue( + complexCopy.GetBoolBy(P("/innerObject/array/1")) == false); + TEST_ExpectTrue( + complexCopy.GetItemBy(P("/innerObject/array/2")) == none); + TEST_ExpectTrue( + complexCopy.GetStringBy(P("/innerObject/array/3/something \"here\"")) + == "yes"); + TEST_ExpectTrue( + complexCopy.GetFloatBy(P("/innerObject/array/3/maybe")) == 0.003); + TEST_ExpectTrue( + complexCopy.GetFloatBy(P("/innerObject/array/4")) == 56.6); + TEST_ExpectTrue( + complexCopy.GetIntBy(P("/innerObject/one more/nope")) == 324532); + TEST_ExpectTrue( + complexCopy.GetBoolBy(P("/innerObject/one more/whatever")) == false); + TEST_ExpectTrue( + complexCopy.GetStringBy(P("/innerObject/one more/o rly?")) == "ya rly"); + TEST_ExpectTrue( + complexCopy.GetIntBy(P("/innerObject/my_int")) == -9823452); + TEST_ExpectTrue( + complexCopy.GetFloatBy(P("/some_var")) == -7.32); + TEST_ExpectTrue( + complexCopy.GetStringBy(P("/another_var")) == "aye!"); +} + +protected static function Test_Incrementing() +{ + Context("Testing incrementing JSON values with `_.json.Increment()`."); + SubTest_Incrementing_Null(); + SubTest_Incrementing_Bool(); + SubTest_Incrementing_Number(); + SubTest_Incrementing_String(); + SubTest_Incrementing_Array(); + SubTest_Incrementing_Object(); + SubTest_Incrementing_Incompatible(); +} + +protected static function SubTest_Incrementing_Null() +{ + local FloatRef ref; + + Issue("Null values aren't incremented correctly."); + TEST_ExpectNone(__().json.Increment(none, none)); + TEST_ExpectTrue(BoolBox(__().json.Increment( + none, __().box.bool(true))).Get() == true); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.float(11.5), none)).Get() == 11.5); + + Issue("Incrementing null values simply copies reference."); + ref = __().ref.float(1032423.91); + TEST_ExpectFalse(__().json.Increment(ref, none) == none); + TEST_ExpectFalse(__().json.Increment(none, ref) == none); +} + +protected static function SubTest_Incrementing_Bool() +{ + Issue("Boolean values aren't incremented correctly."); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(false), __().box.bool(false))).Get() == false); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(true), __().box.bool(false))).Get() == true); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(false), __().box.bool(true))).Get() == true); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(true), __().box.bool(true))).Get() == true); + + Issue("Incrementing boolean values produces incorrect type."); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(false), __().box.bool(true))).Get() == true); + TEST_ExpectTrue(BoolBox(__().json.Increment( + __().box.bool(false), __().ref.bool(true))).Get() == true); + TEST_ExpectTrue(BoolRef(__().json.Increment( + __().ref.bool(false), __().box.bool(true))).Get() == true); + TEST_ExpectTrue(BoolRef(__().json.Increment( + __().ref.bool(false), __().ref.bool(true))).Get() == true); +} + +protected static function SubTest_Incrementing_Number() +{ + SubSubTest_Incrementing_Number_Pure(); + SubSubTest_Incrementing_Number_Mixed(); +} + +protected static function SubSubTest_Incrementing_Number_Pure() +{ + Issue("Numeric values aren't incremented correctly (for boxed `int`s)."); + TEST_ExpectTrue(IntBox(__().json.Increment( + __().box.int(3), __().box.int(-3))).Get() == 0); + TEST_ExpectTrue(IntBox(__().json.Increment( + __().box.int(-4), __().ref.int(11))).Get() == 7); + TEST_ExpectTrue(IntRef(__().json.Increment( + __().ref.int(124), __().box.int(624))).Get() == 748); + TEST_ExpectTrue(IntRef(__().json.Increment( + __().ref.int(345), __().ref.int(-23423))).Get() == -23078); + + Issue("Numeric values aren't incremented correctly (for boxed `float`s)."); + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.float(11.2), __().box.float(-0.2))).Get() == 11); + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.float(1012.78), __().ref.float(0.12))).Get() == 1012.9); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.float(12), __().box.float(13))).Get() == 25); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.float(-0.32), __().ref.float(0.32))).Get() == 0); +} + +protected static function SubSubTest_Incrementing_Number_Mixed() +{ + Issue("Numeric values aren't incremented correctly (for mixed `int`s and" + @ "`float`s)."); + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.float(11.2), __().box.int(0))).Get() == 11.2); + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.float(1012.78), __().ref.int(2))).Get() == 1014.78); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.float(12), __().box.int(13))).Get() == 25); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.float(-0.32), __().ref.int(14))).Get() == 13.68); + + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.int(11), __().box.float(-0.2))).Get() == 10.8); + TEST_ExpectTrue(FloatBox(__().json.Increment( + __().box.int(1012), __().ref.float(7.12))).Get() == 1019.12); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.int(12), __().box.float(13.1))).Get() == 25.1); + TEST_ExpectTrue(FloatRef(__().json.Increment( + __().ref.int(-10), __().ref.float(0.32))).Get() == -9.68); +} + +protected static function SubTest_Incrementing_String() +{ + Issue("String values aren't incremented correctly."); + TEST_ExpectTrue(Text(__().json.Increment( + __().text.FromString("Whatever"), __().text.FromString("revetahW"))) + .ToString() == "WhateverrevetahW"); + TEST_ExpectTrue(MutableText(__().json.Increment( + __().text.FromStringM("Whatever"), __().text.FromString("revetahW"))) + .ToString() == "WhateverrevetahW"); + TEST_ExpectTrue(Text(__().json.Increment( + __().text.FromString("Whatever"), __().text.FromStringM("revetahW"))) + .ToString() == "WhateverrevetahW"); + TEST_ExpectTrue(MutableText(__().json.Increment( + __().text.FromStringM("Whatever"), __().text.FromStringM("revetahW"))) + .ToString() == "WhateverrevetahW"); +} + +protected static function SubTest_Incrementing_Array() +{ + local ArrayList array1, array2, result; + + Issue("Array values aren't incremented correctly."); + array1 = __().collections.EmptyArrayList(); + array2 = __().collections.EmptyArrayList(); + array1.AddItem(__().box.int(5)); + array2.AddItem(__().box.int(3)); + array2.AddItem(__().box.int(-7)); + result = ArrayList(__().json.Increment(array1, array2)); + TEST_ExpectTrue(__().json.Print(result).ToString() == "[5,3,-7]"); + TEST_ExpectTrue(result.GetItem(0) != array1.GetItem(0)); + TEST_ExpectTrue(result.GetItem(1) != array2.GetItem(0)); + TEST_ExpectTrue(result.GetItem(2) != array2.GetItem(1)); + + Issue("Incrementing array values incorrectly handles reference counts."); + // +1 after copy, +2 after getters (before and here) + TEST_ExpectTrue(result.GetItem(0)._getRefCount() == 3); + TEST_ExpectTrue(result.GetItem(1)._getRefCount() == 3); + TEST_ExpectTrue(result.GetItem(2)._getRefCount() == 3); + TEST_ExpectTrue(array1._getRefCount() == 1); + TEST_ExpectTrue(array2._getRefCount() == 1); + TEST_ExpectTrue(result._getRefCount() == 1); +} + +protected static function SubTest_Incrementing_Object() +{ + local HashTable table1, table2, result; + + Issue("Object values aren't incremented correctly."); + table1 = __().collections.EmptyHashTable(); + table2 = __().collections.EmptyHashTable(); + table1.Setitem(P("A"), __().box.int(5)); + table2.Setitem(P("B"), __().box.int(3)); + table2.Setitem(P("C"), __().box.int(-7)); + result = HashTable(__().json.Increment(table1, table2)); + TEST_ExpectTrue(result.GetLength() == 3); + TEST_ExpectTrue(result.GetInt(P("A")) == 5); + TEST_ExpectTrue(result.GetInt(P("B")) == 3); + TEST_ExpectTrue(result.GetInt(P("C")) == -7); + TEST_ExpectTrue(result.GetItem(P("A")) != table1.GetItem(P("A"))); + TEST_ExpectTrue(result.GetItem(P("B")) != table2.GetItem(P("B"))); + TEST_ExpectTrue(result.GetItem(P("C")) != table2.GetItem(P("C"))); + + // +1 after copy, +2 after getters (before and here) + Issue("Incrementing object values incorrectly handles reference counts."); + TEST_ExpectTrue(result.GetItem(P("A"))._getRefCount() == 3); + TEST_ExpectTrue(result.GetItem(P("B"))._getRefCount() == 3); + TEST_ExpectTrue(result.GetItem(P("C"))._getRefCount() == 3); + TEST_ExpectTrue(table1._getRefCount() == 1); + TEST_ExpectTrue(table2._getRefCount() == 1); + TEST_ExpectTrue(result._getRefCount() == 1); +} + +protected static function SubTest_Incrementing_Incompatible() +{ + Issue("Incrementing with incompatible values doesn't produce `none`."); + SubSubTest_Incrementing_Incompatible_bool(); + SubSubTest_Incrementing_Incompatible_int(); + SubSubTest_Incrementing_Incompatible_float(); + SubSubTest_Incrementing_Incompatible_text(); + SubSubTest_Incrementing_Incompatible_arraylist(); + SubSubTest_Incrementing_Incompatible_hashtable(); +} + +protected static function SubSubTest_Incrementing_Incompatible_bool() +{ + TEST_ExpectNone(__().json.Increment( + __().box.bool(true), + __().ref.int(32))); + TEST_ExpectNone(__().json.Increment( + __().box.bool(true), + __().ref.float(32.5))); + TEST_ExpectNone(__().json.Increment( + __().box.bool(true), + __().text.FromString("Hello there!"))); + TEST_ExpectNone(__().json.Increment( + __().box.bool(true), + __().collections.EmptyArrayList())); + TEST_ExpectNone(__().json.Increment( + __().box.bool(true), + __().collections.EmptyHashTable())); +} + +protected static function SubSubTest_Incrementing_Incompatible_int() +{ + TEST_ExpectNone(__().json.Increment( + __().box.int(3), + __().ref.bool(false))); + TEST_ExpectNone(__().json.Increment( + __().box.int(234), + __().text.FromString("Hello there!"))); + TEST_ExpectNone(__().json.Increment( + __().box.int(2), + __().collections.EmptyArrayList())); + TEST_ExpectNone(__().json.Increment( + __().box.int(782), + __().collections.EmptyHashTable())); +} + +protected static function SubSubTest_Incrementing_Incompatible_float() +{ + TEST_ExpectNone(__().json.Increment( + __().box.float(3), + __().ref.bool(false))); + TEST_ExpectNone(__().json.Increment( + __().box.float(234), + __().text.FromString("Hello there!"))); + TEST_ExpectNone(__().json.Increment( + __().box.float(2), + __().collections.EmptyArrayList())); + TEST_ExpectNone(__().json.Increment( + __().box.float(782), + __().collections.EmptyHashTable())); +} + +protected static function SubSubTest_Incrementing_Incompatible_text() +{ + TEST_ExpectNone(__().json.Increment( + __().text.FromString("yo"), + __().ref.bool(true))); + TEST_ExpectNone(__().json.Increment( + __().text.FromString("yo"), + __().ref.int(32))); + TEST_ExpectNone(__().json.Increment( + __().text.FromString("yo"), + __().ref.float(32.5))); + TEST_ExpectNone(__().json.Increment( + __().text.FromString("yo"), + __().collections.EmptyArrayList())); + TEST_ExpectNone(__().json.Increment( + __().text.FromString("yo"), + __().collections.EmptyHashTable())); +} + +protected static function SubSubTest_Incrementing_Incompatible_arraylist() +{ + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyArrayList(), + __().ref.bool(true))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyArrayList(), + __().ref.int(32))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyArrayList(), + __().ref.float(32.5))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyArrayList(), + __().text.FromString("Not a collection!"))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyArrayList(), + __().collections.EmptyHashTable())); +} + +protected static function SubSubTest_Incrementing_Incompatible_hashtable() +{ + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyHashTable(), + __().ref.bool(true))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyHashTable(), + __().ref.int(32))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyHashTable(), + __().ref.float(32.5))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyHashTable(), + __().text.FromString("Not a collection!"))); + TEST_ExpectNone(__().json.Increment( + __().collections.EmptyHashTable(), + __().collections.EmptyArrayList())); +} + defaultproperties { caseName = "JSON"