public void TestReflection_Array() { var expectedTest = ""; var json = ""; var testClass = new SeveralTypesTest(); testClass.Populate(); var expressionResult1 = testClass.FieldPublicArrayUni.AsReflection().Query().ToString(); expectedTest = "{System.String[]_0} + [0]: \"[0]\" + [1]: \"[1]\""; json = ToJson(testClass.FieldPublicArrayUni); AssertTrue(expressionResult1 == expectedTest, "ArrayUni"); var expressionResult2 = testClass.FieldPublicArrayTwo.AsReflection().Query().ToString(); expectedTest = "{System.String[,]_0} + [0,0]: \"[0, 0]\" + [0,1]: \"[0, 1]\" + [1,0]: \"[1, 0]\" + [1,1]: \"[1, 1]\""; json = ToJson(testClass.FieldPublicArrayTwo); AssertTrue(expressionResult2 == expectedTest, "ArrayTwo"); var expressionResult3 = testClass.FieldPublicArrayThree.AsReflection().Query().ToString(); expectedTest = "{System.String[,,]_0} + [0,0,0]: \"[0, 0, 0]\" + [0,0,1]: \"[0, 0, 1]\""; json = ToJson(testClass.FieldPublicArrayThree); AssertTrue(expressionResult3 == expectedTest, "ArrayThree"); var expressionResult4 = testClass.FieldPublicJaggedArrayTwo.AsReflection().Query().ToString(); expectedTest = "{System.String[][]_0} + ([0]: {System.String[]_1} + [0]: \"a\" + [1]: \"b\" + [2]: \"c\" + [3]: \"d\" + [4]: \"e\") + ([1]: {System.String[]_7} + [0]: \"a1\" + [1]: \"b1\" + [2]: \"c1\" + [3]: \"d1\")"; json = ToJson(testClass.FieldPublicJaggedArrayTwo); AssertTrue(expressionResult4 == expectedTest, "JaggedArrayTwo"); var expressionResult5 = testClass.FieldPublicJaggedArrayThree.AsReflection().Query().ToString(); expectedTest = "{System.String[][][]_0} + ([0]: {System.String[][]_1} + ([0]: {System.String[]_2} + [0]: \"[0][0][0]\" + [1]: \"[0][0][1]\"))"; json = ToJson(testClass.FieldPublicJaggedArrayThree); AssertTrue(expressionResult5 == expectedTest, "JaggedArrayThree"); var expressionResult6 = testClass.FieldPublicArrayListNonGeneric.AsReflection().Query().ToString(); expectedTest = "{System.Collections.ArrayList_0} + [0]: 1 + [1]: \"a\" + [2]: 10.0 + [3]: \"2000-01-01T00:00:00.000-02:00\""; json = ToJson(testClass.FieldPublicArrayListNonGeneric); AssertTrue(expressionResult6 == expectedTest, "ArrayList"); var expressionResult7 = testClass.FieldPublicBitArray.AsReflection().Query().ToString(); expectedTest = "{System.Collections.BitArray_0} + [0]: false + [1]: false + [2]: true"; json = ToJson(testClass.FieldPublicBitArray); AssertTrue(expressionResult7 == expectedTest, "BitArray"); // is normal "int[,][]" is changed by "int[][,]". The .net make it. // ** Newtonsoft Json have different return expectations ** var expressionResult8 = testClass.FieldPublicMixedArrayAndJagged.AsReflection().Query().ToString(); expectedTest = "{System.Int32[,][]_0} + ([0]: {System.Int32[,]_1} + [0,0]: 1 + [0,1]: 3 + [1,0]: 5 + [1,1]: 7) + ([1]: {System.Int32[,]_6} + [0,0]: 0 + [0,1]: 2 + [1,0]: 4 + [1,1]: 6 + [2,0]: 8 + [2,1]: 10) + ([2]: {System.Int32[,]_13} + [0,0]: 11 + [0,1]: 22 + [1,0]: 99 + [1,1]: 88 + [2,0]: 0 + [2,1]: 9)"; json = ToJson(testClass.FieldPublicMixedArrayAndJagged); AssertTrue(expressionResult8 == expectedTest, "MixedArrayAndJagged"); }
public void TestReflection_Lists() { var expectedTest = ""; var json = ""; var testClass = new SeveralTypesTest(); testClass.Populate(); var expressionResult1 = GetString(testClass.FieldPublicDictionary); expectedTest = "{System.Collections.Generic.Dictionary<System.String, System.String>_0} + [\"Key1\"]: \"Value1\" + [\"Key2\"]: \"Value2\" + [\"Key3\"]: \"Value3\" + [\"Key4\"]: \"Value4\""; json = ToJson(testClass.FieldPublicDictionary); AssertTrue(expressionResult1 == expectedTest, "Dictionary"); var expressionResult2 = GetString(testClass.FieldPublicList); expectedTest = "{System.Collections.Generic.List<System.Int32>_0} + [0]: 0 + [1]: 1 + [2]: 2"; json = ToJson(testClass.FieldPublicList); AssertTrue(expressionResult2 == expectedTest, "List<int>"); var expressionResult3 = GetString(testClass.FieldPublicQueue); expectedTest = "{System.Collections.Generic.Queue<System.Int32>_0} + [0]: 10 + [1]: 11 + [2]: 12"; json = ToJson(testClass.FieldPublicQueue); AssertTrue(expressionResult3 == expectedTest, "Queue<int>"); var expressionResult4 = GetString(testClass.FieldPublicHashSet); expectedTest = "{System.Collections.Generic.HashSet<System.String>_0} + [0]: \"HashSet1\" + [1]: \"HashSet2\""; json = ToJson(testClass.FieldPublicHashSet); AssertTrue(expressionResult4 == expectedTest, "HashSet<string>"); var expressionResult5 = GetString(testClass.FieldPublicSortedSet); expectedTest = "{System.Collections.Generic.SortedSet<System.String>_0} + [0]: \"SortedSet1\" + [1]: \"SortedSet2\" + [2]: \"SortedSet3\""; json = ToJson(testClass.FieldPublicSortedSet); AssertTrue(expressionResult5 == expectedTest, "SortedSet<string>"); var expressionResult6 = GetString(testClass.FieldPublicStack); expectedTest = "{System.Collections.Generic.Stack<System.String>_0} + [0]: \"Stack3\" + [1]: \"Stack2\" + [2]: \"Stack1\""; json = ToJson(testClass.FieldPublicStack); AssertTrue(expressionResult6 == expectedTest, "Stack<string>"); var expressionResult7 = GetString(testClass.FieldPublicLinkedList); expectedTest = "{System.Collections.Generic.LinkedList<System.String>_0} + [0]: \"LinkedList1\" + [1]: \"LinkedList1.1\" + [2]: \"LinkedList2\""; json = ToJson(testClass.FieldPublicLinkedList); AssertTrue(expressionResult7 == expectedTest, "LinkedList<string>"); var expressionResult8 = GetString(testClass.FieldPublicObservableCollection); expectedTest = "{System.Collections.ObjectModel.ObservableCollection<System.String>_0} + [0]: \"ObservableCollection1\" + [1]: \"ObservableCollection2\""; json = ToJson(testClass.FieldPublicObservableCollection); AssertTrue(expressionResult8 == expectedTest, "ObservableCollection<string>"); var expressionResult9 = GetString(testClass.FieldPublicKeyedCollection); expectedTest = "{MyDataKeyedCollection_0} + ([0]: {MyData_1} + Id: 0 + Data: \"data1\") + ([1]: {MyData_4} + Id: 1 + Data: \"data2\")"; json = ToJson(testClass.FieldPublicKeyedCollection); AssertTrue(expressionResult9 == expectedTest, "KeyedCollection<int, MyData>"); var expressionResult10 = GetString(testClass.FieldPublicReadOnlyCollection); expectedTest = "{System.Collections.ObjectModel.ReadOnlyCollection<System.String>_0} + [0]: \"list1\" + [1]: \"list2\" + [2]: \"list3\""; json = ToJson(testClass.FieldPublicReadOnlyCollection); AssertTrue(expressionResult10 == expectedTest, "ReadOnlyCollection<string>"); var expressionResult11 = GetString(testClass.FieldPublicReadOnlyDictionary); expectedTest = "{System.Collections.ObjectModel.ReadOnlyDictionary<System.String, System.String>_0} + [\"Key1\"]: \"Value1\" + [\"Key2\"]: \"Value2\" + [\"Key3\"]: \"Value3\" + [\"Key4\"]: \"Value4\""; json = ToJson(testClass.FieldPublicReadOnlyDictionary); AssertTrue(expressionResult11 == expectedTest, "ReadOnlyDictionary<string, string>"); var expressionResult12 = GetString(testClass.FieldPublicArrayListNonGeneric); expectedTest = "{System.Collections.ArrayList_0} + [0]: 1 + [1]: \"a\" + [2]: 10.0 + [3]: \"2000-01-01T00:00:00.000-02:00\""; json = ToJson(testClass.FieldPublicArrayListNonGeneric); AssertTrue(expressionResult12 == expectedTest, "ArrayList"); var expressionResult13 = GetString(testClass.FieldPublicBitArray); expectedTest = "{System.Collections.BitArray_0} + [0]: false + [1]: false + [2]: true"; json = ToJson(testClass.FieldPublicBitArray); AssertTrue(expressionResult13 == expectedTest, "BitArray"); var expressionResult14 = GetString(testClass.FieldPublicSortedList); expectedTest = "{System.Collections.SortedList_0} + [\"key1\"]: 1 + [\"key2\"]: 2 + [\"key3\"]: 3 + [\"key4\"]: 4"; json = ToJson(testClass.FieldPublicSortedList); AssertTrue(expressionResult14 == expectedTest, "SortedList"); var expressionResult15 = GetString(testClass.FieldPublicHashtableNonGeneric); expectedTest = "{System.Collections.Hashtable_0} + [\"key2\"]: 2 + [\"key3\"]: 3 + [\"key1\"]: 1 + [\"key4\"]: 4"; json = ToJson(testClass.FieldPublicHashtableNonGeneric); AssertTrue(expressionResult15 == expectedTest, "Hashtable"); var expressionResult16 = GetString(testClass.FieldPublicQueueNonGeneric); expectedTest = "{System.Collections.Queue_0} + [0]: \"QueueNonGeneric1\" + [1]: \"QueueNonGeneric2\" + [2]: \"QueueNonGeneric3\""; json = ToJson(testClass.FieldPublicQueueNonGeneric); AssertTrue(expressionResult16 == expectedTest, "Queue"); var expressionResult17 = GetString(testClass.FieldPublicStackNonGeneric); expectedTest = "{System.Collections.Stack_0} + [0]: \"StackNonGeneric2\" + [1]: \"StackNonGeneric1\""; json = ToJson(testClass.FieldPublicStackNonGeneric); AssertTrue(expressionResult17 == expectedTest, "Stack"); var expressionResult18 = GetString(testClass.FieldPublicIEnumerable); expectedTest = "{System.Collections.SortedList_0} + [\"key1\"]: 1 + [\"key2\"]: 2 + [\"key3\"]: 3 + [\"key4\"]: 4"; json = ToJson(testClass.FieldPublicIEnumerable); AssertTrue(expressionResult18 == expectedTest, "IEnumerable"); var expressionResult19 = GetString(testClass.FieldPublicBlockingCollection); expectedTest = "{System.Collections.Concurrent.BlockingCollection<System.String>_0} + [0]: \"BlockingCollection1\" + [1]: \"BlockingCollection2\""; json = ToJson(testClass.FieldPublicBlockingCollection); AssertTrue(expressionResult19 == expectedTest, "BlockingCollection<string>"); var expressionResult20 = GetString(testClass.FieldPublicConcurrentBag); expectedTest = "{System.Collections.Concurrent.ConcurrentBag<System.String>_0} + [0]: \"ConcurrentBag3\" + [1]: \"ConcurrentBag2\" + [2]: \"ConcurrentBag1\""; json = ToJson(testClass.FieldPublicConcurrentBag); AssertTrue(expressionResult20 == expectedTest, "ConcurrentBag<string>"); var expressionResult21 = GetString(testClass.FieldPublicConcurrentDictionary); expectedTest = "{System.Collections.Concurrent.ConcurrentDictionary<System.String, System.Int32>_0} + [\"ConcurrentDictionary2\"]: 0 + [\"ConcurrentDictionary1\"]: 0"; json = ToJson(testClass.FieldPublicConcurrentDictionary); AssertTrue(expressionResult21 == expectedTest, "ConcurrentDictionary<string, int>"); var expressionResult22 = GetString(testClass.FieldPublicConcurrentQueue); expectedTest = "{System.Collections.Concurrent.ConcurrentQueue<System.String>_0} + [0]: \"ConcurrentQueue1\" + [1]: \"ConcurrentQueue2\""; json = ToJson(testClass.FieldPublicConcurrentQueue); AssertTrue(expressionResult22 == expectedTest, "ConcurrentQueue<string>"); var expressionResult23 = GetString(testClass.FieldPublicConcurrentStack); expectedTest = "{System.Collections.Concurrent.ConcurrentStack<System.String>_0} + [0]: \"ConcurrentStack2\" + [1]: \"ConcurrentStack1\""; json = ToJson(testClass.FieldPublicConcurrentStack); AssertTrue(expressionResult23 == expectedTest, "ConcurrentStack<string>"); var expressionResult24 = GetString(testClass.FieldPublicHybridDictionary); expectedTest = "{System.Collections.Specialized.HybridDictionary_0} + [\"HybridDictionaryKey1\"]: \"HybridDictionary1\" + [\"HybridDictionaryKey2\"]: \"HybridDictionary2\""; json = ToJson(testClass.FieldPublicHybridDictionary); AssertTrue(expressionResult24 == expectedTest, "HybridDictionary"); var expressionResult25 = GetString(testClass.FieldPublicListDictionary); expectedTest = "{System.Collections.Specialized.ListDictionary_0} + [\"ListDictionaryKey1\"]: \"ListDictionary1\" + [\"ListDictionaryKey2\"]: \"ListDictionary2\""; json = ToJson(testClass.FieldPublicListDictionary); AssertTrue(expressionResult25 == expectedTest, "ListDictionary"); var expressionResult26 = GetString(testClass.FieldPublicNameValueCollection); expectedTest = "{System.Collections.Specialized.NameValueCollection_0} + [0]: \"Key1\" + [1]: \"Key2\""; json = ToJson(testClass.FieldPublicNameValueCollection); AssertTrue(expressionResult26 == expectedTest, "NameValueCollection"); var expressionResult27 = GetString(testClass.FieldPublicOrderedDictionary); expectedTest = "{System.Collections.Specialized.OrderedDictionary_0} + [1]: \"OrderedDictionary1\" + [2]: \"OrderedDictionary1\" + [\"OrderedDictionaryKey2\"]: \"OrderedDictionary2\""; json = ToJson(testClass.FieldPublicOrderedDictionary); AssertTrue(expressionResult27 == expectedTest, "OrderedDictionary"); var expressionResult28 = GetString(testClass.FieldPublicStringCollection); expectedTest = "{System.Collections.Specialized.StringCollection_0} + [0]: \"StringCollection1\" + [1]: \"StringCollection2\""; json = ToJson(testClass.FieldPublicStringCollection); AssertTrue(expressionResult28 == expectedTest, "StringCollection"); }
public void TestReflection_Primitives() { var expectedTest = ""; var json = ""; var testClass = new SeveralTypesTest(); testClass.Populate(); #region Types of Keywords var expressionResult1 = Extensions.AsReflection(testClass.FieldPublicDynamic).Query().ToString(); expectedTest = "{<>f__AnonymousType1<System.String, System.Int32, System.String, System.String, System.String, System.String, System.String, System.String, System.String, System.String, System.String, <>f__AnonymousType0<System.Int32, System.Int32, System.Int32>>_0} + PropPublic1: \"A\" + PropPublic2: 1 + PropPublic3: \"B\" + PropPublic4: \"B\" + PropPublic5: \"B\" + PropPublic6: \"B\" + PropPublic7: \"B\" + PropPublic8: \"B\" + PropPublic9: \"B\" + PropPublic10: \"B\" + PropPublic11: \"B\" + (PropPublic12: {<>f__AnonymousType0<System.Int32, System.Int32, System.Int32>_12} + PropSubPublic1: 0 + PropSubPublic2: 1 + PropSubPublic3: 2)"; json = ToJson(testClass.FieldPublicDynamic); AssertTrue(expressionResult1 == expectedTest, "Dynamic"); // ** Newtonsoft Json have different return expectations ** var expressionResult2 = GetString(testClass.FieldPublicObject); expectedTest = "{System.Text.StringBuilder_0}"; json = ToJson(testClass.FieldPublicObject); AssertTrue(expressionResult2 == expectedTest, "Object"); var expressionResult3 = GetString(testClass.FieldPublicInt32); expectedTest = "2147483647"; json = ToJson(testClass.FieldPublicInt32); AssertTrue(expressionResult3 == expectedTest, "Int32"); var expressionResult4 = GetString(testClass.FieldPublicInt64); expectedTest = "9223372036854775807"; json = ToJson(testClass.FieldPublicInt64); AssertTrue(expressionResult4 == expectedTest, "Int64"); var expressionResult5 = GetString(testClass.FieldPublicULong); expectedTest = "18446744073709551615"; json = ToJson(testClass.FieldPublicULong); AssertTrue(expressionResult5 == expectedTest, "ULong"); var expressionResult6 = GetString(testClass.FieldPublicUInt); expectedTest = "4294967295"; json = ToJson(testClass.FieldPublicUInt); AssertTrue(expressionResult6 == expectedTest, "UInt"); var expressionResult7 = GetString(testClass.FieldPublicDecimal); expectedTest = "100000.999999"; json = ToJson(testClass.FieldPublicDecimal); AssertTrue(expressionResult7 == expectedTest, "Decimal"); var expressionResult8 = GetString(testClass.FieldPublicDouble); expectedTest = "100000.999999"; json = ToJson(testClass.FieldPublicDouble); AssertTrue(expressionResult8 == expectedTest, "Double"); var expressionResult9 = GetString(testClass.FieldPublicChar); expectedTest = "\"A\""; json = ToJson(testClass.FieldPublicChar); AssertTrue(expressionResult9 == expectedTest, "Char"); var expressionResult10 = GetString(testClass.FieldPublicByte); expectedTest = "255"; json = ToJson(testClass.FieldPublicByte); AssertTrue(expressionResult10 == expectedTest, "Byte"); var expressionResult11 = GetString(testClass.FieldPublicBoolean); expectedTest = "true"; json = ToJson(testClass.FieldPublicBoolean); AssertTrue(expressionResult11 == expectedTest, "Boolean"); var expressionResult12 = GetString(testClass.FieldPublicSByte); expectedTest = "127"; json = ToJson(testClass.FieldPublicSByte); AssertTrue(expressionResult12 == expectedTest, "SByte"); var expressionResult13 = GetString(testClass.FieldPublicShort); expectedTest = "32767"; json = ToJson(testClass.FieldPublicShort); AssertTrue(expressionResult13 == expectedTest, "Short"); var expressionResult14 = GetString(testClass.FieldPublicUShort); expectedTest = "65535"; json = ToJson(testClass.FieldPublicUShort); AssertTrue(expressionResult14 == expectedTest, "UShort"); // ** Newtonsoft Json have different return expectations ** var expressionResult15 = GetString(testClass.FieldPublicFloat); expectedTest = "100000.671875"; json = ToJson(testClass.FieldPublicFloat); AssertTrue(expressionResult15 == expectedTest, "Float"); var expressionResult16 = GetString(testClass.FieldPublicInt32Nullable); expectedTest = "2147483647"; json = ToJson(testClass.FieldPublicInt32Nullable); AssertTrue(expressionResult16 == expectedTest, "Int32Nullable"); var expressionResult17 = GetString(testClass.FieldPublicInt64Nullable); expectedTest = "2"; json = ToJson(testClass.FieldPublicInt64Nullable); AssertTrue(expressionResult17 == expectedTest, "Int64Nullable"); var expressionResult18 = GetString(testClass.FieldPublicULongNullable); expectedTest = "18446744073709551615"; json = ToJson(testClass.FieldPublicULongNullable); AssertTrue(expressionResult18 == expectedTest, "ULongNullable"); var expressionResult19 = GetString(testClass.FieldPublicUIntNullable); expectedTest = "4294967295"; json = ToJson(testClass.FieldPublicUIntNullable); AssertTrue(expressionResult19 == expectedTest, "UIntNullable"); var expressionResult20 = GetString(testClass.FieldPublicDecimalNullable); expectedTest = "100000.999999"; json = ToJson(testClass.FieldPublicDecimalNullable); AssertTrue(expressionResult20 == expectedTest, "DecimalNullable"); var expressionResult21 = GetString(testClass.FieldPublicDoubleNullable); expectedTest = "100000.999999"; json = ToJson(testClass.FieldPublicDoubleNullable); AssertTrue(expressionResult21 == expectedTest, "DoubleNullable"); var expressionResult22 = GetString(testClass.FieldPublicCharNullable); expectedTest = "\"A\""; json = ToJson(testClass.FieldPublicCharNullable); AssertTrue(expressionResult22 == expectedTest, "CharNullable"); var expressionResult23 = GetString(testClass.FieldPublicByteNullable); expectedTest = "255"; json = ToJson(testClass.FieldPublicByteNullable); AssertTrue(expressionResult23 == expectedTest, "ByteNullable"); var expressionResult24 = GetString(testClass.FieldPublicBooleanNullable); expectedTest = "true"; json = ToJson(testClass.FieldPublicBooleanNullable); AssertTrue(expressionResult24 == expectedTest, "BooleanNullable"); var expressionResult25 = GetString(testClass.FieldPublicSByteNullable); expectedTest = "127"; json = ToJson(testClass.FieldPublicSByteNullable); AssertTrue(expressionResult25 == expectedTest, "SByteNullable"); var expressionResult26 = GetString(testClass.FieldPublicShortNullable); expectedTest = "32767"; json = ToJson(testClass.FieldPublicShortNullable); AssertTrue(expressionResult26 == expectedTest, "ShortNullable"); var expressionResult27 = GetString(testClass.FieldPublicUShortNullable); expectedTest = "65535"; json = ToJson(testClass.FieldPublicUShortNullable); AssertTrue(expressionResult27 == expectedTest, "UShortNullable"); var expressionResult28 = GetString(testClass.FieldPublicFloatNullable); expectedTest = "100000.671875"; json = ToJson(testClass.FieldPublicFloatNullable); AssertTrue(expressionResult28 == expectedTest, "FloatNullable"); #endregion #region System // ** Newtonsoft Json have different return expectations ** var expressionResult29 = GetString(testClass.FieldPublicSingle); expectedTest = "3.40282346638529E+38"; json = ToJson(testClass.FieldPublicSingle); AssertTrue(expressionResult29 == expectedTest, "Single"); // ** Newtonsoft Json have different return expectations ** // ** Is different because Newtonsoft use "System.Runtime.Serialization.SerializationInfo" to get properties ** var expressionResult30 = GetString(testClass.FieldPublicException); expectedTest = "{System.Exception_0}"; json = ToJson(testClass.FieldPublicException); AssertTrue(expressionResult30 == expectedTest, "Exception"); // ** Newtonsoft Json have different return expectations ** var expressionResult31 = GetString(testClass.FieldPublicEnumNonGeneric); expectedTest = "ValueA"; json = ToJson(testClass.FieldPublicEnumNonGeneric); AssertTrue(expressionResult31 == expectedTest, "EnumNonGeneric"); var expressionResult32 = GetString(testClass.FieldPublicAction); expectedTest = "{System.Action_0}"; json = ToJson(testClass.FieldPublicAction); AssertTrue(expressionResult32 == expectedTest, "Action"); var expressionResult33 = GetString(testClass.FieldPublicAction2); expectedTest = "{System.Action<System.String, System.Int32>_0}"; json = ToJson(testClass.FieldPublicAction); AssertTrue(expressionResult33 == expectedTest, "Action<string, int>"); var expressionResult34 = GetString(testClass.FieldPublicFunc); expectedTest = "{System.Func<System.Boolean>_0}"; json = ToJson(testClass.FieldPublicFunc); AssertTrue(expressionResult34 == expectedTest, "Func"); var expressionResult35 = GetString(testClass.FieldPublicFunc2); expectedTest = "{System.Func<System.String, System.Int32, System.Boolean>_0}"; json = ToJson(testClass.FieldPublicFunc); AssertTrue(expressionResult35 == expectedTest, "Func<string, int, bool>"); // ** Newtonsoft Json have different return expectations ** var expressionResult36 = GetString(testClass.FieldPublicDateTime); expectedTest = "\"2000-01-01T01:01:01.000-02:00\""; json = ToJson(testClass.FieldPublicDateTime); AssertTrue(expressionResult36 == expectedTest, "DateTime)"); var expressionResult37 = GetString(testClass.FieldPublicTimeSpan); expectedTest = "{System.TimeSpan_0}"; json = ToJson(testClass.FieldPublicTimeSpan); AssertTrue(expressionResult37 == expectedTest, "TimeSpan"); // ** Newtonsoft Json have different return expectations ** var expressionResult38 = GetString(testClass.FieldPublicEnumDateTimeKind); expectedTest = "Local"; json = ToJson(testClass.FieldPublicEnumDateTimeKind); AssertTrue(expressionResult38 == expectedTest, "EnumDateTimeKind"); var expressionResult39 = GetString(testClass.FieldPublicDateTimeOffset); expectedTest = "\"2008-05-01T08:06:32.545+01:00\""; json = ToJson(testClass.FieldPublicDateTimeOffset); AssertTrue(expressionResult39 == expectedTest, "DateTimeOffset"); // ** Newtonsoft Json have different return expectations ** var expressionResult40 = GetString(testClass.FieldPublicIntPtr); expectedTest = "100"; json = ToJson(testClass.FieldPublicIntPtr); AssertTrue(expressionResult40 == expectedTest, "IntPtr"); var expressionResult41 = GetString(testClass.FieldPublicTimeZone); expectedTest = "{System.CurrentSystemTimeZone_0}"; json = ToJson(testClass.FieldPublicTimeZone); AssertTrue(expressionResult41 == expectedTest, "TimeZone"); // ** Newtonsoft Json have different return expectations ** // ** Is different because Newtonsoft use "System.Runtime.Serialization.SerializationInfo" to get properties ** var expressionResult42 = GetString(testClass.FieldPublicTimeZoneInfo); expectedTest = "{System.TimeZoneInfo_0}"; json = ToJson(testClass.FieldPublicTimeZoneInfo); AssertTrue(expressionResult42 == expectedTest, "TimeZoneInfo"); var expressionResult43 = GetString(testClass.FieldPublicTuple); expectedTest = "{System.Tuple<System.String, System.Int32, System.Decimal>_0}"; json = ToJson(testClass.FieldPublicTuple); AssertTrue(expressionResult43 == expectedTest, "Tuple"); // ** Newtonsoft Json have different return expectations ** // ** ERROR var expressionResult44 = GetString(testClass.FieldPublicType); expectedTest = "{System.RuntimeType_0}"; json = ToJson(testClass.FieldPublicType); AssertTrue(expressionResult44 == expectedTest, "Type"); var expressionResult45 = GetString(testClass.FieldPublicUIntPtr); expectedTest = "100"; json = ToJson(testClass.FieldPublicUIntPtr); AssertTrue(expressionResult45 == expectedTest, "UIntPtr"); // ** Newtonsoft Json have different return expectations ** var expressionResult46 = GetString(testClass.FieldPublicUri); expectedTest = "{System.Uri_0}"; json = ToJson(testClass.FieldPublicUri); AssertTrue(expressionResult46 == expectedTest, "Uri"); var expressionResult47 = GetString(testClass.FieldPublicVersion); expectedTest = "{System.Version_0}"; json = ToJson(testClass.FieldPublicVersion); AssertTrue(expressionResult47 == expectedTest, "Version"); var expressionResult48 = GetString(testClass.FieldPublicGuid, true); expectedTest = "{System.Guid_0}"; json = ToJson(testClass.FieldPublicGuid); AssertTrue(expressionResult48 == expectedTest, "Guid"); #endregion }
public void TestReflection_Custom() { var expectedTest = ""; var json = ""; var testClass = new SeveralTypesTest(); testClass.Populate(); var expressionResult1 = GetString(testClass.FieldPublicMyCollectionPublicGetEnumerator); expectedTest = "{MyCollectionPublicGetEnumerator_0} + [0]: \"a\" + [1]: \"b\" + [2]: \"c\""; json = ToJson(testClass.FieldPublicMyCollectionPublicGetEnumerator); AssertTrue(expressionResult1 == expectedTest, "MyCollectionPublicGetEnumerator"); var expressionResult2 = GetString(testClass.FieldPublicMyCollectionInheritsPublicGetEnumerator); expectedTest = "{MyCollectionInheritsPublicGetEnumerator_0} + [0]: \"a\" + [1]: \"b\" + [2]: \"c\""; json = ToJson(testClass.FieldPublicMyCollectionInheritsPublicGetEnumerator); AssertTrue(expressionResult2 == expectedTest, "MyCollectionInheritsPublicGetEnumerator"); var expressionResult3 = GetString(testClass.FieldPublicMyCollectionExplicitGetEnumerator); expectedTest = "{MyCollectionExplicitGetEnumerator_0} + [0]: \"a\" + [1]: \"b\" + [2]: \"c\""; json = ToJson(testClass.FieldPublicMyCollectionExplicitGetEnumerator); AssertTrue(expressionResult3 == expectedTest, "MyCollectionExplicitGetEnumerator"); var expressionResult4 = GetString(testClass.FieldPublicMyCollectionInheritsExplicitGetEnumerator); expectedTest = "{MyCollectionInheritsExplicitGetEnumerator_0} + [0]: \"a\" + [1]: \"b\" + [2]: \"c\""; json = ToJson(testClass.FieldPublicMyCollectionInheritsExplicitGetEnumerator); AssertTrue(expressionResult4 == expectedTest, "MyCollectionInheritsExplicitGetEnumerator"); var expressionResult5 = GetString(testClass.FieldPublicMyCollectionInheritsTooIEnumerable); expectedTest = "{MyCollectionInheritsTooIEnumerable_0} + [0]: \"A\" + [1]: \"B\" + [2]: \"C\""; json = ToJson(testClass.FieldPublicMyCollectionInheritsTooIEnumerable); AssertTrue(expressionResult5 == expectedTest, "FieldPublicMyCollectionInheritsTooIEnumerable"); // ** Newtonsoft Json have different return expectations ** var expressionResult6 = GetString(testClass.FieldPublicEnumSpecific); expectedTest = "ValueB"; json = ToJson(testClass.FieldPublicEnumSpecific); AssertTrue(expressionResult6 == expectedTest, "EnumSpecific"); // ** Newtonsoft Json throw exception with delegates ** var expressionResult7 = GetString(testClass.MyDelegate); expectedTest = "{DelegateTest_0}"; //json = ToJson(testClass.MyDelegate); AssertTrue(expressionResult7 == expectedTest, "Func<string, int, bool>"); var expressionResult8 = GetString(testClass.EmptyClass); expectedTest = "{EmptyClass_0}"; json = ToJson(testClass.EmptyClass); AssertTrue(expressionResult8 == expectedTest, "Func<string, int, bool>"); var expressionResult9 = GetString(testClass.StructGeneric); expectedTest = "{ThreeTuple<System.Int32>_0}"; json = ToJson(testClass.StructGeneric); AssertTrue(expressionResult9 == expectedTest, "StructGeneric"); var expressionResult10 = GetString(testClass.StructGenericNullable); expectedTest = "{ThreeTuple<System.Int32>_0}"; json = ToJson(testClass.StructGenericNullable); AssertTrue(expressionResult10 == expectedTest, "StructGenericNullable"); var expressionResult11 = GetString(testClass.FieldPublicNullable); expectedTest = "{ThreeTuple<System.Int32>_0}"; json = ToJson(testClass.StructGenericNullable); AssertTrue(expressionResult11 == expectedTest, "Nullable"); }