Esempio n. 1
0
    static bool CheckSmallStruct()
    {
        var v = new SmallStruct[4, 4, 4];
        var e = new SmallStruct(33f);

        v[1, 2, 3] = e;
        return(UseArrayElementAsCallArgument(v, e));
    }
Esempio n. 2
0
 public void Setup()
 {
     structs = new SmallStruct[items];
     classes = new SmallClass[items];
     for (int i = 0; i < items; i++)
     {
         structs[i] = new SmallStruct {
             Value1 = i
         };
         classes[i] = new SmallClass {
             Value1 = i
         };
     }
 }
Esempio n. 3
0
 public SmallStruct echoSmallStruct(/*[in]*/ SmallStruct arg)
 {
     return(arg);
 }
Esempio n. 4
0
        public static void Run()
        {
            var o = new TestDelegateFatFunctionPointers();

            string hw        = "Hello World";
            string roundtrip = o.Generic <string>(hw);

            if (roundtrip != hw)
            {
                throw new Exception();
            }

            {
                VoidGenericDelegate <object> f = o.VoidGeneric;
                object obj      = new object();
                object location = null;
                f(ref location, obj);
                if (location != obj)
                {
                    throw new Exception();
                }
            }

            {
                Func <SmallStruct, SmallStruct> f = o.SmallStructGeneric <object>;
                SmallStruct x = new SmallStruct {
                    X = 12345
                };
                SmallStruct result = f(x);
                if (result.X != x.X)
                {
                    throw new Exception();
                }
            }

            {
                Func <MediumStruct, MediumStruct> f = o.MediumStructGeneric <object>;
                MediumStruct x = new MediumStruct {
                    X = 12, Y = 34, Z = 56, W = 78
                };
                MediumStruct result = f(x);
                if (result.X != x.X || result.Y != x.Y || result.Z != x.Z || result.W != x.W)
                {
                    throw new Exception();
                }
            }

            unsafe
            {
                Func <BigStruct, BigStruct> f = o.BigStructGeneric <object>;
                BigStruct x = new BigStruct();
                for (int i = 0; i < BigStruct.Length; i++)
                {
                    x.Bytes[i] = (byte)(i * 2);
                }

                BigStruct result = f(x);

                for (int i = 0; i < BigStruct.Length; i++)
                {
                    if (x.Bytes[i] != result.Bytes[i])
                    {
                        throw new Exception();
                    }
                }
            }
        }
Esempio n. 5
0
 SmallStruct SmallStructGeneric <T>(SmallStruct x)
 {
     return(x);
 }
Esempio n. 6
0
        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);
        }
