| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| using System; |
| using System.IO; |
| using Xunit; |
| using PdxTests; |
| using System.Collections; |
| using System.Collections.Generic; |
| using Xunit.Abstractions; |
| using System.Reflection; |
| using System.Linq; |
| |
| namespace Apache.Geode.Client.IntegrationTests |
| { |
| public class ApartmentLocation |
| { |
| int _aptNumber; |
| string _street; |
| string _city; |
| |
| public ApartmentLocation() |
| { } |
| public override string ToString() |
| { |
| return _aptNumber + " :" + _street + " : " + _city; |
| } |
| public ApartmentLocation(int aptN, string street, string city) |
| { |
| _aptNumber = aptN; |
| _street = street; |
| _city = city; |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| ApartmentLocation other = obj as ApartmentLocation; |
| if (other == null) |
| return false; |
| if (_aptNumber == other._aptNumber |
| && _street == other._street |
| && _city == other._city) |
| return true; |
| return false; |
| } |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class PdxTypesReflectionTest |
| { |
| char m_char; |
| bool m_bool; |
| sbyte m_byte; |
| sbyte m_sbyte; |
| short m_int16; |
| short m_uint16; |
| Int32 m_int32; |
| Int32 m_uint32; |
| long m_long; |
| Int64 m_ulong; |
| float m_float; |
| double m_double; |
| |
| string m_string; |
| |
| bool[] m_boolArray; |
| byte[] m_byteArray; |
| byte[] m_sbyteArray; |
| |
| char[] m_charArray; |
| |
| DateTime m_dateTime; |
| |
| Int16[] m_int16Array; |
| Int16[] m_uint16Array; |
| |
| Int32[] m_int32Array; |
| Int32[] m_uint32Array; |
| |
| long[] m_longArray; |
| Int64[] m_ulongArray; |
| |
| float[] m_floatArray; |
| double[] m_doubleArray; |
| |
| byte[][] m_byteByteArray; |
| |
| string[] m_stringArray; |
| |
| List<object> m_arraylist = new List<object>(); |
| IDictionary<object, object> m_map = new Dictionary<object, object>(); |
| Hashtable m_hashtable = new Hashtable(); |
| ArrayList m_vector = new ArrayList(); |
| |
| CacheableHashSet m_chs = CacheableHashSet.Create(); |
| CacheableLinkedHashSet m_clhs = CacheableLinkedHashSet.Create(); |
| |
| byte[] m_byte252 = new byte[252]; |
| byte[] m_byte253 = new byte[253]; |
| byte[] m_byte65535 = new byte[65535]; |
| byte[] m_byte65536 = new byte[65536]; |
| |
| pdxEnumTest m_pdxEnum = pdxEnumTest.pdx3; |
| ApartmentLocation[] m_address = new ApartmentLocation[10]; |
| |
| LinkedList<Object> m_LinkedList = new LinkedList<Object>(); |
| |
| public void Init() |
| { |
| m_char = 'C'; |
| m_bool = true; |
| m_byte = 0x74; |
| m_sbyte = 0x67; |
| m_int16 = 0xab; |
| m_uint16 = 0x2dd5; |
| m_int32 = 0x2345abdc; |
| m_uint32 = 0x2a65c434; |
| m_long = 324897980; |
| m_ulong = 238749898; |
| m_float = 23324.324f; |
| m_double = 3243298498d; |
| |
| m_string = "gfestring"; |
| |
| m_boolArray = new bool[] { true, false, true }; |
| m_byteArray = new byte[] { 0x34, 0x64 }; |
| m_sbyteArray = new byte[] { 0x34, 0x64 }; |
| |
| m_charArray = new char[] { 'c', 'v' }; |
| |
| long ticks = 634460644691540000L; |
| m_dateTime = new DateTime(ticks); |
| |
| m_int16Array = new short[] { 0x2332, 0x4545 }; |
| m_uint16Array = new short[] { 0x3243, 0x3232 }; |
| |
| m_int32Array = new int[] { 23, 676868, 34343, 2323 }; |
| m_uint32Array = new int[] { 435, 234324, 324324, 23432432 }; |
| |
| m_longArray = new long[] { 324324L, 23434545L }; |
| m_ulongArray = new Int64[] { 3245435, 3425435 }; |
| |
| m_floatArray = new float[] { 232.565f, 2343254.67f }; |
| m_doubleArray = new double[] { 23423432d, 4324235435d }; |
| |
| m_byteByteArray = new byte[][]{new byte[] {0x23}, |
| new byte[]{0x34, 0x55} |
| }; |
| |
| m_stringArray = new string[] { "one", "two" }; |
| |
| m_arraylist = new List<object>(); |
| m_arraylist.Add(1); |
| m_arraylist.Add(2); |
| |
| m_LinkedList = new LinkedList<Object>(); |
| m_LinkedList.AddFirst("Item1"); |
| m_LinkedList.AddLast("Item2"); |
| m_LinkedList.AddLast("Item3"); |
| |
| |
| m_map = new Dictionary<object, object>(); |
| m_map.Add(1, 1); |
| m_map.Add(2, 2); |
| |
| m_hashtable = new Hashtable(); |
| m_hashtable.Add(1, "1111111111111111"); |
| m_hashtable.Add(2, "2222222222221111111111111111"); |
| |
| m_vector = new ArrayList(); |
| m_vector.Add(1); |
| m_vector.Add(2); |
| m_vector.Add(3); |
| |
| m_chs.Add(1); |
| m_clhs.Add(1); |
| m_clhs.Add(2); |
| m_pdxEnum = pdxEnumTest.pdx3; |
| |
| m_address = new ApartmentLocation[10]; |
| |
| for (int i = 0; i < m_address.Length; i++) |
| { |
| m_address[i] = new ApartmentLocation(i, "street" + i, "city" + i); |
| } |
| } |
| |
| public PdxTypesReflectionTest() |
| { |
| |
| |
| } |
| |
| public PdxTypesReflectionTest(bool initialize) |
| { |
| if (initialize) |
| Init(); |
| |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| |
| PdxTypesReflectionTest other = obj as PdxTypesReflectionTest; |
| |
| if (other == null) |
| return false; |
| |
| this.checkEquality(other); |
| return true; |
| } |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| #region IPdxSerializable Members |
| byte[][] compareByteByteArray(byte[][] baa, byte[][] baa2) |
| { |
| if (baa.Length == baa2.Length) |
| { |
| int i = 0; |
| while (i < baa.Length) |
| { |
| compareByteArray(baa[i], baa2[i]); |
| i++; |
| } |
| if (i == baa2.Length) |
| return baa2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + baa2.GetType().ToString()); |
| } |
| bool compareBool(bool b, bool b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| bool[] compareBoolArray(bool[] a, bool[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| byte compareByte(byte b, byte b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| byte[] compareByteArray(byte[] a, byte[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| char[] compareCharArray(char[] a, char[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| List<object> compareCompareCollection(List<object> a, List<object> a2) |
| { |
| if (a.Count == a2.Count) |
| { |
| int i = 0; |
| while (i < a.Count) |
| { |
| if (!a[i].Equals(a2[i])) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Count) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| |
| LinkedList<object> compareCompareCollection(LinkedList<object> a, LinkedList<object> a2) |
| { |
| if (a.Count == a2.Count) |
| { |
| LinkedList<Object>.Enumerator e1 = a.GetEnumerator(); |
| LinkedList<Object>.Enumerator e2 = a2.GetEnumerator(); |
| while (e1.MoveNext() && e2.MoveNext()) |
| { |
| if (!e1.Current.Equals(e2.Current)) |
| break; |
| } |
| return a2; |
| } |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| |
| DateTime compareData(DateTime b, DateTime b2) |
| { |
| //TODO: |
| // return b; |
| if ((b.Ticks / 10000L) == (b2.Ticks / 10000L)) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| Double compareDouble(Double b, Double b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| double[] compareDoubleArray(double[] a, double[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| float compareFloat(float b, float b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| float[] compareFloatArray(float[] a, float[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| Int16 compareInt16(Int16 b, Int16 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| Int32 compareInt32(Int32 b, Int32 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| Int64 compareInt64(Int64 b, Int64 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| Int32[] compareIntArray(Int32[] a, Int32[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| long[] compareLongArray(long[] a, long[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| Int16[] compareSHortArray(Int16[] a, Int16[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| sbyte compareSByte(sbyte b, sbyte b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| sbyte[] compareSByteArray(sbyte[] a, sbyte[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| string[] compareStringArray(string[] a, string[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| UInt16 compareUInt16(UInt16 b, UInt16 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| UInt32 compareUInt32(UInt32 b, UInt32 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| UInt64 compareUint64(UInt64 b, UInt64 b2) |
| { |
| if (b == b2) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| UInt32[] compareUnsignedIntArray(UInt32[] a, UInt32[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| UInt64[] compareUnsignedLongArray(UInt64[] a, UInt64[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| UInt16[] compareUnsignedShortArray(UInt16[] a, UInt16[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (a[i] != a2[i]) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| |
| T[] GenericCompare<T>(T[] a, T[] a2) |
| { |
| if (a.Length == a2.Length) |
| { |
| int i = 0; |
| while (i < a.Length) |
| { |
| if (!a[i].Equals(a2[i])) |
| break; |
| else |
| i++; |
| } |
| if (i == a2.Length) |
| return a2; |
| } |
| |
| throw new IllegalStateException("Not got expected value for type: " + a2.GetType().ToString()); |
| } |
| |
| |
| T GenericValCompare<T>(T b, T b2) |
| { |
| if (b.Equals(b2)) |
| return b; |
| throw new IllegalStateException("Not got expected value for type: " + b2.GetType().ToString()); |
| } |
| public void checkEquality(PdxTypesReflectionTest other) |
| { |
| byte[][] baa = other.m_byteByteArray; |
| m_byteByteArray = compareByteByteArray(baa, m_byteByteArray); |
| m_char = GenericValCompare(other.m_char, m_char); |
| |
| m_bool = GenericValCompare(other.m_bool, m_bool); |
| m_boolArray = GenericCompare(other.m_boolArray, m_boolArray); |
| |
| m_byte = GenericValCompare(other.m_byte, m_byte); |
| m_byteArray = GenericCompare(other.m_byteArray, m_byteArray); |
| m_charArray = GenericCompare(other.m_charArray, m_charArray); |
| |
| m_arraylist = compareCompareCollection(other.m_arraylist, m_arraylist); |
| |
| m_LinkedList = compareCompareCollection(other.m_LinkedList, m_LinkedList); |
| |
| IDictionary<object, object> tmpM = other.m_map; |
| if (tmpM.Count != m_map.Count) |
| throw new IllegalStateException("Not got expected value for type: " + m_map.GetType().ToString()); |
| |
| Hashtable tmpH = other.m_hashtable; |
| |
| if (tmpH.Count != m_hashtable.Count) |
| throw new IllegalStateException("Not got expected value for type: " + m_hashtable.GetType().ToString()); |
| |
| ArrayList arrAl = other.m_vector; |
| |
| if (arrAl.Count != m_vector.Count) |
| throw new IllegalStateException("Not got expected value for type: " + m_vector.GetType().ToString()); |
| |
| CacheableHashSet rmpChs = other.m_chs; |
| |
| if (rmpChs.Count != m_chs.Count) |
| throw new IllegalStateException("Not got expected value for type: " + m_chs.GetType().ToString()); |
| |
| CacheableLinkedHashSet rmpClhs = other.m_clhs; |
| |
| if (rmpClhs.Count != m_clhs.Count) |
| throw new IllegalStateException("Not got expected value for type: " + m_clhs.GetType().ToString()); |
| |
| |
| m_string = GenericValCompare(other.m_string, m_string); |
| |
| m_dateTime = compareData(other.m_dateTime, m_dateTime); |
| |
| m_double = GenericValCompare(other.m_double, m_double); |
| |
| m_doubleArray = GenericCompare(other.m_doubleArray, m_doubleArray); |
| m_float = GenericValCompare(other.m_float, m_float); |
| m_floatArray = GenericCompare(other.m_floatArray, m_floatArray); |
| m_int16 = GenericValCompare(other.m_int16, m_int16); |
| m_int32 = GenericValCompare(other.m_int32, m_int32); |
| m_long = GenericValCompare(other.m_long, m_long); |
| m_int32Array = GenericCompare(other.m_int32Array, m_int32Array); |
| m_longArray = GenericCompare(other.m_longArray, m_longArray); |
| m_int16Array = GenericCompare(other.m_int16Array, m_int16Array); |
| m_sbyte = GenericValCompare(other.m_sbyte, m_sbyte); |
| m_sbyteArray = GenericCompare(other.m_sbyteArray, m_sbyteArray); |
| m_stringArray = GenericCompare(other.m_stringArray, m_stringArray); |
| m_uint16 = GenericValCompare(other.m_uint16, m_uint16); |
| m_uint32 = GenericValCompare(other.m_uint32, m_uint32); |
| m_ulong = GenericValCompare(other.m_ulong, m_ulong); |
| m_uint32Array = GenericCompare(other.m_uint32Array, m_uint32Array); |
| m_ulongArray = GenericCompare(other.m_ulongArray, m_ulongArray); |
| m_uint16Array = GenericCompare(other.m_uint16Array, m_uint16Array); |
| |
| byte[] ret = other.m_byte252; |
| if (ret.Length != 252) |
| throw new Exception("Array len 252 not found"); |
| |
| ret = other.m_byte253; |
| if (ret.Length != 253) |
| throw new Exception("Array len 253 not found"); |
| |
| ret = other.m_byte65535; |
| if (ret.Length != 65535) |
| throw new Exception("Array len 65535 not found"); |
| |
| ret = other.m_byte65536; |
| if (ret.Length != 65536) |
| throw new Exception("Array len 65536 not found"); |
| if (other.m_pdxEnum != m_pdxEnum) |
| throw new Exception("Pdx enum is not equal"); |
| |
| ApartmentLocation[] otherA = other.m_address; |
| for (int i = 0; i < m_address.Length; i++) |
| { |
| if (!m_address[i].Equals(otherA[i])) |
| throw new Exception("ApartmentLocation array is not equal " + i); |
| } |
| } |
| #endregion |
| } |
| |
| public class SerializePdx1 |
| { |
| [PdxIdentityField] public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| public SerializePdx1() |
| { |
| } |
| |
| public SerializePdx1(bool init) |
| { |
| if (init) |
| { |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx1; |
| |
| if (other == null) |
| return false; |
| |
| if (i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class UnsupportedTypes |
| { |
| public struct Coords |
| { |
| public Coords(double x, double y) |
| { |
| X = x; |
| Y = y; |
| } |
| |
| public double X { get; set; } |
| public double Y { get; set; } |
| |
| public override bool Equals(object ob) |
| { |
| if (ob is Coords) |
| { |
| Coords c = (Coords)ob; |
| return X == c.X && Y == c.Y; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| public override int GetHashCode() |
| { |
| return X.GetHashCode() ^ Y.GetHashCode(); |
| } |
| } |
| |
| [PdxIdentityField] public int i1; |
| public Coords coordsVal; |
| |
| public UnsupportedTypes() |
| { |
| } |
| |
| public UnsupportedTypes(bool init) |
| { |
| if (init) |
| { |
| i1 = 1; |
| coordsVal = new Coords(1,2); |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as UnsupportedTypes; |
| |
| if (other == null) |
| return false; |
| |
| if (i1 == other.i1 |
| && coordsVal.Equals(coordsVal)) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class SerializePdx2 |
| { |
| public string s0; |
| [PdxIdentityField] public int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| |
| public SerializePdx2() |
| { |
| } |
| |
| public override string ToString() |
| { |
| return i1 + i2 + s1 + s2; |
| } |
| |
| public SerializePdx2(bool init) |
| { |
| if (init) |
| { |
| s0 = "s9999999999999999999999999999999999"; |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx2; |
| |
| if (other == null) |
| return false; |
| |
| if (s0 == other.s0 |
| && i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class BaseClass |
| { |
| [NonSerialized] |
| private const int _const = 1003; |
| |
| private int _baseclassmember; |
| |
| public BaseClass() |
| { |
| } |
| |
| public BaseClass(bool init) |
| { |
| if (init) |
| { |
| _baseclassmember = 101; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var bc = obj as BaseClass; |
| if (bc == null) |
| return false; |
| |
| if (bc == this) |
| return true; |
| |
| if (bc._baseclassmember == _baseclassmember) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| |
| public void ToData(IPdxWriter w) |
| { |
| w.WriteInt("_baseclassmember", _baseclassmember); |
| } |
| |
| public void FromData(IPdxReader r) |
| { |
| _baseclassmember = r.ReadInt("_baseclassmember"); |
| } |
| } |
| |
| public class AddressWithGuid |
| { |
| private static Guid oddGuid = new Guid("924243B5-9C2A-41d7-86B1-E0B905C7EED3"); |
| private static Guid evenGuid = new Guid("47AA8F17-FF6B-4a7d-B398-D83790977574"); |
| private string _street; |
| private string _aptName; |
| private int _flatNumber; |
| private Guid _guid; |
| |
| public AddressWithGuid() |
| { |
| } |
| |
| public AddressWithGuid(int id) |
| { |
| _flatNumber = id; |
| _aptName = id.ToString(); |
| _street = id.ToString() + "_street"; |
| if (id % 2 == 0) |
| _guid = evenGuid; |
| else |
| _guid = oddGuid; |
| } |
| |
| public override string ToString() |
| { |
| return _flatNumber + " " + _aptName + " " + _street + " " + _guid.ToString(); |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| var other = obj as AddressWithGuid; |
| |
| if (other == null) |
| return false; |
| |
| if (_street == other._street && |
| _aptName == other._aptName && |
| _flatNumber == other._flatNumber && |
| _guid.Equals(other._guid)) |
| return true; |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class SerializeAllTypes : BaseClass |
| { |
| public enum COLORS { RED, WHITE, BLUE }; |
| |
| [PdxIdentityField] private int identity; |
| |
| private string stringVal; |
| private string[] stringArray; |
| |
| public char charVal; |
| public char[] charArray; |
| |
| public bool boolVal; |
| public bool[] boolArray; |
| |
| public byte byteVal; |
| public byte[] byteArray; |
| |
| public sbyte sbyteVal; |
| public sbyte[] sbyteArray; |
| |
| public short shortVal; |
| public ushort ushortVal; |
| public short[] shortArray; |
| public ushort[] ushortArray; |
| |
| public int intVal; |
| public uint uintVal; |
| public int[] intArray; |
| public uint[] uintArray; |
| |
| public long longVal; |
| public ulong ulongVal; |
| public long[] longArray; |
| public ulong[] ulongArray; |
| |
| public float floatVal; |
| public float[] floatArray; |
| |
| public double doubleVal; |
| public double[] doubleArray; |
| |
| public DateTime dateTimeVal; |
| public DateTime[] dateTimeArray; |
| |
| public string s1; |
| public string s2; |
| private SerializePdx2 nestedObject; |
| private ArrayList _addressList; |
| private AddressWithGuid _address; |
| |
| private Hashtable _hashTable; |
| private Stack _stack; |
| private Queue _queue; |
| |
| public COLORS colorVal; |
| public Guid guid; |
| public Decimal decimalVal; |
| |
| public SerializeAllTypes() |
| : base() |
| { |
| } |
| |
| public SerializeAllTypes(bool init, int nAddress) |
| : base(init) |
| { |
| if (init) |
| { |
| stringVal = "Harry Potter is a gryffindor"; |
| stringArray = new string[] { "Ron", "Hermeine", "Hagrid" }; |
| |
| identity = 1; |
| |
| charVal = 'z'; |
| charArray = new char[] { 'a', 'b', 'c' }; |
| |
| boolVal = true; |
| boolArray = new bool[] { true, false, true }; |
| |
| byteVal = 0xa0; |
| byteArray = new byte[] { (byte)(Byte.MaxValue - 1), (byte)(Byte.MaxValue - 10), (byte)(Byte.MaxValue - 20) }; |
| |
| sbyteVal = 0x10; |
| sbyteArray = new sbyte[] { -5, 2, 0x70 }; |
| |
| shortVal = -2; |
| ushortVal = 2; |
| shortArray = new short[] { 1, 11, 111 }; |
| ushortArray = new ushort[] { (ushort)(UInt16.MaxValue - 1), (ushort)(UInt16.MaxValue - 11), (ushort)(UInt16.MaxValue - 111) }; |
| |
| intVal = -22; |
| uintVal = 22; |
| intArray = new int[] { 10, 110, 1110 }; |
| uintArray = new uint[] { (uint)(UInt32.MaxValue - 10), (uint)(UInt32.MaxValue - 110), (uint)(UInt32.MaxValue - 1110) }; |
| |
| longVal = -222; |
| ulongVal = 222; |
| longArray = new long[] { 100, 1100, 11100 }; |
| ulongArray = new ulong[] { (ulong)(UInt64.MaxValue - 100), (ulong)(UInt64.MaxValue - 1100), (ulong)(UInt64.MaxValue - 11100) }; |
| |
| floatVal = 1.6f; |
| floatArray = new float[] { 1.6f, 1600.1f, 1.2e7f }; |
| |
| doubleVal = 1.6; |
| doubleArray = new double[] { 2.6, 2600.1, 2.2e7 }; |
| |
| dateTimeVal = new DateTime(2009, 8, 1, 0, 0, 0); |
| dateTimeArray = new DateTime[] { dateTimeVal, dateTimeVal.AddDays(1), dateTimeVal.AddHours(1) }; |
| |
| s1 = "s1"; |
| s2 = "s2"; |
| nestedObject = new SerializePdx2(true); |
| |
| _addressList = new ArrayList(); |
| _hashTable = new Hashtable(); |
| _stack = new Stack(); |
| _queue = new Queue(); |
| |
| for (var i = 0; i < 10; i++) |
| { |
| _addressList.Add(new AddressWithGuid(i)); |
| _hashTable.Add(i, new SerializePdx2(true)); |
| _stack.Push(new SerializePdx2(true)); |
| _queue.Enqueue(new SerializePdx2(true)); |
| } |
| |
| _address = new AddressWithGuid(nAddress); |
| colorVal = COLORS.RED; |
| guid = new Guid("924243B5-9C2A-41d7-86B1-E0B905C7EED3"); |
| decimalVal = Decimal.MaxValue; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializeAllTypes; |
| |
| if (other == null) |
| return false; |
| |
| if (stringVal == other.stringVal |
| && stringArray.SequenceEqual(other.stringArray) |
| |
| && identity == other.identity |
| |
| && charVal == other.charVal |
| && charArray.SequenceEqual(other.charArray) |
| |
| && boolVal == other.boolVal |
| && boolArray.SequenceEqual(other.boolArray) |
| |
| && byteVal == other.byteVal |
| && byteArray.SequenceEqual(other.byteArray) |
| |
| && sbyteVal == other.sbyteVal |
| && sbyteArray.SequenceEqual(other.sbyteArray) |
| |
| && shortVal == other.shortVal |
| && ushortVal == other.ushortVal |
| && shortArray.SequenceEqual(other.shortArray) |
| && ushortArray.SequenceEqual(other.ushortArray) |
| |
| && intVal == other.intVal |
| && uintVal == other.uintVal |
| && intArray.SequenceEqual(other.intArray) |
| && uintArray.SequenceEqual(other.uintArray) |
| |
| && longVal == other.longVal |
| && ulongVal == other.ulongVal |
| && longArray.SequenceEqual(other.longArray) |
| && ulongArray.SequenceEqual(other.ulongArray) |
| |
| && floatVal == other.floatVal |
| && floatArray.SequenceEqual(other.floatArray) |
| |
| && doubleVal == other.doubleVal |
| && doubleArray.SequenceEqual(other.doubleArray) |
| |
| && dateTimeVal == other.dateTimeVal |
| && dateTimeArray.SequenceEqual(other.dateTimeArray) |
| |
| && s1 == other.s1 |
| && s2 == other.s2 |
| && colorVal == other.colorVal |
| && guid == other.guid |
| && decimalVal == other.decimalVal) |
| { |
| var ret = nestedObject.Equals(other.nestedObject); |
| |
| if (ret) |
| { |
| if (_addressList.Count == 10 && |
| _addressList.Count == other._addressList.Count |
| ) |
| { |
| for (var i = 0; i < _addressList.Count; i++) |
| { |
| ret = _addressList[i].Equals(other._addressList[i]); |
| if (!ret) |
| return false; |
| } |
| |
| if (_hashTable.Count != other._hashTable.Count) |
| return false; |
| |
| foreach (DictionaryEntry de in _hashTable) |
| { |
| var otherHe = other._hashTable[de.Key]; |
| ret = de.Value.Equals(otherHe); |
| if (!ret) |
| return false; |
| } |
| |
| if (_stack.Count != other._stack.Count) |
| return false; |
| foreach (Object o in _stack) |
| { |
| var otherO = other._stack.Pop(); |
| ret = o.Equals(otherO); |
| if (!ret) |
| return false; |
| } |
| |
| if (_queue.Count != other._queue.Count) |
| return false; |
| foreach (Object o in _queue) |
| { |
| var otherO = other._queue.Dequeue(); |
| ret = o.Equals(otherO); |
| if (!ret) |
| return false; |
| } |
| |
| if (!_address.Equals(other._address)) |
| return false; |
| |
| return base.Equals(other); |
| } |
| } |
| } |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class SerializePdx4 : BaseClass |
| { |
| private string s0; |
| [PdxIdentityField] private int i1; |
| public int i2; |
| public string s1; |
| public string s2; |
| private SerializePdx2 nestedObject; |
| private ArrayList _addressList; |
| |
| private AddressWithGuid[] _addressArray; |
| |
| //private int arrayCount = 10; |
| public SerializePdx4() |
| : base() |
| { |
| } |
| |
| public override string ToString() |
| { |
| return i1 + ":" + i2 + ":" + s1 + ":" + s2 + nestedObject.ToString() + " add: " + _addressList[0].ToString(); |
| } |
| |
| public SerializePdx4(bool init) |
| : base(init) |
| { |
| if (init) |
| { |
| s0 = "s9999999999999999999999999999999999"; |
| i1 = 1; |
| i2 = 2; |
| s1 = "s1"; |
| s2 = "s2"; |
| nestedObject = new SerializePdx2(true); |
| |
| _addressList = new ArrayList(); |
| _addressArray = new AddressWithGuid[10]; |
| |
| for (var i = 0; i < 10; i++) |
| { |
| _addressList.Add(new AddressWithGuid(i)); |
| _addressArray[i] = new AddressWithGuid(i); |
| } |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| if (obj == this) |
| return true; |
| |
| var other = obj as SerializePdx4; |
| |
| if (other == null) |
| return false; |
| |
| if (s0 == other.s0 |
| && i1 == other.i1 |
| && i2 == other.i2 |
| && s1 == other.s1 |
| && s2 == other.s2) |
| { |
| var ret = nestedObject.Equals(other.nestedObject); |
| if (ret) |
| { |
| if (_addressList.Count == other._addressList.Count && |
| _addressList[0].Equals(other._addressList[0])) |
| { |
| for (var i = 0; i < _addressList.Count; i++) |
| { |
| ret = _addressList[i].Equals(other._addressList[i]); |
| if (!ret) |
| return false; |
| } |
| |
| for (var i = 0; i < _addressArray.Length; i++) |
| { |
| ret = _addressArray[i].Equals(other._addressArray[i]); |
| if (!ret) |
| return false; |
| } |
| |
| return base.Equals(other); |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class PdxFieldTest |
| { |
| private string _notInclude = "default_value"; |
| private int _nameChange; |
| private int _identityField; |
| |
| public PdxFieldTest() |
| { |
| } |
| |
| public string NotInclude |
| { |
| set { _notInclude = value; } |
| } |
| |
| public PdxFieldTest(bool init) |
| { |
| if (init) |
| { |
| _notInclude = "valuechange"; |
| _nameChange = 11213; |
| _identityField = 1038193; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if (obj == null) |
| return false; |
| |
| var other = obj as PdxFieldTest; |
| |
| if (other == null) |
| return false; |
| |
| if (_notInclude == other._notInclude |
| && _nameChange == other._nameChange |
| && _identityField == other._identityField) |
| return true; |
| |
| |
| return false; |
| } |
| |
| public override int GetHashCode() |
| { |
| return base.GetHashCode(); |
| } |
| } |
| |
| public class SpecialAutoSerializer : ReflectionBasedAutoSerializer |
| { |
| public override bool IsIdentityField(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_identityField") |
| return true; |
| return base.IsIdentityField(fi, type); |
| } |
| |
| public override string GetFieldName(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_nameChange") |
| return fi.Name + "NewName"; |
| |
| return fi.Name; |
| } |
| |
| public override bool IsFieldIncluded(FieldInfo fi, Type type) |
| { |
| if (fi.Name == "_notInclude") |
| return false; |
| return base.IsFieldIncluded(fi, type); |
| } |
| |
| public override FieldType GetFieldType(FieldInfo fi, Type type) |
| { |
| //if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| // return FieldType.STRING; |
| return base.GetFieldType(fi, type); |
| } |
| |
| public override object WriteTransform(FieldInfo fi, Type type, object originalValue) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| //writer.WriteField(fi.Name, fi.GetValue(o).ToString(), Type.GetType("System.String")); |
| return originalValue.ToString(); |
| } |
| else |
| return base.WriteTransform(fi, type, originalValue); |
| } |
| |
| public override object ReadTransform(FieldInfo fi, Type type, object serializeValue) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| var g = new Guid((string)serializeValue); |
| |
| //fi.SetValue(o, g); |
| return g; |
| } |
| else |
| return base.ReadTransform(fi, type, serializeValue); |
| } |
| |
| /*public override void SerializeField(object o, FieldInfo fi, IPdxWriter writer) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| writer.WriteField(fi.Name, fi.GetValue(o).ToString(), Type.GetType("System.String")); |
| } |
| else |
| base.SerializeField(o, fi, writer); |
| }*/ |
| |
| /* public override object DeserializeField(object o, FieldInfo fi, IPdxReader reader) |
| { |
| if (fi.FieldType.Equals(Type.GetType("System.Guid"))) |
| { |
| string gStr = (string)reader.ReadField(fi.Name, Type.GetType("System.String")); |
| Guid g = new Guid(gStr); |
| |
| //fi.SetValue(o, g); |
| return g; |
| } |
| else |
| return base.DeserializeField(o, fi, reader); |
| }*/ |
| } |
| |
| [Trait("Category", "Integration")] |
| public class AutoSerializationTests : TestBase |
| { |
| public AutoSerializationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) |
| { |
| } |
| |
| [Fact] |
| public void AutoPutGet() |
| { |
| using (var cluster = new Cluster(output, CreateTestCaseDirectoryName(), 1, 1)) |
| { |
| Assert.True(cluster.Start()); |
| Assert.Equal(0, cluster.Gfsh.create() |
| |
| .region() |
| .withName("testRegion") |
| .withType("REPLICATE") |
| .execute()); |
| |
| var properties = new Dictionary<string, string>() |
| { |
| { "log-level", "debug" }, |
| { "log-file", "c:/temp/autoserializertest.log" } |
| }; |
| |
| var cache = cluster.CreateCache(properties); |
| |
| var region = cache.CreateRegionFactory(RegionShortcut.PROXY) |
| .SetPoolName("default") |
| .Create<object, object>("testRegion"); |
| Assert.NotNull(region); |
| |
| cache.TypeRegistry.PdxSerializer = new ReflectionBasedAutoSerializer(); |
| |
| for (var i = 0; i < 10; i++) |
| { |
| object put; |
| object ret; |
| |
| Assert.ThrowsAny<Exception>(() => |
| { |
| put = new UnsupportedTypes(true); |
| region[i] = put; |
| var val = region[i]; |
| Console.WriteLine("Shouldn't be able to retrieve an unsupported type"); |
| }); |
| |
| put = new SerializePdx1(true); |
| region[i] = put; |
| ret = region[i]; |
| Assert.Equal(put, ret); |
| |
| put = new SerializePdx2(true); |
| region[i + 10] = put; |
| ret = region[i + 10]; |
| Assert.Equal(put, ret); |
| |
| put = new PdxTypesReflectionTest(true); |
| region[i + 20] = put; |
| ret = region[i + 20]; |
| Assert.Equal(put, ret); |
| |
| put = new SerializeAllTypes(true, i % 2); |
| region[i + 30] = put; |
| ret = region[i + 30]; |
| Assert.Equal(put, ret); |
| |
| put = new SerializePdx4(true); |
| region[i + 40] = put; |
| ret = region[i + 40]; |
| Assert.Equal(put, ret); |
| |
| var p1 = region[i + 30]; |
| var p2 = region[i + 40]; |
| Assert.True(p1 != p2, "Should NOt be equal"); |
| } |
| } |
| } |
| |
| [Fact] |
| public void AutoPutAll() |
| { |
| using (var cluster = new Cluster(output, CreateTestCaseDirectoryName(), 1, 1)) |
| { |
| Assert.True(cluster.Start()); |
| Assert.Equal(0, cluster.Gfsh.create() |
| .region() |
| .withName("testRegion") |
| .withType("REPLICATE") |
| .execute()); |
| |
| var cache = cluster.CreateCache(); |
| |
| var region = cache.CreateRegionFactory(RegionShortcut.PROXY) |
| .SetPoolName("default") |
| .Create<object, object>("testRegion"); |
| Assert.NotNull(region); |
| |
| // Register the reflectionbased serializer |
| cache.TypeRegistry.PdxSerializer = new ReflectionBasedAutoSerializer(); |
| |
| IDictionary<object, object> collection = new Dictionary<object, object>(); |
| collection.Add(100, new SerializeAllTypes(true, 0)); |
| collection.Add(200, new SerializeAllTypes(true, 1)); |
| collection.Add(300, new SerializePdx4(true)); |
| region.PutAll(collection); |
| } |
| } |
| |
| [Fact] |
| public void DerivedAutoSerializer() |
| { |
| using (var cluster = new Cluster(output, CreateTestCaseDirectoryName(), 1, 1)) |
| { |
| Assert.True(cluster.Start()); |
| Assert.Equal(0, cluster.Gfsh.create() |
| .region() |
| .withName("testRegion") |
| .withType("REPLICATE") |
| .execute()); |
| |
| var properties = new Dictionary<string, string>() |
| { |
| { "log-level", "debug" }, |
| { "log-file", "c:/temp/autoserializertest.log" } |
| }; |
| |
| var cache = cluster.CreateCache(properties); |
| |
| var region = cache.CreateRegionFactory(RegionShortcut.PROXY) |
| .SetPoolName("default") |
| .Create<object, object>("testRegion"); |
| Assert.NotNull(region); |
| |
| cache.TypeRegistry.PdxSerializer = new SpecialAutoSerializer(); |
| |
| for (var i = 0; i < 1; i++) |
| { |
| var pft = new PdxFieldTest(true); |
| region[i + 50] = pft; |
| var ret = region[i + 50]; |
| |
| Assert.NotEqual(pft, ret); |
| |
| pft.NotInclude = "default_value"; |
| Assert.Equal(pft, ret); |
| } |
| } |
| } |
| } |
| } |
