static public int allTests(global::Test.TestHelper helper) { var communicator = helper.communicator(); InputStream istr; OutputStream ostr; var output = helper.getWriter(); output.Write("testing primitive types... "); output.Flush(); { byte[] data = new byte[0]; istr = new InputStream(communicator, data); } { ostr = new OutputStream(communicator); ostr.StartEncapsulation(); ostr.WriteBool(true); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); test(istr.ReadBool()); istr.EndEncapsulation(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); test(istr.ReadBool()); istr.EndEncapsulation(); } { var data = new byte[0]; istr = new InputStream(communicator, data); try { istr.ReadBool(); test(false); } catch (UnmarshalOutOfBoundsException) { } } { ostr = new OutputStream(communicator); ostr.WriteBool(true); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadBool()); } { ostr = new OutputStream(communicator); ostr.WriteByte(1); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadByte() == 1); } { ostr = new OutputStream(communicator); ostr.WriteShort(2); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadShort() == 2); } { ostr = new OutputStream(communicator); ostr.WriteInt(3); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadInt() == 3); } { ostr = new OutputStream(communicator); ostr.WriteLong(4); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadLong() == 4); } { ostr = new OutputStream(communicator); ostr.WriteFloat((float)5.0); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadFloat() == (float)5.0); } { ostr = new OutputStream(communicator); ostr.WriteDouble(6.0); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadDouble() == 6.0); } { ostr = new OutputStream(communicator); ostr.WriteString("hello world"); var data = ostr.Finished(); istr = new InputStream(communicator, data); test(istr.ReadString().Equals("hello world")); } output.WriteLine("ok"); output.Write("testing constructed types... "); output.Flush(); { ostr = new OutputStream(communicator); ostr.Write(MyEnum.enum3); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); MyEnum e = istr.ReadMyEnum(); test(e == MyEnum.enum3); } { ostr = new OutputStream(communicator); var s = new SmallStruct(); s.bo = true; s.by = 1; s.sh = 2; s.i = 3; s.l = 4; s.f = 5.0f; s.d = 6.0; s.str = "7"; s.e = MyEnum.enum2; s.p = IMyInterfacePrx.Parse("test:default", communicator); ostr.WriteStruct(s); var data = ostr.Finished(); var s2 = new SmallStruct(new InputStream(communicator, data)); test(s2.Equals(s)); } { ostr = new OutputStream(communicator); var o = new Test.OptionalClass(); o.bo = true; o.by = 5; o.sh = 4; o.i = 3; // Can only read/write classes within encaps ostr.StartEncapsulation(); ostr.WriteClass(o); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var o2 = istr.ReadClass <Test.OptionalClass>(); istr.EndEncapsulation(); test(o2.bo == o.bo); test(o2.by == o.by); test(o2.sh == o.sh); test(o2.i == o.i); } { bool[] arr = { true, false, true, false }; ostr = new OutputStream(communicator); ostr.WriteBoolSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadBoolArray(); test(Compare(arr2, arr)); bool[][] arrS = { arr, new bool[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadBoolSS(); test(Compare(arr2S, arrS)); } { byte[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); ostr.WriteByteSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadByteArray(); test(Compare(arr2, arr)); byte[][] arrS = { arr, new byte[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadByteSS(); test(Compare(arr2S, arrS)); } { var small = new Serialize.Small(); small.i = 99; ostr = new OutputStream(communicator); ostr.WriteSerializable(small); var data = ostr.Finished(); istr = new InputStream(communicator, data); var small2 = (Serialize.Small)istr.ReadSerializable(); test(small2.i == 99); } { short[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); ostr.WriteShortSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadShortArray(); test(Compare(arr2, arr)); short[][] arrS = { arr, new short[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadShortSS(); test(Compare(arr2S, arrS)); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); ostr.WriteIntSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadIntArray(); test(Compare(arr2, arr)); int[][] arrS = { arr, new int[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadIntSS(); test(Compare(arr2S, arrS)); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); ostr.WriteLongSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadLongArray(); test(Compare(arr2, arr)); long[][] arrS = { arr, new long[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadLongSS(); test(Compare(arr2S, arrS)); } { float[] arr = { 1, 2, 3, 4 }; ostr = new OutputStream(communicator); ostr.WriteFloatSeq(arr); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); float[] arr2 = istr.ReadFloatArray(); test(Compare(arr2, arr)); float[][] arrS = { arr, new float[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadFloatSS(); test(Compare(arr2S, arrS)); } { double[] arr = { 1, 2, 3, 4 }; ostr = new OutputStream(communicator); ostr.WriteDoubleSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadDoubleArray(); test(Compare(arr2, arr)); double[][] arrS = { arr, new double[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadDoubleSS(); test(Compare(arr2S, arrS)); } { string[] arr = { "string1", "string2", "string3", "string4" }; ostr = new OutputStream(communicator); ostr.WriteStringSeq(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadStringArray(); test(Compare(arr2, arr)); string[][] arrS = { arr, new string[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadStringSS(); test(Compare(arr2S, arrS)); } { MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 }; ostr = new OutputStream(communicator); ostr.Write(arr); var data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2 = istr.ReadMyEnumS(); test(Compare(arr2, arr)); Test.MyEnum[][] arrS = { arr, new Test.MyEnum[0], arr }; ostr = new OutputStream(communicator); ostr.Write(arrS); data = ostr.Finished(); istr = new InputStream(communicator, data); var arr2S = istr.ReadMyEnumSS(); test(Compare(arr2S, arrS)); } var smallStructArray = new Test.SmallStruct[3]; for (int i = 0; i < smallStructArray.Length; ++i) { smallStructArray[i] = new Test.SmallStruct(); smallStructArray[i].bo = true; smallStructArray[i].by = 1; smallStructArray[i].sh = 2; smallStructArray[i].i = 3; smallStructArray[i].l = 4; smallStructArray[i].f = 5.0f; smallStructArray[i].d = 6.0; smallStructArray[i].str = "7"; smallStructArray[i].e = Test.MyEnum.enum2; smallStructArray[i].p = Test.IMyInterfacePrx.Parse("test:default", communicator); } var myClassArray = new Test.MyClass[4]; for (int i = 0; i < myClassArray.Length; ++i) { myClassArray[i] = new Test.MyClass(); myClassArray[i].c = myClassArray[i]; myClassArray[i].o = myClassArray[i]; myClassArray[i].s = new SmallStruct(false, 0, 0, 0, 0, 0.0f, 0.0, "", MyEnum.enum1, null); myClassArray[i].s.e = Test.MyEnum.enum2; myClassArray[i].seq1 = new bool[] { true, false, true, false }; myClassArray[i].seq2 = new byte[] { 1, 2, 3, 4 }; myClassArray[i].seq3 = new short[] { 1, 2, 3, 4 }; myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 }; myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 }; myClassArray[i].seq6 = new float[] { 1, 2, 3, 4 }; myClassArray[i].seq7 = new double[] { 1, 2, 3, 4 }; myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" }; myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; myClassArray[i].seq10 = new Test.MyClass[4]; // null elements. myClassArray[i].d = new Dictionary <string, Test.MyClass>(); myClassArray[i].d["hi"] = myClassArray[i]; } { ostr = new OutputStream(communicator); ostr.StartEncapsulation(); ostr.Write(myClassArray); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var arr2 = istr.ReadMyClassS(); istr.EndEncapsulation(); test(arr2.Length == myClassArray.Length); for (int i = 0; i < arr2.Length; ++i) { test(arr2[i] != null); test(arr2[i].c == arr2[i]); test(arr2[i].o == arr2[i]); test(arr2[i].s.e == Test.MyEnum.enum2); test(Compare(arr2[i].seq1, myClassArray[i].seq1)); test(Compare(arr2[i].seq2, myClassArray[i].seq2)); test(Compare(arr2[i].seq3, myClassArray[i].seq3)); test(Compare(arr2[i].seq4, myClassArray[i].seq4)); test(Compare(arr2[i].seq5, myClassArray[i].seq5)); test(Compare(arr2[i].seq6, myClassArray[i].seq6)); test(Compare(arr2[i].seq7, myClassArray[i].seq7)); test(Compare(arr2[i].seq8, myClassArray[i].seq8)); test(Compare(arr2[i].seq9, myClassArray[i].seq9)); test(arr2[i].d["hi"].Equals(arr2[i])); } Test.MyClass[][] arrS = { myClassArray, new Test.MyClass[0], myClassArray }; ostr = new OutputStream(communicator); ostr.StartEncapsulation(); ostr.Write(arrS); ostr.EndEncapsulation(); data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var arr2S = istr.ReadMyClassSS(); istr.EndEncapsulation(); test(arr2S.Length == arrS.Length); test(arr2S[0].Length == arrS[0].Length); test(arr2S[1].Length == arrS[1].Length); test(arr2S[2].Length == arrS[2].Length); for (int j = 0; j < arr2S.Length; ++j) { for (int k = 0; k < arr2S[j].Length; ++k) { test(arr2S[j][k].c == arr2S[j][k]); test(arr2S[j][k].o == arr2S[j][k]); test(arr2S[j][k].s.e == Test.MyEnum.enum2); test(Compare(arr2S[j][k].seq1, myClassArray[k].seq1)); test(Compare(arr2S[j][k].seq2, myClassArray[k].seq2)); test(Compare(arr2S[j][k].seq3, myClassArray[k].seq3)); test(Compare(arr2S[j][k].seq4, myClassArray[k].seq4)); test(Compare(arr2S[j][k].seq5, myClassArray[k].seq5)); test(Compare(arr2S[j][k].seq6, myClassArray[k].seq6)); test(Compare(arr2S[j][k].seq7, myClassArray[k].seq7)); test(Compare(arr2S[j][k].seq8, myClassArray[k].seq8)); test(Compare(arr2S[j][k].seq9, myClassArray[k].seq9)); test(arr2S[j][k].d["hi"].Equals(arr2S[j][k])); } } } { ostr = new OutputStream(communicator); var obj = new Test.MyClass(); obj.s = new SmallStruct(false, 0, 0, 0, 0, 0.0f, 0.0, "", MyEnum.enum1, null); obj.s.e = Test.MyEnum.enum2; ostr.StartEncapsulation(); ostr.WriteClass(obj); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var robj = istr.ReadClass <Test.MyClass>(); istr.EndEncapsulation(); test(robj != null); test(robj.s.e == Test.MyEnum.enum2); } { ostr = new OutputStream(communicator); ostr.StartEncapsulation(ostr.Encoding, FormatType.SlicedFormat); var ex = new Test.MyException(); var c = new Test.MyClass(); c.c = c; c.o = c; c.s = new SmallStruct(false, 0, 0, 0, 0, 0.0f, 0.0, "", MyEnum.enum1, null); c.s.e = Test.MyEnum.enum2; c.seq1 = new bool[] { true, false, true, false }; c.seq2 = new byte[] { 1, 2, 3, 4 }; c.seq3 = new short[] { 1, 2, 3, 4 }; c.seq4 = new int[] { 1, 2, 3, 4 }; c.seq5 = new long[] { 1, 2, 3, 4 }; c.seq6 = new float[] { 1, 2, 3, 4 }; c.seq7 = new double[] { 1, 2, 3, 4 }; c.seq8 = new string[] { "string1", "string2", "string3", "string4" }; c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; c.seq10 = new Test.MyClass[4]; // null elements. c.d = new Dictionary <string, Test.MyClass>(); c.d.Add("hi", c); ex.c = c; ostr.WriteException(ex); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); try { istr.ThrowException(); test(false); } catch (Test.MyException ex1) { test(ex1.c.s.e == c.s.e); test(Compare(ex1.c.seq1, c.seq1)); test(Compare(ex1.c.seq2, c.seq2)); test(Compare(ex1.c.seq3, c.seq3)); test(Compare(ex1.c.seq4, c.seq4)); test(Compare(ex1.c.seq5, c.seq5)); test(Compare(ex1.c.seq6, c.seq6)); test(Compare(ex1.c.seq7, c.seq7)); test(Compare(ex1.c.seq8, c.seq8)); test(Compare(ex1.c.seq9, c.seq9)); } catch (UserException) { test(false); } istr.EndEncapsulation(); } { var dict = new Dictionary <byte, bool>(); dict.Add(4, true); dict.Add(1, false); ostr = new OutputStream(communicator); ostr.Write(dict); var data = ostr.Finished(); istr = new InputStream(communicator, data); var dict2 = istr.ReadByteBoolD(); test(global::Test.Collections.Equals(dict2, dict)); } { var dict = new Dictionary <short, int>(); dict.Add(1, 9); dict.Add(4, 8); ostr = new OutputStream(communicator); ostr.Write(dict); var data = ostr.Finished(); istr = new InputStream(communicator, data); var dict2 = istr.ReadShortIntD(); test(global::Test.Collections.Equals(dict2, dict)); } { var dict = new Dictionary <long, float>(); dict.Add(123809828, 0.51f); dict.Add(123809829, 0.56f); ostr = new OutputStream(communicator); ostr.Write(dict); var data = ostr.Finished(); istr = new InputStream(communicator, data); var dict2 = istr.ReadLongFloatD(); test(global::Test.Collections.Equals(dict2, dict)); } { var dict = new Dictionary <string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); ostr = new OutputStream(communicator); StringStringDHelper.Write(ostr, dict); var data = ostr.Finished(); istr = new InputStream(communicator, data); var dict2 = istr.ReadStringStringD(); test(global::Test.Collections.Equals(dict2, dict)); } { var dict = new Dictionary <string, Test.MyClass>(); var c = new Test.MyClass(); c.s = new SmallStruct(false, 0, 0, 0, 0, 0.0f, 0.0, "", MyEnum.enum1, null); c.s.e = Test.MyEnum.enum2; dict.Add("key1", c); c = new Test.MyClass(); c.s = new SmallStruct(false, 0, 0, 0, 0, 0.0f, 0.0, "", MyEnum.enum1, null); c.s.e = Test.MyEnum.enum3; dict.Add("key2", c); ostr = new OutputStream(communicator); ostr.StartEncapsulation(); ostr.Write(dict); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var dict2 = istr.ReadStringMyClassD(); istr.EndEncapsulation(); test(dict2.Count == dict.Count); test(dict2["key1"].s.e == Test.MyEnum.enum2); test(dict2["key2"].s.e == Test.MyEnum.enum3); } { bool[] arr = { true, false, true, false }; ostr = new OutputStream(communicator); var l = new List <bool>(arr); ostr.StartEncapsulation(); ostr.WriteBoolSeq(l); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var l2 = new List <bool>(istr.ReadBoolArray()); istr.EndEncapsulation(); test(Compare(l, l2)); } { byte[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); var l = new List <byte>(arr); ostr.WriteByteSeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new List <byte>(istr.ReadByteArray()); test(Compare(l2, l)); } { MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 }; ostr = new OutputStream(communicator); var l = new List <MyEnum>(arr); ostr.Write(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadMyEnumList(); test(Compare(l2, l)); } { ostr = new OutputStream(communicator); var l = new List <SmallStruct>(smallStructArray); ostr.Write(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadSmallStructList(); test(l2.Count == l.Count); for (int i = 0; i < l2.Count; ++i) { test(l2[i].Equals(smallStructArray[i])); } } { ostr = new OutputStream(communicator); ostr.StartEncapsulation(); var l = new List <MyClass>(myClassArray); ostr.Write(l); ostr.EndEncapsulation(); var data = ostr.Finished(); istr = new InputStream(communicator, data); istr.StartEncapsulation(); var l2 = istr.ReadMyClassList(); istr.EndEncapsulation(); test(l2.Count == l.Count); for (int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } } { var arr = new IObjectPrx[2]; arr[0] = IObjectPrx.Parse("zero", communicator); arr[1] = IObjectPrx.Parse("one", communicator); ostr = new OutputStream(communicator); var l = new List <IObjectPrx>(arr); ostr.Write(arr); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new List <IObjectPrx>(istr.ReadObjectProxySeq()); test(Compare(l2, l)); } { var arr = new Test.IMyInterfacePrx[2]; arr[0] = Test.IMyInterfacePrx.Parse("zero", communicator); arr[1] = Test.IMyInterfacePrx.Parse("one", communicator); ostr = new OutputStream(communicator); var l = new List <Test.IMyInterfacePrx>(arr); ostr.WriteProxySeq(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadMyInterfaceProxyList(); test(Compare(l2, l)); } { short[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); var l = new LinkedList <short>(arr); ostr.WriteShortSeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new LinkedList <short>(istr.ReadShortArray()); test(Compare(l2, l)); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); var l = new LinkedList <int>(arr); ostr.WriteIntSeq(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new LinkedList <int>(istr.ReadIntArray()); test(Compare(l2, l)); } { MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 }; ostr = new OutputStream(communicator); var l = new LinkedList <Test.MyEnum>(arr); ostr.Write(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadMyEnumLinkedList(); test(Compare(l2, l)); } { ostr = new OutputStream(communicator); var l = new LinkedList <SmallStruct>(smallStructArray); ostr.Write(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadSmallStructLinkedList(); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; ostr = new OutputStream(communicator); var l = new Stack <long>(arr); ostr.WriteLongSeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new Stack <long>(istr.ReadLongArray().Reverse()); test(Compare(l2, l)); } { float[] arr = { 1, 2, 3, 4 }; ostr = new OutputStream(communicator); var l = new Stack <float>(arr); ostr.WriteFloatSeq(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new Stack <float>(istr.ReadFloatArray().Reverse()); test(Compare(l2, l)); } { ostr = new OutputStream(communicator); var l = new Stack <Test.SmallStruct>(smallStructArray); ostr.Write(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadSmallStructStack(); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { var arr = new Test.IMyInterfacePrx[2]; arr[0] = Test.IMyInterfacePrx.Parse("zero", communicator); arr[1] = Test.IMyInterfacePrx.Parse("one", communicator); ostr = new OutputStream(communicator); var l = new Stack <Test.IMyInterfacePrx>(arr); ostr.WriteProxySeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadMyInterfaceProxyStack(); test(Compare(l2, l)); } { double[] arr = { 1, 2, 3, 4 }; ostr = new OutputStream(communicator); var l = new Queue <double>(arr); ostr.WriteDoubleSeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new Queue <double>(istr.ReadDoubleArray()); test(Compare(l2, l)); } { string[] arr = { "string1", "string2", "string3", "string4" }; ostr = new OutputStream(communicator); var l = new Queue <string>(arr); ostr.WriteStringSeq(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = new Queue <string>(istr.ReadStringCollection()); test(Compare(l2, l)); } { ostr = new OutputStream(communicator); var l = new Queue <Test.SmallStruct>(smallStructArray); ostr.Write(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadSmallStructQueue(); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; ostr = new OutputStream(communicator); var l = new List <string[]>(arrS); ostr.Write(l); byte[] data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadStringSList(); test(Compare(l2, l)); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; ostr = new OutputStream(communicator); var l = new Stack <string[]>(arrS); ostr.Write(l); var data = ostr.Finished(); istr = new InputStream(communicator, data); var l2 = istr.ReadStringSStack(); test(Compare(l2, l)); } { var dict = new SortedDictionary <string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); ostr = new OutputStream(communicator); ostr.Write(dict); var data = ostr.Finished(); istr = new InputStream(communicator, data); var dict2 = istr.ReadSortedStringStringD(); test(global::Test.Collections.Equals(dict2, dict)); } output.WriteLine("ok"); return(0); }
static public int allTests(global::Test.TestHelper helper) { var communicator = helper.communicator(); Ice.InputStream inS; Ice.OutputStream outS; var output = helper.getWriter(); output.Write("testing primitive types... "); output.Flush(); { byte[] data = new byte[0]; inS = new Ice.InputStream(communicator, data); } { outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeBool(true); outS.endEncapsulation(); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); inS.startEncapsulation(); test(inS.readBool()); inS.endEncapsulation(); inS = new Ice.InputStream(communicator, data); inS.startEncapsulation(); test(inS.readBool()); inS.endEncapsulation(); } { var data = new byte[0]; inS = new Ice.InputStream(communicator, data); try { inS.readBool(); test(false); } catch (Ice.UnmarshalOutOfBoundsException) { } } { outS = new Ice.OutputStream(communicator); outS.writeBool(true); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readBool()); } { outS = new Ice.OutputStream(communicator); outS.writeByte(1); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readByte() == 1); } { outS = new Ice.OutputStream(communicator); outS.writeShort(2); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readShort() == 2); } { outS = new Ice.OutputStream(communicator); outS.writeInt(3); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readInt() == 3); } { outS = new Ice.OutputStream(communicator); outS.writeLong(4); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readLong() == 4); } { outS = new Ice.OutputStream(communicator); outS.writeFloat((float)5.0); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readFloat() == (float)5.0); } { outS = new Ice.OutputStream(communicator); outS.writeDouble(6.0); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readDouble() == 6.0); } { outS = new Ice.OutputStream(communicator); outS.writeString("hello world"); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); test(inS.readString().Equals("hello world")); } output.WriteLine("ok"); output.Write("testing constructed types... "); output.Flush(); { outS = new Ice.OutputStream(communicator); Test.MyEnumHelper.write(outS, Test.MyEnum.enum3); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var e = Test.MyEnumHelper.read(inS); test(e == Test.MyEnum.enum3); } { outS = new Ice.OutputStream(communicator); var s = new Test.SmallStruct(); s.bo = true; s.by = 1; s.sh = 2; s.i = 3; s.l = 4; s.f = 5.0f; s.d = 6.0; s.str = "7"; s.e = Test.MyEnum.enum2; s.p = Test.MyInterfacePrx.Parse("test:default", communicator); Test.SmallStruct.ice_write(outS, s); var data = outS.finished(); var s2 = Test.SmallStruct.ice_read(new Ice.InputStream(communicator, data)); test(s2.Equals(s)); } { outS = new Ice.OutputStream(communicator); var o = new Test.OptionalClass(); o.bo = true; o.by = 5; o.sh = 4; o.i = 3; outS.writeValue(o); outS.writePendingValues(); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); TestReadValueCallback cb = new TestReadValueCallback(); inS.readValue(cb.invoke); inS.readPendingValues(); var o2 = (Test.OptionalClass)cb.obj; test(o2.bo == o.bo); test(o2.by == o.by); if (communicator.getProperties().getProperty("Ice.Default.EncodingVersion").Equals("1.0")) { test(!o2.sh.HasValue); test(!o2.i.HasValue); } else { test(o2.sh.Value == o.sh.Value); test(o2.i.Value == o.i.Value); } } { outS = new Ice.OutputStream(communicator, Ice.Util.Encoding_1_0); var o = new Test.OptionalClass(); o.bo = true; o.by = 5; o.sh = 4; o.i = 3; outS.writeValue(o); outS.writePendingValues(); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, Ice.Util.Encoding_1_0, data); var cb = new TestReadValueCallback(); inS.readValue(cb.invoke); inS.readPendingValues(); var o2 = (Test.OptionalClass)cb.obj; test(o2.bo == o.bo); test(o2.by == o.by); test(!o2.sh.HasValue); test(!o2.i.HasValue); } { bool[] arr = { true, false, true, false }; outS = new Ice.OutputStream(communicator); Ice.BoolSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.BoolSeqHelper.read(inS); test(Compare(arr2, arr)); bool[][] arrS = { arr, new bool[0], arr }; outS = new Ice.OutputStream(communicator); Test.BoolSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.BoolSSHelper.read(inS); test(Compare(arr2S, arrS)); } { byte[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); Ice.ByteSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.ByteSeqHelper.read(inS); test(Compare(arr2, arr)); byte[][] arrS = { arr, new byte[0], arr }; outS = new Ice.OutputStream(communicator); Test.ByteSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.ByteSSHelper.read(inS); test(Compare(arr2S, arrS)); } { Serialize.Small small = new Serialize.Small(); small.i = 99; outS = new Ice.OutputStream(communicator); outS.writeSerializable(small); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var small2 = (Serialize.Small)inS.readSerializable(); test(small2.i == 99); } { short[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); Ice.ShortSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.ShortSeqHelper.read(inS); test(Compare(arr2, arr)); short[][] arrS = { arr, new short[0], arr }; outS = new Ice.OutputStream(communicator); Test.ShortSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.ShortSSHelper.read(inS); test(Compare(arr2S, arrS)); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); Ice.IntSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.IntSeqHelper.read(inS); test(Compare(arr2, arr)); int[][] arrS = { arr, new int[0], arr }; outS = new Ice.OutputStream(communicator); Test.IntSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.IntSSHelper.read(inS); test(Compare(arr2S, arrS)); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); Ice.LongSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.LongSeqHelper.read(inS); test(Compare(arr2, arr)); long[][] arrS = { arr, new long[0], arr }; outS = new Ice.OutputStream(communicator); Test.LongSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.LongSSHelper.read(inS); test(Compare(arr2S, arrS)); } { float[] arr = { 1, 2, 3, 4 }; outS = new Ice.OutputStream(communicator); Ice.FloatSeqHelper.write(outS, arr); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); float[] arr2 = Ice.FloatSeqHelper.read(inS); test(Compare(arr2, arr)); float[][] arrS = { arr, new float[0], arr }; outS = new Ice.OutputStream(communicator); Test.FloatSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.FloatSSHelper.read(inS); test(Compare(arr2S, arrS)); } { double[] arr = { 1, 2, 3, 4 }; outS = new Ice.OutputStream(communicator); Ice.DoubleSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.DoubleSeqHelper.read(inS); test(Compare(arr2, arr)); double[][] arrS = { arr, new double[0], arr }; outS = new Ice.OutputStream(communicator); Test.DoubleSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.DoubleSSHelper.read(inS); test(Compare(arr2S, arrS)); } { string[] arr = { "string1", "string2", "string3", "string4" }; outS = new Ice.OutputStream(communicator); Ice.StringSeqHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Ice.StringSeqHelper.read(inS); test(Compare(arr2, arr)); string[][] arrS = { arr, new string[0], arr }; outS = new Ice.OutputStream(communicator); Test.StringSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.StringSSHelper.read(inS); test(Compare(arr2S, arrS)); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; outS = new Ice.OutputStream(communicator); Test.MyEnumSHelper.write(outS, arr); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Test.MyEnumSHelper.read(inS); test(Compare(arr2, arr)); Test.MyEnum[][] arrS = { arr, new Test.MyEnum[0], arr }; outS = new Ice.OutputStream(communicator); Test.MyEnumSSHelper.write(outS, arrS); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.MyEnumSSHelper.read(inS); test(Compare(arr2S, arrS)); } var smallStructArray = new Test.SmallStruct[3]; for (int i = 0; i < smallStructArray.Length; ++i) { smallStructArray[i] = new Test.SmallStruct(); smallStructArray[i].bo = true; smallStructArray[i].by = 1; smallStructArray[i].sh = 2; smallStructArray[i].i = 3; smallStructArray[i].l = 4; smallStructArray[i].f = 5.0f; smallStructArray[i].d = 6.0; smallStructArray[i].str = "7"; smallStructArray[i].e = Test.MyEnum.enum2; smallStructArray[i].p = Test.MyInterfacePrx.Parse("test:default", communicator); } var myClassArray = new Test.MyClass[4]; for (int i = 0; i < myClassArray.Length; ++i) { myClassArray[i] = new Test.MyClass(); myClassArray[i].c = myClassArray[i]; myClassArray[i].o = myClassArray[i]; myClassArray[i].s = new Test.SmallStruct(); myClassArray[i].s.e = Test.MyEnum.enum2; myClassArray[i].seq1 = new bool[] { true, false, true, false }; myClassArray[i].seq2 = new byte[] { 1, 2, 3, 4 }; myClassArray[i].seq3 = new short[] { 1, 2, 3, 4 }; myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 }; myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 }; myClassArray[i].seq6 = new float[] { 1, 2, 3, 4 }; myClassArray[i].seq7 = new double[] { 1, 2, 3, 4 }; myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" }; myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; myClassArray[i].seq10 = new Test.MyClass[4]; // null elements. myClassArray[i].d = new Dictionary <string, Test.MyClass>(); myClassArray[i].d["hi"] = myClassArray[i]; } { outS = new Ice.OutputStream(communicator); Test.MyClassSHelper.write(outS, myClassArray); outS.writePendingValues(); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2 = Test.MyClassSHelper.read(inS); inS.readPendingValues(); test(arr2.Length == myClassArray.Length); for (int i = 0; i < arr2.Length; ++i) { test(arr2[i] != null); test(arr2[i].c == arr2[i]); test(arr2[i].o == arr2[i]); test(arr2[i].s.e == Test.MyEnum.enum2); test(Compare(arr2[i].seq1, myClassArray[i].seq1)); test(Compare(arr2[i].seq2, myClassArray[i].seq2)); test(Compare(arr2[i].seq3, myClassArray[i].seq3)); test(Compare(arr2[i].seq4, myClassArray[i].seq4)); test(Compare(arr2[i].seq5, myClassArray[i].seq5)); test(Compare(arr2[i].seq6, myClassArray[i].seq6)); test(Compare(arr2[i].seq7, myClassArray[i].seq7)); test(Compare(arr2[i].seq8, myClassArray[i].seq8)); test(Compare(arr2[i].seq9, myClassArray[i].seq9)); test(arr2[i].d["hi"].Equals(arr2[i])); } Test.MyClass[][] arrS = { myClassArray, new Test.MyClass[0], myClassArray }; outS = new Ice.OutputStream(communicator); Test.MyClassSSHelper.write(outS, arrS); outS.writePendingValues(); data = outS.finished(); inS = new Ice.InputStream(communicator, data); var arr2S = Test.MyClassSSHelper.read(inS); inS.readPendingValues(); test(arr2S.Length == arrS.Length); test(arr2S[0].Length == arrS[0].Length); test(arr2S[1].Length == arrS[1].Length); test(arr2S[2].Length == arrS[2].Length); for (int j = 0; j < arr2S.Length; ++j) { for (int k = 0; k < arr2S[j].Length; ++k) { test(arr2S[j][k].c == arr2S[j][k]); test(arr2S[j][k].o == arr2S[j][k]); test(arr2S[j][k].s.e == Test.MyEnum.enum2); test(Compare(arr2S[j][k].seq1, myClassArray[k].seq1)); test(Compare(arr2S[j][k].seq2, myClassArray[k].seq2)); test(Compare(arr2S[j][k].seq3, myClassArray[k].seq3)); test(Compare(arr2S[j][k].seq4, myClassArray[k].seq4)); test(Compare(arr2S[j][k].seq5, myClassArray[k].seq5)); test(Compare(arr2S[j][k].seq6, myClassArray[k].seq6)); test(Compare(arr2S[j][k].seq7, myClassArray[k].seq7)); test(Compare(arr2S[j][k].seq8, myClassArray[k].seq8)); test(Compare(arr2S[j][k].seq9, myClassArray[k].seq9)); test(arr2S[j][k].d["hi"].Equals(arr2S[j][k])); } } } { outS = new Ice.OutputStream(communicator); var obj = new Test.MyClass(); obj.s = new Test.SmallStruct(); obj.s.e = Test.MyEnum.enum2; var writer = new TestValueWriter(obj); outS.writeValue(writer); outS.writePendingValues(); var data = outS.finished(); test(writer.called); inS = new Ice.InputStream(communicator, data); var cb = new TestReadValueCallback(); inS.readValue(cb.invoke); inS.readPendingValues(); test(cb.obj != null); test(cb.obj is Test.MyClass); var robj = (Test.MyClass)cb.obj; test(robj != null); test(robj.s.e == Test.MyEnum.enum2); } { outS = new Ice.OutputStream(communicator); var ex = new Test.MyException(); var c = new Test.MyClass(); c.c = c; c.o = c; c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; c.seq1 = new bool[] { true, false, true, false }; c.seq2 = new byte[] { 1, 2, 3, 4 }; c.seq3 = new short[] { 1, 2, 3, 4 }; c.seq4 = new int[] { 1, 2, 3, 4 }; c.seq5 = new long[] { 1, 2, 3, 4 }; c.seq6 = new float[] { 1, 2, 3, 4 }; c.seq7 = new double[] { 1, 2, 3, 4 }; c.seq8 = new string[] { "string1", "string2", "string3", "string4" }; c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; c.seq10 = new Test.MyClass[4]; // null elements. c.d = new Dictionary <string, Test.MyClass>(); c.d.Add("hi", c); ex.c = c; outS.writeException(ex); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); try { inS.throwException(); test(false); } catch (Test.MyException ex1) { test(ex1.c.s.e == c.s.e); test(Compare(ex1.c.seq1, c.seq1)); test(Compare(ex1.c.seq2, c.seq2)); test(Compare(ex1.c.seq3, c.seq3)); test(Compare(ex1.c.seq4, c.seq4)); test(Compare(ex1.c.seq5, c.seq5)); test(Compare(ex1.c.seq6, c.seq6)); test(Compare(ex1.c.seq7, c.seq7)); test(Compare(ex1.c.seq8, c.seq8)); test(Compare(ex1.c.seq9, c.seq9)); } catch (Ice.UserException) { test(false); } } { var dict = new Dictionary <byte, bool>(); dict.Add(4, true); dict.Add(1, false); outS = new Ice.OutputStream(communicator); Test.ByteBoolDHelper.write(outS, dict); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.ByteBoolDHelper.read(inS); test(Ice.CollectionComparer.Equals(dict2, dict)); } { var dict = new Dictionary <short, int>(); dict.Add(1, 9); dict.Add(4, 8); outS = new Ice.OutputStream(communicator); Test.ShortIntDHelper.write(outS, dict); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.ShortIntDHelper.read(inS); test(Ice.CollectionComparer.Equals(dict2, dict)); } { var dict = new Dictionary <long, float>(); dict.Add(123809828, 0.51f); dict.Add(123809829, 0.56f); outS = new Ice.OutputStream(communicator); Test.LongFloatDHelper.write(outS, dict); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.LongFloatDHelper.read(inS); test(Ice.CollectionComparer.Equals(dict2, dict)); } { var dict = new Dictionary <string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); outS = new Ice.OutputStream(communicator); Test.StringStringDHelper.write(outS, dict); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.StringStringDHelper.read(inS); test(Ice.CollectionComparer.Equals(dict2, dict)); } { var dict = new Dictionary <string, Test.MyClass>(); var c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; dict.Add("key1", c); c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum3; dict.Add("key2", c); outS = new Ice.OutputStream(communicator); Test.StringMyClassDHelper.write(outS, dict); outS.writePendingValues(); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.StringMyClassDHelper.read(inS); inS.readPendingValues(); test(dict2.Count == dict.Count); test(dict2["key1"].s.e == Test.MyEnum.enum2); test(dict2["key2"].s.e == Test.MyEnum.enum3); } { bool[] arr = { true, false, true, false }; outS = new Ice.OutputStream(communicator); var l = new List <bool>(arr); Test.BoolListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.BoolListHelper.read(inS); test(Compare(l, l2)); } { byte[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); var l = new List <byte>(arr); Test.ByteListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.ByteListHelper.read(inS); test(Compare(l2, l)); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; outS = new Ice.OutputStream(communicator); var l = new List <Test.MyEnum>(arr); Test.MyEnumListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyEnumListHelper.read(inS); test(Compare(l2, l)); } { outS = new Ice.OutputStream(communicator); var l = new List <Test.SmallStruct>(smallStructArray); Test.SmallStructListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.SmallStructListHelper.read(inS); test(l2.Count == l.Count); for (int i = 0; i < l2.Count; ++i) { test(l2[i].Equals(smallStructArray[i])); } } { outS = new Ice.OutputStream(communicator); var l = new List <Test.MyClass>(myClassArray); Test.MyClassListHelper.write(outS, l); outS.writePendingValues(); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyClassListHelper.read(inS); inS.readPendingValues(); test(l2.Count == l.Count); for (int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } } { var arr = new IObjectPrx[2]; arr[0] = IObjectPrx.Parse("zero", communicator); arr[1] = IObjectPrx.Parse("one", communicator); outS = new Ice.OutputStream(communicator); var l = new List <Ice.IObjectPrx>(arr); Test.MyClassProxyListHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyClassProxyListHelper.read(inS); test(Compare(l2, l)); } { var arr = new Test.MyInterfacePrx[2]; arr[0] = Test.MyInterfacePrx.Parse("zero", communicator); arr[1] = Test.MyInterfacePrx.Parse("one", communicator); outS = new Ice.OutputStream(communicator); var l = new List <Test.MyInterfacePrx>(arr); Test.MyInterfaceProxyListHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyInterfaceProxyListHelper.read(inS); test(Compare(l2, l)); } { short[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); var l = new LinkedList <short>(arr); Test.ShortLinkedListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.ShortLinkedListHelper.read(inS); test(Compare(l2, l)); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); LinkedList <int> l = new LinkedList <int>(arr); Test.IntLinkedListHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); LinkedList <int> l2 = Test.IntLinkedListHelper.read(inS); test(Compare(l2, l)); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; outS = new Ice.OutputStream(communicator); LinkedList <Test.MyEnum> l = new LinkedList <Test.MyEnum>(arr); Test.MyEnumLinkedListHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); LinkedList <Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(inS); test(Compare(l2, l)); } { outS = new Ice.OutputStream(communicator); var l = new LinkedList <Test.SmallStruct>(smallStructArray); Test.SmallStructLinkedListHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.SmallStructLinkedListHelper.read(inS); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; outS = new Ice.OutputStream(communicator); var l = new Stack <long>(arr); Test.LongStackHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.LongStackHelper.read(inS); test(Compare(l2, l)); } { float[] arr = { 1, 2, 3, 4 }; outS = new Ice.OutputStream(communicator); var l = new Stack <float>(arr); Test.FloatStackHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.FloatStackHelper.read(inS); test(Compare(l2, l)); } { outS = new Ice.OutputStream(communicator); var l = new Stack <Test.SmallStruct>(smallStructArray); Test.SmallStructStackHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.SmallStructStackHelper.read(inS); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { var arr = new IObjectPrx[2]; arr[0] = IObjectPrx.Parse("zero", communicator); arr[1] = IObjectPrx.Parse("one", communicator); outS = new Ice.OutputStream(communicator); var l = new Stack <Ice.IObjectPrx>(arr); Test.MyClassProxyStackHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyClassProxyStackHelper.read(inS); test(Compare(l2, l)); } { var arr = new Test.MyInterfacePrx[2]; arr[0] = Test.MyInterfacePrx.Parse("zero", communicator); arr[1] = Test.MyInterfacePrx.Parse("one", communicator); outS = new Ice.OutputStream(communicator); var l = new Stack <Test.MyInterfacePrx>(arr); Test.MyInterfaceProxyStackHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.MyInterfaceProxyStackHelper.read(inS); test(Compare(l2, l)); } { double[] arr = { 1, 2, 3, 4 }; outS = new Ice.OutputStream(communicator); var l = new Queue <double>(arr); Test.DoubleQueueHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.DoubleQueueHelper.read(inS); test(Compare(l2, l)); } { string[] arr = { "string1", "string2", "string3", "string4" }; outS = new Ice.OutputStream(communicator); var l = new Queue <string>(arr); Test.StringQueueHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.StringQueueHelper.read(inS); test(Compare(l2, l)); } { outS = new Ice.OutputStream(communicator); var l = new Queue <Test.SmallStruct>(smallStructArray); Test.SmallStructQueueHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.SmallStructQueueHelper.read(inS); test(l2.Count == l.Count); var e = l.GetEnumerator(); var e2 = l2.GetEnumerator(); while (e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; outS = new Ice.OutputStream(communicator); var l = new List <string[]>(arrS); Test.StringSListHelper.write(outS, l); byte[] data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.StringSListHelper.read(inS); test(Compare(l2, l)); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; outS = new Ice.OutputStream(communicator); var l = new Stack <string[]>(arrS); Test.StringSStackHelper.write(outS, l); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var l2 = Test.StringSStackHelper.read(inS); test(Compare(l2, l)); } { var dict = new SortedDictionary <string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); outS = new Ice.OutputStream(communicator); Test.SortedStringStringDHelper.write(outS, dict); var data = outS.finished(); inS = new Ice.InputStream(communicator, data); var dict2 = Test.SortedStringStringDHelper.read(inS); test(Ice.CollectionComparer.Equals(dict2, dict)); } output.WriteLine("ok"); return(0); }
private static int run(string[] args, Ice.Communicator communicator) { MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper(); communicator.addObjectFactory(factoryWrapper, Test.MyClass.ice_staticId()); communicator.addObjectFactory(new MyInterfaceFactory(), Test.MyInterfaceDisp_.ice_staticId()); Ice.InputStream @in; Ice.OutputStream @out; Console.Write("testing primitive types... "); Console.Out.Flush(); { byte[] data = new byte[0]; @in = Ice.Util.createInputStream(communicator, data); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.startEncapsulation(); @out.writeBool(true); @out.endEncapsulation(); byte[] data = @out.finished(); @out.destroy(); @in = Ice.Util.createInputStream(communicator, data); @in.startEncapsulation(); test(@in.readBool()); @in.endEncapsulation(); @in.destroy(); } { byte[] data = new byte[0]; @in = Ice.Util.createInputStream(communicator, data); try { @in.readBool(); test(false); } catch(Ice.UnmarshalOutOfBoundsException) { } @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeBool(true); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readBool()); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeByte((byte)1); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readByte() == (byte)1); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeShort((short)2); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readShort() == (short)2); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeInt(3); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readInt() == 3); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeLong(4); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readLong() == 4); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeFloat((float)5.0); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readFloat() == (float)5.0); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeDouble(6.0); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readDouble() == 6.0); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeString("hello world"); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readString().Equals("hello world")); @out.destroy(); @in.destroy(); } Console.WriteLine("ok"); Console.Write("testing constructed types... "); Console.Out.Flush(); { @out = Ice.Util.createOutputStream(communicator); Test.MyEnumHelper.write(@out, Test.MyEnum.enum3); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(Test.MyEnumHelper.read(@in) == Test.MyEnum.enum3); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.SmallStruct s = new Test.SmallStruct(); s.bo = true; s.by = (byte)1; s.sh = (short)2; s.i = 3; s.l = 4; s.f = (float)5.0; s.d = 6.0; s.str = "7"; s.e = Test.MyEnum.enum2; s.p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default")); s.ice_write(@out); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.SmallStruct s2 = new Test.SmallStruct(); s2.ice_read(@in); test(s2.Equals(s)); @out.destroy(); @in.destroy(); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); Ice.BoolSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); bool[] arr2 = Ice.BoolSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); bool[][] arrS = { arr, new bool[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.BoolSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); bool[][] arr2S = Test.BoolSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { byte[] arr = { (byte)0x01, (byte)0x11, (byte)0x12, (byte)0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.ByteSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); byte[] arr2 = Ice.ByteSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); byte[][] arrS = { arr, new byte[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.ByteSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); byte[][] arr2S = Test.ByteSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } #if !COMPACT { Serialize.Small small = new Serialize.Small(); small.i = 99; @out = Ice.Util.createOutputStream(communicator); @out.writeSerializable(small); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Serialize.Small small2 = (Serialize.Small)@in.readSerializable(); test(small2.i == 99); @out.destroy(); @in.destroy(); } #endif { short[] arr = { (short)0x01, (short)0x11, (short)0x12, (short)0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.ShortSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); short[] arr2 = Ice.ShortSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); short[][] arrS = { arr, new short[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.ShortSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); short[][] arr2S = Test.ShortSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.IntSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); int[] arr2 = Ice.IntSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); int[][] arrS = { arr, new int[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.IntSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); int[][] arr2S = Test.IntSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.LongSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); long[] arr2 = Ice.LongSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); long[][] arrS = { arr, new long[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.LongSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); long[][] arr2S = Test.LongSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { float[] arr = { (float)1, (float)2, (float)3, (float)4 }; @out = Ice.Util.createOutputStream(communicator); Ice.FloatSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); float[] arr2 = Ice.FloatSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); float[][] arrS = { arr, new float[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.FloatSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); float[][] arr2S = Test.FloatSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { double[] arr = { (double)1, (double)2, (double)3, (double)4 }; @out = Ice.Util.createOutputStream(communicator); Ice.DoubleSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); double[] arr2 = Ice.DoubleSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); double[][] arrS = { arr, new double[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.DoubleSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); double[][] arr2S = Test.DoubleSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Ice.StringSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); string[] arr2 = Ice.StringSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.StringSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); string[][] arr2S = Test.StringSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumSHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnum[] arr2 = Test.MyEnumSHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); Test.MyEnum[][] arrS = { arr, new Test.MyEnum[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnum[][] arr2S = Test.MyEnumSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } Test.SmallStruct[] smallStructArray = new Test.SmallStruct[3]; for(int i = 0; i < smallStructArray.Length; ++i) { smallStructArray[i] = new Test.SmallStruct(); smallStructArray[i].bo = true; smallStructArray[i].by = (byte)1; smallStructArray[i].sh = (short)2; smallStructArray[i].i = 3; smallStructArray[i].l = 4; smallStructArray[i].f = (float)5.0; smallStructArray[i].d = 6.0; smallStructArray[i].str = "7"; smallStructArray[i].e = Test.MyEnum.enum2; smallStructArray[i].p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default")); } Test.MyClass[] myClassArray = new Test.MyClass[4]; for(int i = 0; i < myClassArray.Length; ++i) { myClassArray[i] = new Test.MyClass(); myClassArray[i].c = myClassArray[i]; myClassArray[i].o = myClassArray[i]; myClassArray[i].s = new Test.SmallStruct(); myClassArray[i].s.e = Test.MyEnum.enum2; myClassArray[i].seq1 = new bool[] { true, false, true, false }; myClassArray[i].seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }; myClassArray[i].seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 }; myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 }; myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 }; myClassArray[i].seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 }; myClassArray[i].seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 }; myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" }; myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; myClassArray[i].seq10 = new Test.MyClass[4]; // null elements. myClassArray[i].d = new System.Collections.Generic.Dictionary<string, Test.MyClass>(); myClassArray[i].d["hi"] = myClassArray[i]; } { @out = Ice.Util.createOutputStream(communicator); Test.MyClassSHelper.write(@out, myClassArray); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClass[] arr2 = Test.MyClassSHelper.read(@in); @in.readPendingObjects(); test(arr2.Length == myClassArray.Length); for(int i = 0; i < arr2.Length; ++i) { test(arr2[i] != null); test(arr2[i].c == arr2[i]); test(arr2[i].o == arr2[i]); test(arr2[i].s.e == Test.MyEnum.enum2); test(Compare(arr2[i].seq1, myClassArray[i].seq1)); test(Compare(arr2[i].seq2, myClassArray[i].seq2)); test(Compare(arr2[i].seq3, myClassArray[i].seq3)); test(Compare(arr2[i].seq4, myClassArray[i].seq4)); test(Compare(arr2[i].seq5, myClassArray[i].seq5)); test(Compare(arr2[i].seq6, myClassArray[i].seq6)); test(Compare(arr2[i].seq7, myClassArray[i].seq7)); test(Compare(arr2[i].seq8, myClassArray[i].seq8)); test(Compare(arr2[i].seq9, myClassArray[i].seq9)); test(arr2[i].d["hi"].Equals(arr2[i])); } @out.destroy(); @in.destroy(); Test.MyClass[][] arrS = { myClassArray, new Test.MyClass[0], myClassArray }; @out = Ice.Util.createOutputStream(communicator); Test.MyClassSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClass[][] arr2S = Test.MyClassSSHelper.read(@in); test(arr2S.Length == arrS.Length); test(arr2S[0].Length == arrS[0].Length); test(arr2S[1].Length == arrS[1].Length); test(arr2S[2].Length == arrS[2].Length); @out.destroy(); @in.destroy(); } { Test.MyInterface i = new MyInterfaceI(); @out = Ice.Util.createOutputStream(communicator); Test.MyInterfaceHelper.write(@out, i); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyInterfaceHelper helper = new Test.MyInterfaceHelper(@in); helper.read(); @in.readPendingObjects(); test(helper.value != null); } { @out = Ice.Util.createOutputStream(communicator); Test.MyClass obj = new Test.MyClass(); obj.s = new Test.SmallStruct(); obj.s.e = Test.MyEnum.enum2; TestObjectWriter writer = new TestObjectWriter(obj); @out.writeObject(writer); @out.writePendingObjects(); byte[] data = @out.finished(); test(writer.called); factoryWrapper.setFactory(new TestObjectFactory()); @in = Ice.Util.createInputStream(communicator, data); TestReadObjectCallback cb = new TestReadObjectCallback(); @in.readObject(cb); @in.readPendingObjects(); test(cb.obj != null); test(cb.obj is TestObjectReader); TestObjectReader reader = (TestObjectReader)cb.obj; test(reader.called); test(reader.obj != null); test(reader.obj.s.e == Test.MyEnum.enum2); @out.destroy(); @in.destroy(); factoryWrapper.setFactory(null); } { @out = Ice.Util.createOutputStream(communicator); Test.MyException ex = new Test.MyException(); Test.MyClass c = new Test.MyClass(); c.c = c; c.o = c; c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; c.seq1 = new bool[] { true, false, true, false }; c.seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }; c.seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 }; c.seq4 = new int[] { 1, 2, 3, 4 }; c.seq5 = new long[] { 1, 2, 3, 4 }; c.seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 }; c.seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 }; c.seq8 = new string[] { "string1", "string2", "string3", "string4" }; c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; c.seq10 = new Test.MyClass[4]; // null elements. c.d = new Dictionary<string, Test.MyClass>(); c.d.Add("hi", c); ex.c = c; @out.writeException(ex); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); try { @in.throwException(); test(false); } catch(Test.MyException ex1) { test(ex1.c.s.e == c.s.e); test(Compare(ex1.c.seq1, c.seq1)); test(Compare(ex1.c.seq2, c.seq2)); test(Compare(ex1.c.seq3, c.seq3)); test(Compare(ex1.c.seq4, c.seq4)); test(Compare(ex1.c.seq5, c.seq5)); test(Compare(ex1.c.seq6, c.seq6)); test(Compare(ex1.c.seq7, c.seq7)); test(Compare(ex1.c.seq8, c.seq8)); test(Compare(ex1.c.seq9, c.seq9)); } catch(Ice.UserException) { test(false); } } { Dictionary<byte, bool> dict = new Dictionary<byte, bool>(); dict.Add((byte)4, true); dict.Add((byte)1, false); @out = Ice.Util.createOutputStream(communicator); Test.ByteBoolDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<byte, bool> dict2 = Test.ByteBoolDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<short, int> dict = new Dictionary<short, int>(); dict.Add((short)1, 9); dict.Add((short)4, 8); @out = Ice.Util.createOutputStream(communicator); Test.ShortIntDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<short, int> dict2 = Test.ShortIntDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<long, float> dict = new Dictionary<long, float>(); dict.Add((long)123809828, (float)0.51f); dict.Add((long)123809829, (float)0.56f); @out = Ice.Util.createOutputStream(communicator); Test.LongFloatDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<long, float> dict2 = Test.LongFloatDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<string, string> dict = new Dictionary<string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); @out = Ice.Util.createOutputStream(communicator); Test.StringStringDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<string, string> dict2 = Test.StringStringDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<string, Test.MyClass> dict = new Dictionary<string, Test.MyClass>(); Test.MyClass c; c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; dict.Add("key1", c); c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum3; dict.Add("key2", c); @out = Ice.Util.createOutputStream(communicator); Test.StringMyClassDHelper.write(@out, dict); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<string, Test.MyClass> dict2 = Test.StringMyClassDHelper.read(@in); @in.readPendingObjects(); test(dict2.Count == dict.Count); test(dict2["key1"].s.e == Test.MyEnum.enum2); test(dict2["key2"].s.e == Test.MyEnum.enum3); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); List<bool> l = new List<bool>(arr); Test.BoolListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<bool> l2 = Test.BoolListHelper.read(@in); test(Compare(l, l2)); @out.destroy(); @in.destroy(); } { byte[] arr = { (byte)0x01, (byte)0x11, (byte)0x12, (byte)0x22 }; @out = Ice.Util.createOutputStream(communicator); List<byte> l = new List<byte>(arr); Test.ByteListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<byte> l2 = Test.ByteListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); List<Test.MyEnum> l = new List<Test.MyEnum>(arr); Test.MyEnumListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyEnum> l2 = Test.MyEnumListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); List<Test.SmallStruct> l = new List<Test.SmallStruct>(smallStructArray); Test.SmallStructListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.SmallStruct> l2 = Test.SmallStructListHelper.read(@in); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i].Equals(smallStructArray[i])); } @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); List<Test.MyClass> l = new List<Test.MyClass>(myClassArray); Test.MyClassListHelper.write(@out, l); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyClass> l2 = Test.MyClassListHelper.read(@in); @in.readPendingObjects(); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } @out.destroy(); @in.destroy(); } { Test.MyClassPrx[] arr = new Test.MyClassPrx[2]; arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero")); arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one")); @out = Ice.Util.createOutputStream(communicator); List<Test.MyClassPrx> l = new List<Test.MyClassPrx>(arr); Test.MyClassProxyListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyClassPrx> l2 = Test.MyClassProxyListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { short[] arr = { (short)0x01, (short)0x11, (short)0x12, (short)0x22 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<short> l = new LinkedList<short>(arr); Test.ShortLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<short> l2 = Test.ShortLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<int> l = new LinkedList<int>(arr); Test.IntLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<int> l2 = Test.IntLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<Test.MyEnum> l = new LinkedList<Test.MyEnum>(arr); Test.MyEnumLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); LinkedList<Test.SmallStruct> l = new LinkedList<Test.SmallStruct>(smallStructArray); Test.SmallStructLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<Test.SmallStruct> l2 = Test.SmallStructLinkedListHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Stack<long> l = new Stack<long>(arr); Test.LongStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<long> l2 = Test.LongStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { float[] arr = { (float)1, (float)2, (float)3, (float)4 }; @out = Ice.Util.createOutputStream(communicator); Stack<float> l = new Stack<float>(arr); Test.FloatStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<float> l2 = Test.FloatStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Stack<Test.SmallStruct> l = new Stack<Test.SmallStruct>(smallStructArray); Test.SmallStructStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<Test.SmallStruct> l2 = Test.SmallStructStackHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { Test.MyClassPrx[] arr = new Test.MyClassPrx[2]; arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero")); arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one")); @out = Ice.Util.createOutputStream(communicator); Stack<Test.MyClassPrx> l = new Stack<Test.MyClassPrx>(arr); Test.MyClassProxyStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<Test.MyClassPrx> l2 = Test.MyClassProxyStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { double[] arr = { (double)1, (double)2, (double)3, (double)4 }; @out = Ice.Util.createOutputStream(communicator); Queue<double> l = new Queue<double>(arr); Test.DoubleQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<double> l2 = Test.DoubleQueueHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Queue<string> l = new Queue<string>(arr); Test.StringQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<string> l2 = Test.StringQueueHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Queue<Test.SmallStruct> l = new Queue<Test.SmallStruct>(smallStructArray); Test.SmallStructQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<Test.SmallStruct> l2 = Test.SmallStructQueueHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); Test.BoolCollection l = new Test.BoolCollection(arr); Test.BoolCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.BoolCollection l2 = Test.BoolCollectionHelper.read(@in); test(Compare(l, l2)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Test.IntCollection l = new Test.IntCollection(arr); Test.IntCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.IntCollection l2 = Test.IntCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Test.StringCollection l = new Test.StringCollection(arr); Test.StringCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.StringCollection l2 = Test.StringCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumCollection l = new Test.MyEnumCollection(arr); Test.MyEnumCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnumCollection l2 = Test.MyEnumCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.SmallStructCollection l = new Test.SmallStructCollection(smallStructArray); Test.SmallStructCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.SmallStructCollection l2 = Test.SmallStructCollectionHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.MyClassCollection l = new Test.MyClassCollection(myClassArray); Test.MyClassCollectionHelper.write(@out, l); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClassCollection l2 = Test.MyClassCollectionHelper.read(@in); @in.readPendingObjects(); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); List<string[]> l = new List<string[]>(arrS); Test.StringSListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<string[]> l2 = Test.StringSListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); Stack<string[]> l = new Stack<string[]>(arrS); Test.StringSStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<string[]> l2 = Test.StringSStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { #if COMPACT SortedList<string, string> dict = new SortedList<string, string>(); #else SortedDictionary<string, string> dict = new SortedDictionary<string, string>(); #endif dict.Add("key1", "value1"); dict.Add("key2", "value2"); @out = Ice.Util.createOutputStream(communicator); Test.SortedStringStringDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); IDictionary<string, string> dict2 = Test.SortedStringStringDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Test.StringIntDCollection dict = new Test.StringIntDCollection(); dict.Add("key1", 1); dict.Add("key2", 2); @out = Ice.Util.createOutputStream(communicator); Test.StringIntDCollectionHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.StringIntDCollection dict2 = Test.StringIntDCollectionHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } Console.WriteLine("ok"); return 0; }