Esempio n. 7
0
    static public int run(Ice.Communicator communicator)
    {
        MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();

        communicator.getValueFactoryManager().add(factoryWrapper.create, MyClass.ice_staticId());

        Ice.InputStream  inS;
        Ice.OutputStream outS;

        Write("testing primitive types... ");
        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"));
        }

        WriteLine("ok");

        Write("testing constructed types... ");
        Flush();

        {
            outS = new Ice.OutputStream(communicator);
            MyEnumHelper.write(outS, MyEnum.enum3);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var e = MyEnumHelper.read(inS);
            test(e == MyEnum.enum3);
        }

        {
            outS = new Ice.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   = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
            SmallStruct.write(outS, s);
            var data = outS.finished();
            var s2   = SmallStruct.read(new Ice.InputStream(communicator, data));
            test(s2.Equals(s));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var o = new 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 = (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 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 = (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);
            BoolSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            ByteSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            ShortSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            IntSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            LongSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            FloatSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = FloatSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        {
            double[] arr =
            {
                (double)1,
                (double)2,
                (double)3,
                (double)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);
            DoubleSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            StringSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = StringSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 };
            outS = new Ice.OutputStream(communicator);
            MyEnumSHelper.write(outS, arr);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2 = MyEnumSHelper.read(inS);
            test(Compare(arr2, arr));

            MyEnum[][] arrS = { arr, new MyEnum[0], arr };
            outS = new Ice.OutputStream(communicator);
            MyEnumSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = MyEnumSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        var smallStructArray = new SmallStruct[3];

        for (int i = 0; i < smallStructArray.Length; ++i)
        {
            smallStructArray[i]     = new 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   = MyEnum.enum2;
            smallStructArray[i].p   = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
        }

        var myClassArray = new MyClass[4];

        for (int i = 0; i < myClassArray.Length; ++i)
        {
            myClassArray[i]         = new MyClass();
            myClassArray[i].c       = myClassArray[i];
            myClassArray[i].o       = myClassArray[i];
            myClassArray[i].s       = new SmallStruct();
            myClassArray[i].s.e     = 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 MyEnum[] { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1 };
            myClassArray[i].seq10   = new MyClass[4]; // null elements.
            myClassArray[i].d       = new Dictionary <string, Test.MyClass>();
            myClassArray[i].d["hi"] = myClassArray[i];
        }

        {
            outS = new Ice.OutputStream(communicator);
            MyClassSHelper.write(outS, myClassArray);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2 = 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 == 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]));
            }

            MyClass[][] arrS = { myClassArray, new MyClass[0], myClassArray };
            outS = new Ice.OutputStream(communicator);
            MyClassSSHelper.write(outS, arrS);
            data = outS.finished();
            inS  = new Ice.InputStream(communicator, data);
            var arr2S = MyClassSSHelper.read(inS);
            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);
        }

        {
            outS = new Ice.OutputStream(communicator);
            var obj = new MyClass();
            obj.s   = new SmallStruct();
            obj.s.e = MyEnum.enum2;
            var writer = new TestValueWriter(obj);
            outS.writeValue(writer);
            outS.writePendingValues();
            var data = outS.finished();
            test(writer.called);
            factoryWrapper.setFactory(TestObjectFactory);
            inS = new Ice.InputStream(communicator, data);
            var cb = new TestReadValueCallback();
            inS.readValue(cb.invoke);
            inS.readPendingValues();
            test(cb.obj != null);
            test(cb.obj is TestValueReader);
            var reader = (TestValueReader)cb.obj;
            test(reader.called);
            test(reader.obj != null);
            test(reader.obj.s.e == MyEnum.enum2);
            factoryWrapper.setFactory(null);
        }

        {
            outS = new Ice.OutputStream(communicator);
            var ex = new MyException();

            var c = new MyClass();
            c.c     = c;
            c.o     = c;
            c.s     = new SmallStruct();
            c.s.e   = 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 MyEnum[] { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1 };
            c.seq10 = new MyClass[4]; // null elements.
            c.d     = new Dictionary <string, 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 (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);
            ByteBoolDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            ShortIntDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            LongFloatDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            StringStringDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = StringStringDHelper.read(inS);
            test(Ice.CollectionComparer.Equals(dict2, dict));
        }

        {
            var dict = new Dictionary <string, MyClass>();
            var c    = new MyClass();
            c.s   = new SmallStruct();
            c.s.e = MyEnum.enum2;
            dict.Add("key1", c);
            c     = new MyClass();
            c.s   = new SmallStruct();
            c.s.e = MyEnum.enum3;
            dict.Add("key2", c);
            outS = new Ice.OutputStream(communicator);
            StringMyClassDHelper.write(outS, dict);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = StringMyClassDHelper.read(inS);
            inS.readPendingValues();
            test(dict2.Count == dict.Count);
            test(dict2["key1"].s.e == MyEnum.enum2);
            test(dict2["key2"].s.e == MyEnum.enum3);
        }

        {
            bool[] arr = { true, false, true, false };
            outS = new Ice.OutputStream(communicator);
            var l = new List <bool>(arr);
            BoolListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = BoolListHelper.read(inS);
            test(Compare(l, l2));
        }

        {
            byte[] arr = { 0x01, 0x11, 0x12, 0x22 };
            outS = new Ice.OutputStream(communicator);
            var l = new List <byte>(arr);
            ByteListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = ByteListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 };
            outS = new Ice.OutputStream(communicator);
            var l = new List <MyEnum>(arr);
            MyEnumListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyEnumListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new List <SmallStruct>(smallStructArray);
            SmallStructListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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 <MyClass>(myClassArray);
            MyClassListHelper.write(outS, l);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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 == 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 MyClassPrx[2];
            arr[0] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
            arr[1] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
            outS   = new Ice.OutputStream(communicator);
            var l = new List <MyClassPrx>(arr);
            MyClassProxyListHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyClassProxyListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            short[] arr = { 0x01, 0x11, 0x12, 0x22 };
            outS = new Ice.OutputStream(communicator);
            var l = new LinkedList <short>(arr);
            ShortLinkedListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, 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);
            SmallStructLinkedListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            LongStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = LongStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            float[] arr = { 1, 2, 3, 4 };
            outS = new Ice.OutputStream(communicator);
            var l = new Stack <float>(arr);
            FloatStackHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = FloatStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new Stack <SmallStruct>(smallStructArray);
            SmallStructStackHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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 MyClassPrx[2];
            arr[0] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
            arr[1] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
            outS   = new Ice.OutputStream(communicator);
            var l = new Stack <MyClassPrx>(arr);
            MyClassProxyStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyClassProxyStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            double[] arr = { 1, 2, 3, 4 };
            outS = new Ice.OutputStream(communicator);
            var l = new Queue <double>(arr);
            DoubleQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = DoubleQueueHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            string[] arr = { "string1", "string2", "string3", "string4" };
            outS = new Ice.OutputStream(communicator);
            var l = new Queue <string>(arr);
            StringQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = StringQueueHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new Queue <SmallStruct>(smallStructArray);
            SmallStructQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            StringSListHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            StringSStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            SortedStringStringDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = SortedStringStringDHelper.read(inS);
            test(Ice.CollectionComparer.Equals(dict2, dict));
        }

        WriteLine("ok");
        return(0);
    }
Esempio n. 8
0
 public SmallStruct echoSmallStruct(/*[in]*/SmallStruct arg)
 {
     return arg;
 }
Esempio n. 9
0
    public static int run(Ice.Communicator communicator)
    {
        MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();

        communicator.getValueFactoryManager().add(factoryWrapper.create, MyClass.ice_staticId());

        Ice.InputStream inS;
        Ice.OutputStream outS;

        Write("testing primitive types... ");
        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"));
        }

        WriteLine("ok");

        Write("testing constructed types... ");
        Flush();

        {
            outS = new Ice.OutputStream(communicator);
            MyEnumHelper.write(outS, MyEnum.enum3);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var e = MyEnumHelper.read(inS);
            test(e == MyEnum.enum3);
        }

        {
            outS = new Ice.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 = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
            SmallStruct.write(outS, s);
            var data = outS.finished();
            var s2 = SmallStruct.read(new Ice.InputStream(communicator, data));
            test(s2.Equals(s));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var o = new 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 = (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 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 = (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);
            BoolSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            ByteSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            ShortSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            IntSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            LongSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            FloatSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = FloatSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        {
            double[] arr =
            {
                (double)1,
                (double)2,
                (double)3,
                (double)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);
            DoubleSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = 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);
            StringSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = StringSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 };
            outS = new Ice.OutputStream(communicator);
            MyEnumSHelper.write(outS, arr);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2 = MyEnumSHelper.read(inS);
            test(Compare(arr2, arr));

            MyEnum[][] arrS = { arr, new MyEnum[0], arr };
            outS = new Ice.OutputStream(communicator);
            MyEnumSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = MyEnumSSHelper.read(inS);
            test(Compare(arr2S, arrS));
        }

        var smallStructArray = new SmallStruct[3];
        for (int i = 0; i < smallStructArray.Length; ++i)
        {
            smallStructArray[i] = new 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 = MyEnum.enum2;
            smallStructArray[i].p = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
        }

        var myClassArray = new MyClass[4];
        for (int i = 0; i < myClassArray.Length; ++i)
        {
            myClassArray[i] = new MyClass();
            myClassArray[i].c = myClassArray[i];
            myClassArray[i].o = myClassArray[i];
            myClassArray[i].s = new SmallStruct();
            myClassArray[i].s.e = 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 MyEnum[] { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1 };
            myClassArray[i].seq10 = new MyClass[4]; // null elements.
            myClassArray[i].d = new Dictionary<string, Test.MyClass>();
            myClassArray[i].d["hi"] = myClassArray[i];
        }

        {
            outS = new Ice.OutputStream(communicator);
            MyClassSHelper.write(outS, myClassArray);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2 = 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 == 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]));
            }

            MyClass[][] arrS = { myClassArray, new MyClass[0], myClassArray };
            outS = new Ice.OutputStream(communicator);
            MyClassSSHelper.write(outS, arrS);
            data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var arr2S = MyClassSSHelper.read(inS);
            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);
        }

        {
            outS = new Ice.OutputStream(communicator);
            var obj = new MyClass();
            obj.s = new SmallStruct();
            obj.s.e = MyEnum.enum2;
            var writer = new TestValueWriter(obj);
            outS.writeValue(writer);
            outS.writePendingValues();
            var data = outS.finished();
            test(writer.called);
            factoryWrapper.setFactory(TestObjectFactory);
            inS = new Ice.InputStream(communicator, data);
            var cb = new TestReadValueCallback();
            inS.readValue(cb.invoke);
            inS.readPendingValues();
            test(cb.obj != null);
            test(cb.obj is TestValueReader);
            var reader = (TestValueReader)cb.obj;
            test(reader.called);
            test(reader.obj != null);
            test(reader.obj.s.e == MyEnum.enum2);
            factoryWrapper.setFactory(null);
        }

        {
            outS = new Ice.OutputStream(communicator);
            var ex = new MyException();

            var c = new MyClass();
            c.c = c;
            c.o = c;
            c.s = new SmallStruct();
            c.s.e = 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 MyEnum[] { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1 };
            c.seq10 = new MyClass[4]; // null elements.
            c.d = new Dictionary<string, 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 (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);
            ByteBoolDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            ShortIntDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            LongFloatDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = 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);
            StringStringDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = StringStringDHelper.read(inS);
            test(Ice.CollectionComparer.Equals(dict2, dict));
        }

        {
            var dict = new Dictionary<string, MyClass>();
            var c = new MyClass();
            c.s = new SmallStruct();
            c.s.e = MyEnum.enum2;
            dict.Add("key1", c);
            c = new MyClass();
            c.s = new SmallStruct();
            c.s.e = MyEnum.enum3;
            dict.Add("key2", c);
            outS = new Ice.OutputStream(communicator);
            StringMyClassDHelper.write(outS, dict);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = StringMyClassDHelper.read(inS);
            inS.readPendingValues();
            test(dict2.Count == dict.Count);
            test(dict2["key1"].s.e == MyEnum.enum2);
            test(dict2["key2"].s.e == MyEnum.enum3);
        }

        {
            bool[] arr = { true, false, true, false };
            outS = new Ice.OutputStream(communicator);
            var l = new List<bool>(arr);
            BoolListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = BoolListHelper.read(inS);
            test(Compare(l, l2));
        }

        {
            byte[] arr = { 0x01, 0x11, 0x12, 0x22 };
            outS = new Ice.OutputStream(communicator);
            var l = new List<byte>(arr);
            ByteListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = ByteListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, MyEnum.enum2 };
            outS = new Ice.OutputStream(communicator);
            var l = new List<MyEnum>(arr);
            MyEnumListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyEnumListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new List<SmallStruct>(smallStructArray);
            SmallStructListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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<MyClass>(myClassArray);
            MyClassListHelper.write(outS, l);
            outS.writePendingValues();
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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 == 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 MyClassPrx[2];
            arr[0] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
            arr[1] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
            outS = new Ice.OutputStream(communicator);
            var l = new List<MyClassPrx>(arr);
            MyClassProxyListHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyClassProxyListHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            short[] arr = { 0x01, 0x11, 0x12, 0x22 };
            outS = new Ice.OutputStream(communicator);
            var l = new LinkedList<short>(arr);
            ShortLinkedListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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));
        }

        {
            MyEnum[] arr = { MyEnum.enum3, MyEnum.enum2, MyEnum.enum1, 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);
            SmallStructLinkedListHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            LongStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = LongStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            float[] arr = { 1, 2, 3, 4 };
            outS = new Ice.OutputStream(communicator);
            var l = new Stack<float>(arr);
            FloatStackHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = FloatStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new Stack<SmallStruct>(smallStructArray);
            SmallStructStackHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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 MyClassPrx[2];
            arr[0] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
            arr[1] = MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
            outS = new Ice.OutputStream(communicator);
            var l = new Stack<MyClassPrx>(arr);
            MyClassProxyStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = MyClassProxyStackHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            double[] arr = { 1, 2, 3, 4 };
            outS = new Ice.OutputStream(communicator);
            var l = new Queue<double>(arr);
            DoubleQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = DoubleQueueHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            string[] arr = { "string1", "string2", "string3", "string4" };
            outS = new Ice.OutputStream(communicator);
            var l = new Queue<string>(arr);
            StringQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = StringQueueHelper.read(inS);
            test(Compare(l2, l));
        }

        {
            outS = new Ice.OutputStream(communicator);
            var l = new Queue<SmallStruct>(smallStructArray);
            SmallStructQueueHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            StringSListHelper.write(outS, l);
            byte[] data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            StringSStackHelper.write(outS, l);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var l2 = 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);
            SortedStringStringDHelper.write(outS, dict);
            var data = outS.finished();
            inS = new Ice.InputStream(communicator, data);
            var dict2 = SortedStringStringDHelper.read(inS);
            test(Ice.CollectionComparer.Equals(dict2, dict));
        }

        WriteLine("ok");
        return 0;
    }
 int GetForceInlining(ref SmallStruct @class)
 {
     return @class.Val;
 }
 int Get(ref SmallStruct @class)
 {
     return @class.Val;
 }