internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p)
{
{
byte[] i = new byte[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (byte)c;
}
byte[] o;
byte[] r;
r = p.opAByteS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <byte> i = new List <byte>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((byte)c);
}
List <byte> o;
List <byte> r;
r = p.opLByteS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <byte> i = new LinkedList <byte>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((byte)c);
}
LinkedList <byte> o;
LinkedList <byte> r;
r = p.opKByteS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <byte> i = new Queue <byte>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((byte)c);
}
Queue <byte> o;
Queue <byte> r;
r = p.opQByteS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <byte> i = new Stack <byte>();
for (int c = 0; c < _length; ++c)
{
i.Push((byte)c);
}
Stack <byte> o;
Stack <byte> r;
r = p.opSByteS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
bool[] i = new bool[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = c % 1 == 1;
}
bool[] o;
bool[] r;
r = p.opABoolS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <bool> i = new List <bool>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(c % 1 == 1);
}
List <bool> o;
List <bool> r;
r = p.opLBoolS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <bool> i = new LinkedList <bool>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(c % 1 == 1);
}
LinkedList <bool> o;
LinkedList <bool> r;
r = p.opKBoolS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <bool> i = new Queue <bool>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(c % 1 == 1);
}
Queue <bool> o;
Queue <bool> r;
r = p.opQBoolS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <bool> i = new Stack <bool>();
for (int c = 0; c < _length; ++c)
{
i.Push(c % 1 == 1);
}
Stack <bool> o;
Stack <bool> r;
r = p.opSBoolS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
short[] i = new short[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (short)c;
}
short[] o;
short[] r;
{
r = p.opAShortS(i, out o);
}
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <short> i = new List <short>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((short)c);
}
List <short> o;
List <short> r;
r = p.opLShortS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <short> i = new LinkedList <short>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((short)c);
}
LinkedList <short> o;
LinkedList <short> r;
r = p.opKShortS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <short> i = new Queue <short>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((short)c);
}
Queue <short> o;
Queue <short> r;
r = p.opQShortS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <short> i = new Stack <short>();
for (int c = 0; c < _length; ++c)
{
i.Push((short)c);
}
Stack <short> o;
Stack <short> r;
r = p.opSShortS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
int[] i = new int[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (int)c;
}
int[] o;
int[] r;
r = p.opAIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <int> i = new List <int>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((int)c);
}
List <int> o;
List <int> r;
r = p.opLIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <int> i = new LinkedList <int>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((int)c);
}
LinkedList <int> o;
LinkedList <int> r;
r = p.opKIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <int> i = new Queue <int>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((int)c);
}
Queue <int> o;
Queue <int> r;
r = p.opQIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <int> i = new Stack <int>();
for (int c = 0; c < _length; ++c)
{
i.Push((int)c);
}
Stack <int> o;
Stack <int> r;
r = p.opSIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
long[] i = new long[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (long)c;
}
long[] o;
long[] r;
r = p.opALongS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <long> i = new List <long>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((long)c);
}
List <long> o;
List <long> r;
r = p.opLLongS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <long> i = new LinkedList <long>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((long)c);
}
LinkedList <long> o;
LinkedList <long> r;
r = p.opKLongS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <long> i = new Queue <long>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((long)c);
}
Queue <long> o;
Queue <long> r;
r = p.opQLongS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <long> i = new Stack <long>();
for (int c = 0; c < _length; ++c)
{
i.Push((long)c);
}
Stack <long> o;
Stack <long> r;
r = p.opSLongS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
float[] i = new float[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (float)c;
}
float[] o;
float[] r;
r = p.opAFloatS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <float> i = new List <float>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((float)c);
}
List <float> o;
List <float> r;
r = p.opLFloatS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <float> i = new LinkedList <float>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((float)c);
}
LinkedList <float> o;
LinkedList <float> r;
r = p.opKFloatS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <float> i = new Queue <float>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((float)c);
}
Queue <float> o;
Queue <float> r;
r = p.opQFloatS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <float> i = new Stack <float>();
for (int c = 0; c < _length; ++c)
{
i.Push((float)c);
}
Stack <float> o;
Stack <float> r;
r = p.opSFloatS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
double[] i = new double[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (double)c;
}
double[] o;
double[] r;
r = p.opADoubleS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <double> i = new List <double>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((double)c);
}
List <double> o;
List <double> r;
r = p.opLDoubleS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <double> i = new LinkedList <double>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((double)c);
}
LinkedList <double> o;
LinkedList <double> r;
r = p.opKDoubleS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <double> i = new Queue <double>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((double)c);
}
Queue <double> o;
Queue <double> r;
r = p.opQDoubleS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <double> i = new Stack <double>();
for (int c = 0; c < _length; ++c)
{
i.Push((double)c);
}
Stack <double> o;
Stack <double> r;
r = p.opSDoubleS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
string[] i = new string[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = c.ToString();
}
string[] o;
string[] r;
r = p.opAStringS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <string> i = new List <string>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(c.ToString());
}
List <string> o;
List <string> r;
r = p.opLStringS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <string> i = new LinkedList <string>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(c.ToString());
}
LinkedList <string> o;
LinkedList <string> r;
r = p.opKStringS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <string> i = new Queue <string>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(c.ToString());
}
Queue <string> o;
Queue <string> r;
r = p.opQStringS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <string> i = new Stack <string>();
for (int c = 0; c < _length; ++c)
{
i.Push(c.ToString());
}
Stack <string> o;
Stack <string> r;
r = p.opSStringS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Ice.Value[] i = new CV[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new CV(c);
}
Ice.Value[] o;
Ice.Value[] r;
r = p.opAObjectS(i, out o);
System.Collections.IEnumerator eo = o.GetEnumerator();
System.Collections.IEnumerator er = r.GetEnumerator();
foreach (CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((CV)eo.Current).i);
test(obj.i == ((CV)er.Current).i);
}
}
{
var i = new List <Ice.Value>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new CV(c));
}
List <Ice.Value> o;
List <Ice.Value> r;
r = p.opLObjectS(i, out o);
var eo = o.GetEnumerator();
var er = r.GetEnumerator();
foreach (CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((CV)eo.Current).i);
test(obj.i == ((CV)er.Current).i);
}
}
{
Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = communicator.stringToProxy(c.ToString());
}
Ice.ObjectPrx[] o;
Ice.ObjectPrx[] r;
r = p.opAObjectPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <Ice.ObjectPrx> i = new List <Ice.ObjectPrx>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(communicator.stringToProxy(c.ToString()));
}
List <Ice.ObjectPrx> o;
List <Ice.ObjectPrx> r;
r = p.opLObjectPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <Ice.ObjectPrx> i = new LinkedList <Ice.ObjectPrx>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(communicator.stringToProxy(c.ToString()));
}
LinkedList <Ice.ObjectPrx> o;
LinkedList <Ice.ObjectPrx> r;
r = p.opKObjectPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <Ice.ObjectPrx> i = new Queue <Ice.ObjectPrx>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(communicator.stringToProxy(c.ToString()));
}
Queue <Ice.ObjectPrx> o;
Queue <Ice.ObjectPrx> r;
r = p.opQObjectPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <Ice.ObjectPrx> i = new Stack <Ice.ObjectPrx>();
for (int c = 0; c < _length; ++c)
{
i.Push(communicator.stringToProxy(c.ToString()));
}
Stack <Ice.ObjectPrx> o;
Stack <Ice.ObjectPrx> r;
r = p.opSObjectPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
S[] i = new S[_length];
for (int c = 0; c < _length; ++c)
{
i[c].i = c;
}
S[] o;
S[] r;
r = p.opAStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <S> i = new List <S>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new S(c));
}
List <S> o;
List <S> r;
r = p.opLStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <S> i = new LinkedList <S>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(new S(c));
}
LinkedList <S> o;
LinkedList <S> r;
r = p.opKStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <S> i = new Queue <S>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(new S(c));
}
Queue <S> o;
Queue <S> r;
r = p.opQStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <S> i = new Stack <S>();
for (int c = 0; c < _length; ++c)
{
i.Push(new S(c));
}
Stack <S> o;
Stack <S> r;
r = p.opSStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
SD[] i = new SD[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new SD(c);
}
SD[] o;
SD[] r;
r = p.opAStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <SD> i = new List <SD>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new SD(c));
}
List <SD> o;
List <SD> r;
r = p.opLStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <SD> i = new LinkedList <SD>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(new SD(c));
}
LinkedList <SD> o;
LinkedList <SD> r;
r = p.opKStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <SD> i = new Queue <SD>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(new SD(c));
}
Queue <SD> o;
Queue <SD> r;
r = p.opQStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <SD> i = new Stack <SD>();
for (int c = 0; c < _length; ++c)
{
i.Push(new SD(c));
}
Stack <SD> o;
Stack <SD> r;
r = p.opSStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
CV[] i = new CV[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new CV(c);
}
CV[] o;
CV[] r;
r = p.opACVS(i, out o);
System.Collections.IEnumerator eo = o.GetEnumerator();
System.Collections.IEnumerator er = r.GetEnumerator();
foreach (CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((CV)eo.Current).i);
test(obj.i == ((CV)er.Current).i);
}
}
{
List <CV> i = new List <CV>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new CV(c));
}
List <CV> o;
List <CV> r;
r = p.opLCVS(i, out o);
IEnumerator <CV> eo = o.GetEnumerator();
IEnumerator <CV> er = r.GetEnumerator();
foreach (CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == eo.Current.i);
test(obj.i == er.Current.i);
}
}
{
CR[] i = new CR[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new CR(new CV(c));
}
CR[] o;
CR[] r;
r = p.opACRS(i, out o);
System.Collections.IEnumerator eo = o.GetEnumerator();
System.Collections.IEnumerator er = r.GetEnumerator();
foreach (CR obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.v.i == ((CR)eo.Current).v.i);
test(obj.v.i == ((CR)er.Current).v.i);
}
}
{
List <CR> i = new List <CR>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new CR(new CV(c)));
}
List <CR> o;
List <CR> r;
r = p.opLCRS(i, out o);
IEnumerator <CR> eo = o.GetEnumerator();
IEnumerator <CR> er = r.GetEnumerator();
foreach (CR obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.v.i == eo.Current.v.i);
test(obj.v.i == er.Current.v.i);
}
}
{
En[] i = new En[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (En)(c % 3);
}
En[] o;
En[] r;
r = p.opAEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <En> i = new List <En>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((En)(c % 3));
}
List <En> o;
List <En> r;
r = p.opLEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <En> i = new LinkedList <En>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((En)(c % 3));
}
LinkedList <En> o;
LinkedList <En> r;
r = p.opKEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <En> i = new Queue <En>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((En)(c % 3));
}
Queue <En> o;
Queue <En> r;
r = p.opQEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <En> i = new Stack <En>();
for (int c = 0; c < _length; ++c)
{
i.Push((En)(c % 3));
}
Stack <En> o;
Stack <En> r;
r = p.opSEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
CVPrx[] i = new CVPrx[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()));
}
CVPrx[] o;
CVPrx[] r;
r = p.opACVPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <CVPrx> i = new List <CVPrx>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
List <CVPrx> o;
List <CVPrx> r;
r = p.opLCVPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <CVPrx> i = new LinkedList <CVPrx>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
LinkedList <CVPrx> o;
LinkedList <CVPrx> r;
r = p.opKCVPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <CVPrx> i = new Queue <CVPrx>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
Queue <CVPrx> o;
Queue <CVPrx> r;
r = p.opQCVPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <CVPrx> i = new Stack <CVPrx>();
for (int c = 0; c < _length; ++c)
{
i.Push(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
Stack <CVPrx> o;
Stack <CVPrx> r;
r = p.opSCVPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Custom <int> i = new Custom <int>();
for (int c = 0; c < _length; ++c)
{
i.Add(c);
}
Custom <int> o;
Custom <int> r;
r = p.opCustomIntS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Custom <CV> i = new Custom <CV>();
for (int c = 0; c < _length; ++c)
{
i.Add(new CV(c));
}
i.Add(null);
Custom <CV> o;
Custom <CV> r;
r = p.opCustomCVS(i, out o);
IEnumerator <CV> eo = (IEnumerator <CV>)o.GetEnumerator();
IEnumerator <CV> er = (IEnumerator <CV>)r.GetEnumerator();
foreach (CV obj in i)
{
eo.MoveNext();
er.MoveNext();
if (obj == null)
{
test(eo.Current == null);
test(er.Current == null);
}
else
{
test(obj.i == eo.Current.i);
test(obj.i == er.Current.i);
}
}
}
{
Custom <Custom <int> > i = new Custom <Custom <int> >();
for (int c = 0; c < _length; ++c)
{
Custom <int> inner = new Custom <int>();
for (int j = 0; j < c; ++j)
{
inner.Add(j);
}
i.Add(inner);
}
Custom <Custom <int> > o;
Custom <Custom <int> > r;
r = p.opCustomIntSS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Custom <Custom <CV> > i = new Custom <Custom <CV> >();
for (int c = 0; c < _length; ++c)
{
Custom <CV> inner = new Custom <CV>();
for (int j = 0; j < c; ++j)
{
inner.Add(new CV(j));
}
i.Add(inner);
}
Custom <Custom <CV> > o;
Custom <Custom <CV> > r;
r = p.opCustomCVSS(i, out o);
IEnumerator <Custom <CV> > eo = (IEnumerator <Custom <CV> >)o.GetEnumerator();
IEnumerator <Custom <CV> > er = (IEnumerator <Custom <CV> >)r.GetEnumerator();
foreach (Custom <CV> s in i)
{
eo.MoveNext();
er.MoveNext();
IEnumerator <CV> io = (IEnumerator <CV>)eo.Current.GetEnumerator();
IEnumerator <CV> ir = (IEnumerator <CV>)er.Current.GetEnumerator();
foreach (CV obj in s)
{
io.MoveNext();
ir.MoveNext();
if (obj == null)
{
test(io.Current == null);
test(ir.Current == null);
}
else
{
test(obj.i == io.Current.i);
test(obj.i == ir.Current.i);
}
}
}
}
{
Serialize.Small i = null;
Serialize.Small o;
Serialize.Small r;
r = p.opSerialSmallCSharp(i, out o);
test(o == null);
test(r == null);
}
{
Serialize.Small i = new Serialize.Small();
i.i = 99;
Serialize.Small o;
Serialize.Small r;
try
{
r = p.opSerialSmallCSharp(i, out o);
test(o.i == 99);
test(r.i == 99);
}
catch (Ice.OperationNotExistException)
{
// OK, talking to non-C# server.
}
}
{
Serialize.Large i = new Serialize.Large();
i.d1 = 1.0;
i.d2 = 2.0;
i.d3 = 3.0;
i.d4 = 4.0;
i.d5 = 5.0;
i.d6 = 6.0;
i.d7 = 7.0;
i.d8 = 8.0;
i.d9 = 9.0;
i.d10 = 10.0;
Serialize.Large o;
Serialize.Large r;
try
{
r = p.opSerialLargeCSharp(i, out o);
test(o.d1 == 1.0);
test(o.d2 == 2.0);
test(o.d3 == 3.0);
test(o.d4 == 4.0);
test(o.d5 == 5.0);
test(o.d6 == 6.0);
test(o.d7 == 7.0);
test(o.d8 == 8.0);
test(o.d9 == 9.0);
test(o.d10 == 10.0);
test(r.d1 == 1.0);
test(r.d2 == 2.0);
test(r.d3 == 3.0);
test(r.d4 == 4.0);
test(r.d5 == 5.0);
test(r.d6 == 6.0);
test(r.d7 == 7.0);
test(r.d8 == 8.0);
test(r.d9 == 9.0);
test(r.d10 == 10.0);
}
catch (Ice.OperationNotExistException)
{
// OK, talking to non-C# server.
}
}
{
Serialize.Struct i = new Serialize.Struct();
i.o = null;
i.o2 = i;
i.s = null;
i.s2 = "Hello";
Serialize.Struct o;
Serialize.Struct r;
try
{
r = p.opSerialStructCSharp(i, out o);
test(o.o == null);
test(o.o2 != null);
test(((Serialize.Struct)(o.o2)).o == null);
test(((Serialize.Struct)(o.o2)).o2 == o.o2);
test(o.s == null);
test(o.s2.Equals("Hello"));
test(r.o == null);
test(r.o2 != null);
test(((Serialize.Struct)(r.o2)).o == null);
test(((Serialize.Struct)(r.o2)).o2 == r.o2);
test(r.s == null);
test(r.s2.Equals("Hello"));
}
catch (Ice.OperationNotExistException)
{
// OK, talking to non-C# server.
}
}
}
internal static void twowaysAMI(Ice.Communicator communicator, Test.MyClassPrx p)
{
{
Dictionary <int, int> i = new Dictionary <int, int>();
i[0] = 1;
i[1] = 0;
AMI_MyClass_opNVI cb = new AMI_MyClass_opNVI(i);
p.opNV_async(cb, i);
cb.check();
}
{
Dictionary <string, string> i = new Dictionary <string, string>();
i["a"] = "b";
i["b"] = "a";
AMI_MyClass_opNRI cb = new AMI_MyClass_opNRI(i);
p.opNR_async(cb, i);
cb.check();
}
{
Dictionary <string, Dictionary <int, int> > i = new Dictionary <string, Dictionary <int, int> >();
Dictionary <int, int> id = new Dictionary <int, int>();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opNDVI cb = new AMI_MyClass_opNDVI(i);
p.opNDV_async(cb, i);
cb.check();
}
{
Dictionary <string, Dictionary <string, string> > i = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, string> id = new Dictionary <string, string>();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
AMI_MyClass_opNDRI cb = new AMI_MyClass_opNDRI(i);
p.opNDR_async(cb, i);
cb.check();
}
{
OV i = new OV();
i[0] = 1;
i[1] = 0;
AMI_MyClass_opOVI cb = new AMI_MyClass_opOVI(i);
p.opOV_async(cb, i);
cb.check();
}
{
OR i = new OR();
i["a"] = "b";
i["b"] = "a";
AMI_MyClass_opORI cb = new AMI_MyClass_opORI(i);
p.opOR_async(cb, i);
cb.check();
}
{
ODV i = new ODV();
OV id = new OV();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opODVI cb = new AMI_MyClass_opODVI(i);
p.opODV_async(cb, i);
cb.check();
}
{
ODR i = new ODR();
OR id = new OR();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
AMI_MyClass_opODRI cb = new AMI_MyClass_opODRI(i);
p.opODR_async(cb, i);
cb.check();
}
{
Dictionary <string, ODV> i = new Dictionary <string, ODV>();
OV iid = new OV();
iid[0] = 1;
iid[1] = 0;
ODV id = new ODV();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opNODVI cb = new AMI_MyClass_opNODVI(i);
p.opNODV_async(cb, i);
cb.check();
}
{
Dictionary <string, ODR> i = new Dictionary <string, ODR>();
OR iid = new OR();
iid["a"] = "b";
iid["b"] = "a";
ODR id = new ODR();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opNODRI cb = new AMI_MyClass_opNODRI(i);
p.opNODR_async(cb, i);
cb.check();
}
{
ONDV i = new ONDV();
Dictionary <int, int> iid = new Dictionary <int, int>();
iid[0] = 1;
iid[1] = 0;
Dictionary <string, Dictionary <int, int> > id
= new Dictionary <string, Dictionary <int, int> >();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opONDVI cb = new AMI_MyClass_opONDVI(i);
p.opONDV_async(cb, i);
cb.check();
}
{
ONDR i = new ONDR();
Dictionary <string, string> iid = new Dictionary <string, string>();
iid["a"] = "b";
iid["b"] = "a";
Dictionary <string, Dictionary <string, string> > id
= new Dictionary <string, Dictionary <string, string> >();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
AMI_MyClass_opONDRI cb = new AMI_MyClass_opONDRI(i);
p.opONDR_async(cb, i);
cb.check();
}
{
int[] ii = new int[] { 1, 2 };
Dictionary <string, int[]> i = new Dictionary <string, int[]>();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDAISI cb = new AMI_MyClass_opNDAISI(i);
p.opNDAIS_async(cb, i);
cb.check();
}
{
CIS ii = new CIS();
ii.Add(1);
ii.Add(2);
Dictionary <string, CIS> i = new Dictionary <string, CIS>();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDCISI cb = new AMI_MyClass_opNDCISI(i);
p.opNDCIS_async(cb, i);
cb.check();
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
Dictionary <string, List <int> > i = new Dictionary <string, List <int> >();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDGISI cb = new AMI_MyClass_opNDGISI(i);
p.opNDGIS_async(cb, i);
cb.check();
}
{
string[] ii = new string[] { "a", "b" };
Dictionary <string, string[]> i = new Dictionary <string, string[]>();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDASSI cb = new AMI_MyClass_opNDASSI(i);
p.opNDASS_async(cb, i);
cb.check();
}
{
CSS ii = new CSS();
ii.Add("a");
ii.Add("b");
Dictionary <string, CSS> i = new Dictionary <string, CSS>();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDCSSI cb = new AMI_MyClass_opNDCSSI(i);
p.opNDCSS_async(cb, i);
cb.check();
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
Dictionary <string, List <string> > i = new Dictionary <string, List <string> >();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opNDGSSI cb = new AMI_MyClass_opNDGSSI(i);
p.opNDGSS_async(cb, i);
cb.check();
}
{
int[] ii = new int[] { 1, 2 };
ODAIS i = new ODAIS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODAISI cb = new AMI_MyClass_opODAISI(i);
p.opODAIS_async(cb, i);
cb.check();
}
{
CIS ii = new CIS();
ii.Add(1);
ii.Add(2);
ODCIS i = new ODCIS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODCISI cb = new AMI_MyClass_opODCISI(i);
p.opODCIS_async(cb, i);
cb.check();
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
ODGIS i = new ODGIS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODGISI cb = new AMI_MyClass_opODGISI(i);
p.opODGIS_async(cb, i);
cb.check();
}
{
string[] ii = new string[] { "a", "b" };
ODASS i = new ODASS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODASSI cb = new AMI_MyClass_opODASSI(i);
p.opODASS_async(cb, i);
cb.check();
}
{
CSS ii = new CSS();
ii.Add("a");
ii.Add("b");
ODCSS i = new ODCSS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODCSSI cb = new AMI_MyClass_opODCSSI(i);
p.opODCSS_async(cb, i);
cb.check();
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
ODGSS i = new ODGSS();
i["a"] = ii;
i["b"] = ii;
AMI_MyClass_opODGSSI cb = new AMI_MyClass_opODGSSI(i);
p.opODGSS_async(cb, i);
cb.check();
}
}
public static int run(Ice.Communicator communicator)
{
MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();
communicator.getValueFactoryManager().add(factoryWrapper.create, Test.MyClass.ice_staticId());
communicator.getValueFactoryManager().add(MyInterfaceFactory, Test.MyInterfaceDisp_.ice_staticId());
Ice.InputStream @in;
Ice.OutputStream @out;
Write("testing primitive types... ");
Flush();
{
byte[] data = new byte[0];
@in = new Ice.InputStream(communicator, data);
}
{
@out = new Ice.OutputStream(communicator);
@out.startEncapsulation();
@out.writeBool(true);
@out.endEncapsulation();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
@in.startEncapsulation();
test(@in.readBool());
@in.endEncapsulation();
@in = new Ice.InputStream(communicator, data);
@in.startEncapsulation();
test(@in.readBool());
@in.endEncapsulation();
}
{
byte[] data = new byte[0];
@in = new Ice.InputStream(communicator, data);
try
{
@in.readBool();
test(false);
}
catch (Ice.UnmarshalOutOfBoundsException)
{
}
}
{
@out = new Ice.OutputStream(communicator);
@out.writeBool(true);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readBool());
}
{
@out = new Ice.OutputStream(communicator);
@out.writeByte((byte)1);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readByte() == (byte)1);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeShort((short)2);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readShort() == (short)2);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeInt(3);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readInt() == 3);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeLong(4);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readLong() == 4);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeFloat((float)5.0);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readFloat() == (float)5.0);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeDouble(6.0);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readDouble() == 6.0);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeString("hello world");
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readString().Equals("hello world"));
}
WriteLine("ok");
Write("testing constructed types... ");
Flush();
{
@out = new Ice.OutputStream(communicator);
Test.MyEnumHelper.write(@out, Test.MyEnum.enum3);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum e = Test.MyEnumHelper.read(@in);
test(e == Test.MyEnum.enum3);
}
{
@out = new Ice.OutputStream(communicator);
Test.SmallStruct s = new Test.SmallStruct();
s.bo = true;
s.by = (byte)1;
s.sh = (short)2;
s.i = 3;
s.l = 4;
s.f = (float)5.0;
s.d = 6.0;
s.str = "7";
s.e = Test.MyEnum.enum2;
s.p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
s.write__(@out);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.SmallStruct s2 = new Test.SmallStruct();
s2.read__(@in);
test(s2.Equals(s));
}
{
@out = new Ice.OutputStream(communicator);
OptionalClass o = new OptionalClass();
o.bo = true;
o.by = (byte)5;
o.sh = 4;
o.i = 3;
@out.writeValue(o);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
TestReadValueCallback cb = new TestReadValueCallback();
@in.readValue(cb.invoke);
@in.readPendingValues();
OptionalClass 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);
}
}
{
@out = new Ice.OutputStream(communicator, Ice.Util.Encoding_1_0);
OptionalClass o = new OptionalClass();
o.bo = true;
o.by = 5;
o.sh = 4;
o.i = 3;
@out.writeValue(o);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, Ice.Util.Encoding_1_0, data);
TestReadValueCallback cb = new TestReadValueCallback();
@in.readValue(cb.invoke);
@in.readPendingValues();
OptionalClass 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
};
@out = new Ice.OutputStream(communicator);
Ice.BoolSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
bool[] arr2 = Ice.BoolSeqHelper.read(@in);
test(Compare(arr2, arr));
bool[][] arrS =
{
arr,
new bool[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.BoolSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
bool[][] arr2S = Test.BoolSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
byte[] arr =
{
(byte)0x01,
(byte)0x11,
(byte)0x12,
(byte)0x22
};
@out = new Ice.OutputStream(communicator);
Ice.ByteSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
byte[] arr2 = Ice.ByteSeqHelper.read(@in);
test(Compare(arr2, arr));
byte[][] arrS =
{
arr,
new byte[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.ByteSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
byte[][] arr2S = Test.ByteSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
Serialize.Small small = new Serialize.Small();
small.i = 99;
@out = new Ice.OutputStream(communicator);
@out.writeSerializable(small);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Serialize.Small small2 = (Serialize.Small)@in.readSerializable();
test(small2.i == 99);
}
{
short[] arr =
{
(short)0x01,
(short)0x11,
(short)0x12,
(short)0x22
};
@out = new Ice.OutputStream(communicator);
Ice.ShortSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
short[] arr2 = Ice.ShortSeqHelper.read(@in);
test(Compare(arr2, arr));
short[][] arrS =
{
arr,
new short[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.ShortSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
short[][] arr2S = Test.ShortSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
int[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Ice.IntSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
int[] arr2 = Ice.IntSeqHelper.read(@in);
test(Compare(arr2, arr));
int[][] arrS =
{
arr,
new int[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.IntSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
int[][] arr2S = Test.IntSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
long[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Ice.LongSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
long[] arr2 = Ice.LongSeqHelper.read(@in);
test(Compare(arr2, arr));
long[][] arrS =
{
arr,
new long[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.LongSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
long[][] arr2S = Test.LongSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
float[] arr =
{
(float)1,
(float)2,
(float)3,
(float)4
};
@out = new Ice.OutputStream(communicator);
Ice.FloatSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
float[] arr2 = Ice.FloatSeqHelper.read(@in);
test(Compare(arr2, arr));
float[][] arrS =
{
arr,
new float[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.FloatSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
float[][] arr2S = Test.FloatSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
double[] arr =
{
(double)1,
(double)2,
(double)3,
(double)4
};
@out = new Ice.OutputStream(communicator);
Ice.DoubleSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
double[] arr2 = Ice.DoubleSeqHelper.read(@in);
test(Compare(arr2, arr));
double[][] arrS =
{
arr,
new double[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.DoubleSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
double[][] arr2S = Test.DoubleSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
@out = new Ice.OutputStream(communicator);
Ice.StringSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
string[] arr2 = Ice.StringSeqHelper.read(@in);
test(Compare(arr2, arr));
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.StringSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
string[][] arr2S = Test.StringSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
Test.MyEnumSHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum[] arr2 = Test.MyEnumSHelper.read(@in);
test(Compare(arr2, arr));
Test.MyEnum[][] arrS =
{
arr,
new Test.MyEnum[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.MyEnumSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum[][] arr2S = Test.MyEnumSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
Test.SmallStruct[] smallStructArray = new Test.SmallStruct[3];
for (int i = 0; i < smallStructArray.Length; ++i)
{
smallStructArray[i] = new Test.SmallStruct();
smallStructArray[i].bo = true;
smallStructArray[i].by = (byte)1;
smallStructArray[i].sh = (short)2;
smallStructArray[i].i = 3;
smallStructArray[i].l = 4;
smallStructArray[i].f = (float)5.0;
smallStructArray[i].d = 6.0;
smallStructArray[i].str = "7";
smallStructArray[i].e = Test.MyEnum.enum2;
smallStructArray[i].p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
}
Test.MyClass[] myClassArray = new Test.MyClass[4];
for (int i = 0; i < myClassArray.Length; ++i)
{
myClassArray[i] = new Test.MyClass();
myClassArray[i].c = myClassArray[i];
myClassArray[i].o = myClassArray[i];
myClassArray[i].s = new Test.SmallStruct();
myClassArray[i].s.e = Test.MyEnum.enum2;
myClassArray[i].seq1 = new bool[] { true, false, true, false };
myClassArray[i].seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 };
myClassArray[i].seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 };
myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 };
myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 };
myClassArray[i].seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 };
myClassArray[i].seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 };
myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" };
myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 };
myClassArray[i].seq10 = new Test.MyClass[4]; // null elements.
myClassArray[i].d = new System.Collections.Generic.Dictionary<string, Test.MyClass>();
myClassArray[i].d["hi"] = myClassArray[i];
}
{
@out = new Ice.OutputStream(communicator);
Test.MyClassSHelper.write(@out, myClassArray);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyClass[] arr2 = Test.MyClassSHelper.read(@in);
@in.readPendingValues();
test(arr2.Length == myClassArray.Length);
for (int i = 0; i < arr2.Length; ++i)
{
test(arr2[i] != null);
test(arr2[i].c == arr2[i]);
test(arr2[i].o == arr2[i]);
test(arr2[i].s.e == Test.MyEnum.enum2);
test(Compare(arr2[i].seq1, myClassArray[i].seq1));
test(Compare(arr2[i].seq2, myClassArray[i].seq2));
test(Compare(arr2[i].seq3, myClassArray[i].seq3));
test(Compare(arr2[i].seq4, myClassArray[i].seq4));
test(Compare(arr2[i].seq5, myClassArray[i].seq5));
test(Compare(arr2[i].seq6, myClassArray[i].seq6));
test(Compare(arr2[i].seq7, myClassArray[i].seq7));
test(Compare(arr2[i].seq8, myClassArray[i].seq8));
test(Compare(arr2[i].seq9, myClassArray[i].seq9));
test(arr2[i].d["hi"].Equals(arr2[i]));
}
Test.MyClass[][] arrS =
{
myClassArray,
new Test.MyClass[0],
myClassArray
};
@out = new Ice.OutputStream(communicator);
Test.MyClassSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyClass[][] arr2S = Test.MyClassSSHelper.read(@in);
test(arr2S.Length == arrS.Length);
test(arr2S[0].Length == arrS[0].Length);
test(arr2S[1].Length == arrS[1].Length);
test(arr2S[2].Length == arrS[2].Length);
}
{
Test.MyInterface i = new MyInterfaceI();
@out = new Ice.OutputStream(communicator);
@out.writeValue(i);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
TestReadValueCallback cb = new TestReadValueCallback();
@in.readValue(cb.invoke);
@in.readPendingValues();
test(cb.obj != null);
}
{
@out = new Ice.OutputStream(communicator);
Test.MyClass obj = new Test.MyClass();
obj.s = new Test.SmallStruct();
obj.s.e = Test.MyEnum.enum2;
TestValueWriter writer = new TestValueWriter(obj);
@out.writeValue(writer);
@out.writePendingValues();
byte[] data = @out.finished();
test(writer.called);
factoryWrapper.setFactory(TestObjectFactory);
@in = new Ice.InputStream(communicator, data);
TestReadValueCallback cb = new TestReadValueCallback();
@in.readValue(cb.invoke);
@in.readPendingValues();
test(cb.obj != null);
test(cb.obj is TestValueReader);
TestValueReader reader = (TestValueReader)cb.obj;
test(reader.called);
test(reader.obj != null);
test(reader.obj.s.e == Test.MyEnum.enum2);
factoryWrapper.setFactory(null);
}
{
@out = new Ice.OutputStream(communicator);
Test.MyException ex = new Test.MyException();
Test.MyClass c = new Test.MyClass();
c.c = c;
c.o = c;
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum2;
c.seq1 = new bool[] { true, false, true, false };
c.seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 };
c.seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 };
c.seq4 = new int[] { 1, 2, 3, 4 };
c.seq5 = new long[] { 1, 2, 3, 4 };
c.seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 };
c.seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 };
c.seq8 = new string[] { "string1", "string2", "string3", "string4" };
c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 };
c.seq10 = new Test.MyClass[4]; // null elements.
c.d = new Dictionary<string, Test.MyClass>();
c.d.Add("hi", c);
ex.c = c;
@out.writeException(ex);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
try
{
@in.throwException();
test(false);
}
catch (Test.MyException ex1)
{
test(ex1.c.s.e == c.s.e);
test(Compare(ex1.c.seq1, c.seq1));
test(Compare(ex1.c.seq2, c.seq2));
test(Compare(ex1.c.seq3, c.seq3));
test(Compare(ex1.c.seq4, c.seq4));
test(Compare(ex1.c.seq5, c.seq5));
test(Compare(ex1.c.seq6, c.seq6));
test(Compare(ex1.c.seq7, c.seq7));
test(Compare(ex1.c.seq8, c.seq8));
test(Compare(ex1.c.seq9, c.seq9));
}
catch (Ice.UserException)
{
test(false);
}
}
{
Dictionary<byte, bool> dict = new Dictionary<byte, bool>();
dict.Add((byte)4, true);
dict.Add((byte)1, false);
@out = new Ice.OutputStream(communicator);
Test.ByteBoolDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary<byte, bool> dict2 = Test.ByteBoolDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary<short, int> dict = new Dictionary<short, int>();
dict.Add((short)1, 9);
dict.Add((short)4, 8);
@out = new Ice.OutputStream(communicator);
Test.ShortIntDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary<short, int> dict2 = Test.ShortIntDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary<long, float> dict = new Dictionary<long, float>();
dict.Add((long)123809828, (float)0.51f);
dict.Add((long)123809829, (float)0.56f);
@out = new Ice.OutputStream(communicator);
Test.LongFloatDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary<long, float> dict2 = Test.LongFloatDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary<string, string> dict = new Dictionary<string, string>();
dict.Add("key1", "value1");
dict.Add("key2", "value2");
@out = new Ice.OutputStream(communicator);
Test.StringStringDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary<string, string> dict2 = Test.StringStringDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary<string, Test.MyClass> dict = new Dictionary<string, Test.MyClass>();
Test.MyClass c;
c = new Test.MyClass();
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum2;
dict.Add("key1", c);
c = new Test.MyClass();
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum3;
dict.Add("key2", c);
@out = new Ice.OutputStream(communicator);
Test.StringMyClassDHelper.write(@out, dict);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary<string, Test.MyClass> dict2 = Test.StringMyClassDHelper.read(@in);
@in.readPendingValues();
test(dict2.Count == dict.Count);
test(dict2["key1"].s.e == Test.MyEnum.enum2);
test(dict2["key2"].s.e == Test.MyEnum.enum3);
}
{
bool[] arr =
{
true,
false,
true,
false
};
@out = new Ice.OutputStream(communicator);
List<bool> l = new List<bool>(arr);
Test.BoolListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<bool> l2 = Test.BoolListHelper.read(@in);
test(Compare(l, l2));
}
{
byte[] arr =
{
(byte)0x01,
(byte)0x11,
(byte)0x12,
(byte)0x22
};
@out = new Ice.OutputStream(communicator);
List<byte> l = new List<byte>(arr);
Test.ByteListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<byte> l2 = Test.ByteListHelper.read(@in);
test(Compare(l2, l));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
List<Test.MyEnum> l = new List<Test.MyEnum>(arr);
Test.MyEnumListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<Test.MyEnum> l2 = Test.MyEnumListHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
List<Test.SmallStruct> l = new List<Test.SmallStruct>(smallStructArray);
Test.SmallStructListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<Test.SmallStruct> l2 = Test.SmallStructListHelper.read(@in);
test(l2.Count == l.Count);
for (int i = 0; i < l2.Count; ++i)
{
test(l2[i].Equals(smallStructArray[i]));
}
}
{
@out = new Ice.OutputStream(communicator);
List<Test.MyClass> l = new List<Test.MyClass>(myClassArray);
Test.MyClassListHelper.write(@out, l);
@out.writePendingValues();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<Test.MyClass> l2 = Test.MyClassListHelper.read(@in);
@in.readPendingValues();
test(l2.Count == l.Count);
for (int i = 0; i < l2.Count; ++i)
{
test(l2[i] != null);
test(l2[i].c == l2[i]);
test(l2[i].o == l2[i]);
test(l2[i].s.e == Test.MyEnum.enum2);
test(Compare(l2[i].seq1, l[i].seq1));
test(Compare(l2[i].seq2, l[i].seq2));
test(Compare(l2[i].seq3, l[i].seq3));
test(Compare(l2[i].seq4, l[i].seq4));
test(Compare(l2[i].seq5, l[i].seq5));
test(Compare(l2[i].seq6, l[i].seq6));
test(Compare(l2[i].seq7, l[i].seq7));
test(Compare(l2[i].seq8, l[i].seq8));
test(Compare(l2[i].seq9, l[i].seq9));
test(l2[i].d["hi"].Equals(l2[i]));
}
}
{
Test.MyClassPrx[] arr = new Test.MyClassPrx[2];
arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
@out = new Ice.OutputStream(communicator);
List<Test.MyClassPrx> l = new List<Test.MyClassPrx>(arr);
Test.MyClassProxyListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<Test.MyClassPrx> l2 = Test.MyClassProxyListHelper.read(@in);
test(Compare(l2, l));
}
{
short[] arr =
{
(short)0x01,
(short)0x11,
(short)0x12,
(short)0x22
};
@out = new Ice.OutputStream(communicator);
LinkedList<short> l = new LinkedList<short>(arr);
Test.ShortLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList<short> l2 = Test.ShortLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
int[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
LinkedList<int> l = new LinkedList<int>(arr);
Test.IntLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList<int> l2 = Test.IntLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
LinkedList<Test.MyEnum> l = new LinkedList<Test.MyEnum>(arr);
Test.MyEnumLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList<Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
LinkedList<Test.SmallStruct> l = new LinkedList<Test.SmallStruct>(smallStructArray);
Test.SmallStructLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList<Test.SmallStruct> l2 = Test.SmallStructLinkedListHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator<Test.SmallStruct> e = l.GetEnumerator();
IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
long[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Stack<long> l = new Stack<long>(arr);
Test.LongStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack<long> l2 = Test.LongStackHelper.read(@in);
test(Compare(l2, l));
}
{
float[] arr =
{
(float)1,
(float)2,
(float)3,
(float)4
};
@out = new Ice.OutputStream(communicator);
Stack<float> l = new Stack<float>(arr);
Test.FloatStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack<float> l2 = Test.FloatStackHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
Stack<Test.SmallStruct> l = new Stack<Test.SmallStruct>(smallStructArray);
Test.SmallStructStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack<Test.SmallStruct> l2 = Test.SmallStructStackHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator<Test.SmallStruct> e = l.GetEnumerator();
IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
Test.MyClassPrx[] arr = new Test.MyClassPrx[2];
arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
@out = new Ice.OutputStream(communicator);
Stack<Test.MyClassPrx> l = new Stack<Test.MyClassPrx>(arr);
Test.MyClassProxyStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack<Test.MyClassPrx> l2 = Test.MyClassProxyStackHelper.read(@in);
test(Compare(l2, l));
}
{
double[] arr =
{
(double)1,
(double)2,
(double)3,
(double)4
};
@out = new Ice.OutputStream(communicator);
Queue<double> l = new Queue<double>(arr);
Test.DoubleQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue<double> l2 = Test.DoubleQueueHelper.read(@in);
test(Compare(l2, l));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
@out = new Ice.OutputStream(communicator);
Queue<string> l = new Queue<string>(arr);
Test.StringQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue<string> l2 = Test.StringQueueHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
Queue<Test.SmallStruct> l = new Queue<Test.SmallStruct>(smallStructArray);
Test.SmallStructQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue<Test.SmallStruct> l2 = Test.SmallStructQueueHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator<Test.SmallStruct> e = l.GetEnumerator();
IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
List<string[]> l = new List<string[]>(arrS);
Test.StringSListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List<string[]> l2 = Test.StringSListHelper.read(@in);
test(Compare(l2, l));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
Stack<string[]> l = new Stack<string[]>(arrS);
Test.StringSStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack<string[]> l2 = Test.StringSStackHelper.read(@in);
test(Compare(l2, l));
}
{
SortedDictionary<string, string> dict = new SortedDictionary<string, string>();
dict.Add("key1", "value1");
dict.Add("key2", "value2");
@out = new Ice.OutputStream(communicator);
Test.SortedStringStringDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
IDictionary<string, string> dict2 = Test.SortedStringStringDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
WriteLine("ok");
return 0;
}
internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p)
{
{
Dictionary <int, int> i = new Dictionary <int, int>();
i[0] = 1;
i[1] = 0;
Dictionary <int, int> o;
Dictionary <int, int> r;
r = p.opNV(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Dictionary <string, string> i = new Dictionary <string, string>();
i["a"] = "b";
i["b"] = "a";
Dictionary <string, string> o;
Dictionary <string, string> r;
r = p.opNR(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Dictionary <string, Dictionary <int, int> > i = new Dictionary <string, Dictionary <int, int> >();
Dictionary <int, int> id = new Dictionary <int, int>();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
Dictionary <string, Dictionary <int, int> > o;
Dictionary <string, Dictionary <int, int> > r;
r = p.opNDV(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
Dictionary <string, Dictionary <string, string> > i = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, string> id = new Dictionary <string, string>();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
Dictionary <string, Dictionary <string, string> > o;
Dictionary <string, Dictionary <string, string> > r;
r = p.opNDR(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
OV i = new OV();
i[0] = 1;
i[1] = 0;
OV o;
OV r;
r = p.opOV(i, out o);
test(OV.Equals(i, o));
test(OV.Equals(i, r));
}
{
OR i = new OR();
i["a"] = "b";
i["b"] = "a";
OR o;
OR r;
r = p.opOR(i, out o);
test(OR.Equals(i, o));
test(OR.Equals(i, r));
}
{
ODV i = new ODV();
OV id = new OV();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
ODV o;
ODV r;
r = p.opODV(i, out o);
test(ODV.Equals(i, o));
test(ODV.Equals(i, r));
}
{
ODR i = new ODR();
OR id = new OR();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
ODR o;
ODR r;
r = p.opODR(i, out o);
test(ODR.Equals(i, o));
test(ODR.Equals(i, r));
}
{
Dictionary <string, ODV> i = new Dictionary <string, ODV>();
OV iid = new OV();
iid[0] = 1;
iid[1] = 0;
ODV id = new ODV();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
Dictionary <string, ODV> o;
Dictionary <string, ODV> r;
r = p.opNODV(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Dictionary <string, ODR> i = new Dictionary <string, ODR>();
OR iid = new OR();
iid["a"] = "b";
iid["a"] = "b";
ODR id = new ODR();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
Dictionary <string, ODR> o;
Dictionary <string, ODR> r;
r = p.opNODR(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
ONDV i = new ONDV();
Dictionary <int, int> iid = new Dictionary <int, int>();
iid[0] = 1;
iid[1] = 0;
Dictionary <string, Dictionary <int, int> > id
= new Dictionary <string, Dictionary <int, int> >();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
ONDV o;
ONDV r;
r = p.opONDV(i, out o);
foreach (string key in i.Keys)
{
foreach (string s in i[key].Keys)
{
test(Ice.CollectionComparer.Equals(i[key][s], o[key][s]));
test(Ice.CollectionComparer.Equals(i[key][s], r[key][s]));
}
}
}
{
ONDR i = new ONDR();
Dictionary <string, string> iid = new Dictionary <string, string>();
iid["a"] = "b";
iid["b"] = "a";
Dictionary <string, Dictionary <string, string> > id
= new Dictionary <string, Dictionary <string, string> >();
id["a"] = iid;
id["b"] = iid;
i["a"] = id;
i["b"] = id;
ONDR o;
ONDR r;
r = p.opONDR(i, out o);
foreach (string key in i.Keys)
{
foreach (string s in i[key].Keys)
{
test(Ice.CollectionComparer.Equals(i[key][s], o[key][s]));
test(Ice.CollectionComparer.Equals(i[key][s], r[key][s]));
}
}
}
{
int[] ii = new int[] { 1, 2 };
Dictionary <string, int[]> i = new Dictionary <string, int[]>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, int[]> o;
Dictionary <string, int[]> r;
r = p.opNDAIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
CIS ii = new CIS();
ii.Add(1);
ii.Add(2);
Dictionary <string, CIS> i = new Dictionary <string, CIS>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, CIS> o;
Dictionary <string, CIS> r;
r = p.opNDCIS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
Dictionary <string, List <int> > i = new Dictionary <string, List <int> >();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, List <int> > o;
Dictionary <string, List <int> > r;
r = p.opNDGIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
string[] ii = new string[] { "a", "b" };
Dictionary <string, string[]> i = new Dictionary <string, string[]>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, string[]> o;
Dictionary <string, string[]> r;
r = p.opNDASS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
CSS ii = new CSS();
ii.Add("a");
ii.Add("b");
Dictionary <string, CSS> i = new Dictionary <string, CSS>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, CSS> o;
Dictionary <string, CSS> r;
r = p.opNDCSS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
Dictionary <string, List <string> > i = new Dictionary <string, List <string> >();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, List <string> > o;
Dictionary <string, List <string> > r;
r = p.opNDGSS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
int[] ii = new int[] { 1, 2 };
ODAIS i = new ODAIS();
i["a"] = ii;
i["b"] = ii;
ODAIS o;
ODAIS r;
r = p.opODAIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
CIS ii = new CIS();
ii.Add(1);
ii.Add(2);
ODCIS i = new ODCIS();
i["a"] = ii;
i["b"] = ii;
ODCIS o;
ODCIS r;
r = p.opODCIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
ODGIS i = new ODGIS();
i["a"] = ii;
i["b"] = ii;
ODGIS o;
ODGIS r;
r = p.opODGIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
string[] ii = new string[] { "a", "b" };
ODASS i = new ODASS();
i["a"] = ii;
i["b"] = ii;
ODASS o;
ODASS r;
r = p.opODASS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
CSS ii = new CSS();
ii.Add("a");
ii.Add("b");
ODCSS i = new ODCSS();
i["a"] = ii;
i["b"] = ii;
ODCSS o;
ODCSS r;
r = p.opODCSS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
ODGSS i = new ODGSS();
i["a"] = ii;
i["b"] = ii;
ODGSS o;
ODGSS r;
r = p.opODGSS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
}
static public int run(Ice.Communicator communicator)
#endif
{
MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();
communicator.getValueFactoryManager().add(factoryWrapper.create, Test.MyClass.ice_staticId());
communicator.getValueFactoryManager().add(MyInterfaceFactory, Test.MyInterfaceDisp_.ice_staticId());
Ice.InputStream @in;
Ice.OutputStream @out;
Write("testing primitive types... ");
Flush();
{
byte[] data = new byte[0];
@in = new Ice.InputStream(communicator, data);
}
{
@out = new Ice.OutputStream(communicator);
@out.startEncapsulation();
@out.writeBool(true);
@out.endEncapsulation();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
@in.startEncapsulation();
test(@in.readBool());
@in.endEncapsulation();
@in = new Ice.InputStream(communicator, data);
@in.startEncapsulation();
test(@in.readBool());
@in.endEncapsulation();
}
{
byte[] data = new byte[0];
@in = new Ice.InputStream(communicator, data);
try
{
@in.readBool();
test(false);
}
catch (Ice.UnmarshalOutOfBoundsException)
{
}
}
{
@out = new Ice.OutputStream(communicator);
@out.writeBool(true);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readBool());
}
{
@out = new Ice.OutputStream(communicator);
@out.writeByte((byte)1);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readByte() == (byte)1);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeShort((short)2);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readShort() == (short)2);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeInt(3);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readInt() == 3);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeLong(4);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readLong() == 4);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeFloat((float)5.0);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readFloat() == (float)5.0);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeDouble(6.0);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readDouble() == 6.0);
}
{
@out = new Ice.OutputStream(communicator);
@out.writeString("hello world");
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
test(@in.readString().Equals("hello world"));
}
WriteLine("ok");
Write("testing constructed types... ");
Flush();
{
int max = 2;
@out = new Ice.OutputStream(communicator);
@out.writeEnum((int)Test.MyEnum.enum3, max);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum e = (Test.MyEnum)@in.readEnum(max);
test(e == Test.MyEnum.enum3);
}
{
@out = new Ice.OutputStream(communicator);
Test.SmallStruct s = new Test.SmallStruct();
s.bo = true;
s.by = (byte)1;
s.sh = (short)2;
s.i = 3;
s.l = 4;
s.f = (float)5.0;
s.d = 6.0;
s.str = "7";
s.e = Test.MyEnum.enum2;
s.p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
s.write__(@out);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.SmallStruct s2 = new Test.SmallStruct();
s2.read__(@in);
test(s2.Equals(s));
}
{
@out = new Ice.OutputStream(communicator);
OptionalClass o = new OptionalClass();
o.bo = true;
o.by = (byte)5;
o.sh = 4;
o.i = 3;
@out.writeObject(o);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
TestReadObjectCallback cb = new TestReadObjectCallback();
@in.readObject(cb.invoke);
@in.readPendingObjects();
OptionalClass 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);
}
}
{
@out = new Ice.OutputStream(communicator, Ice.Util.Encoding_1_0);
OptionalClass o = new OptionalClass();
o.bo = true;
o.by = 5;
o.sh = 4;
o.i = 3;
@out.writeObject(o);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, Ice.Util.Encoding_1_0, data);
TestReadObjectCallback cb = new TestReadObjectCallback();
@in.readObject(cb.invoke);
@in.readPendingObjects();
OptionalClass 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
};
@out = new Ice.OutputStream(communicator);
Ice.BoolSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
bool[] arr2 = Ice.BoolSeqHelper.read(@in);
test(Compare(arr2, arr));
bool[][] arrS =
{
arr,
new bool[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.BoolSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
bool[][] arr2S = Test.BoolSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
byte[] arr =
{
(byte)0x01,
(byte)0x11,
(byte)0x12,
(byte)0x22
};
@out = new Ice.OutputStream(communicator);
Ice.ByteSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
byte[] arr2 = Ice.ByteSeqHelper.read(@in);
test(Compare(arr2, arr));
byte[][] arrS =
{
arr,
new byte[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.ByteSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
byte[][] arr2S = Test.ByteSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
#if !COMPACT && !SILVERLIGHT
{
Serialize.Small small = new Serialize.Small();
small.i = 99;
@out = new Ice.OutputStream(communicator);
@out.writeSerializable(small);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Serialize.Small small2 = (Serialize.Small)@in.readSerializable();
test(small2.i == 99);
}
#endif
{
short[] arr =
{
(short)0x01,
(short)0x11,
(short)0x12,
(short)0x22
};
@out = new Ice.OutputStream(communicator);
Ice.ShortSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
short[] arr2 = Ice.ShortSeqHelper.read(@in);
test(Compare(arr2, arr));
short[][] arrS =
{
arr,
new short[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.ShortSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
short[][] arr2S = Test.ShortSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
int[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Ice.IntSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
int[] arr2 = Ice.IntSeqHelper.read(@in);
test(Compare(arr2, arr));
int[][] arrS =
{
arr,
new int[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.IntSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
int[][] arr2S = Test.IntSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
long[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Ice.LongSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
long[] arr2 = Ice.LongSeqHelper.read(@in);
test(Compare(arr2, arr));
long[][] arrS =
{
arr,
new long[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.LongSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
long[][] arr2S = Test.LongSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
float[] arr =
{
(float)1,
(float)2,
(float)3,
(float)4
};
@out = new Ice.OutputStream(communicator);
Ice.FloatSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
float[] arr2 = Ice.FloatSeqHelper.read(@in);
test(Compare(arr2, arr));
float[][] arrS =
{
arr,
new float[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.FloatSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
float[][] arr2S = Test.FloatSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
double[] arr =
{
(double)1,
(double)2,
(double)3,
(double)4
};
@out = new Ice.OutputStream(communicator);
Ice.DoubleSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
double[] arr2 = Ice.DoubleSeqHelper.read(@in);
test(Compare(arr2, arr));
double[][] arrS =
{
arr,
new double[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.DoubleSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
double[][] arr2S = Test.DoubleSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
@out = new Ice.OutputStream(communicator);
Ice.StringSeqHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
string[] arr2 = Ice.StringSeqHelper.read(@in);
test(Compare(arr2, arr));
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.StringSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
string[][] arr2S = Test.StringSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
Test.MyEnumSHelper.write(@out, arr);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum[] arr2 = Test.MyEnumSHelper.read(@in);
test(Compare(arr2, arr));
Test.MyEnum[][] arrS =
{
arr,
new Test.MyEnum[0],
arr
};
@out = new Ice.OutputStream(communicator);
Test.MyEnumSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnum[][] arr2S = Test.MyEnumSSHelper.read(@in);
test(Compare(arr2S, arrS));
}
Test.SmallStruct[] smallStructArray = new Test.SmallStruct[3];
for (int i = 0; i < smallStructArray.Length; ++i)
{
smallStructArray[i] = new Test.SmallStruct();
smallStructArray[i].bo = true;
smallStructArray[i].by = (byte)1;
smallStructArray[i].sh = (short)2;
smallStructArray[i].i = 3;
smallStructArray[i].l = 4;
smallStructArray[i].f = (float)5.0;
smallStructArray[i].d = 6.0;
smallStructArray[i].str = "7";
smallStructArray[i].e = Test.MyEnum.enum2;
smallStructArray[i].p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default"));
}
Test.MyClass[] myClassArray = new Test.MyClass[4];
for (int i = 0; i < myClassArray.Length; ++i)
{
myClassArray[i] = new Test.MyClass();
myClassArray[i].c = myClassArray[i];
myClassArray[i].o = myClassArray[i];
myClassArray[i].s = new Test.SmallStruct();
myClassArray[i].s.e = Test.MyEnum.enum2;
myClassArray[i].seq1 = new bool[] { true, false, true, false };
myClassArray[i].seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 };
myClassArray[i].seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 };
myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 };
myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 };
myClassArray[i].seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 };
myClassArray[i].seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 };
myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" };
myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 };
myClassArray[i].seq10 = new Test.MyClass[4]; // null elements.
myClassArray[i].d = new System.Collections.Generic.Dictionary <string, Test.MyClass>();
myClassArray[i].d["hi"] = myClassArray[i];
}
{
@out = new Ice.OutputStream(communicator);
Test.MyClassSHelper.write(@out, myClassArray);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyClass[] arr2 = Test.MyClassSHelper.read(@in);
@in.readPendingObjects();
test(arr2.Length == myClassArray.Length);
for (int i = 0; i < arr2.Length; ++i)
{
test(arr2[i] != null);
test(arr2[i].c == arr2[i]);
test(arr2[i].o == arr2[i]);
test(arr2[i].s.e == Test.MyEnum.enum2);
test(Compare(arr2[i].seq1, myClassArray[i].seq1));
test(Compare(arr2[i].seq2, myClassArray[i].seq2));
test(Compare(arr2[i].seq3, myClassArray[i].seq3));
test(Compare(arr2[i].seq4, myClassArray[i].seq4));
test(Compare(arr2[i].seq5, myClassArray[i].seq5));
test(Compare(arr2[i].seq6, myClassArray[i].seq6));
test(Compare(arr2[i].seq7, myClassArray[i].seq7));
test(Compare(arr2[i].seq8, myClassArray[i].seq8));
test(Compare(arr2[i].seq9, myClassArray[i].seq9));
test(arr2[i].d["hi"].Equals(arr2[i]));
}
Test.MyClass[][] arrS =
{
myClassArray,
new Test.MyClass[0],
myClassArray
};
@out = new Ice.OutputStream(communicator);
Test.MyClassSSHelper.write(@out, arrS);
data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyClass[][] arr2S = Test.MyClassSSHelper.read(@in);
test(arr2S.Length == arrS.Length);
test(arr2S[0].Length == arrS[0].Length);
test(arr2S[1].Length == arrS[1].Length);
test(arr2S[2].Length == arrS[2].Length);
}
{
Test.MyInterface i = new MyInterfaceI();
@out = new Ice.OutputStream(communicator);
@out.writeObject(i);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
TestReadObjectCallback cb = new TestReadObjectCallback();
@in.readObject(cb.invoke);
@in.readPendingObjects();
test(cb.obj != null);
}
{
@out = new Ice.OutputStream(communicator);
Test.MyClass obj = new Test.MyClass();
obj.s = new Test.SmallStruct();
obj.s.e = Test.MyEnum.enum2;
TestObjectWriter writer = new TestObjectWriter(obj);
@out.writeObject(writer);
@out.writePendingObjects();
byte[] data = @out.finished();
test(writer.called);
factoryWrapper.setFactory(TestObjectFactory);
@in = new Ice.InputStream(communicator, data);
TestReadObjectCallback cb = new TestReadObjectCallback();
@in.readObject(cb.invoke);
@in.readPendingObjects();
test(cb.obj != null);
test(cb.obj is TestObjectReader);
TestObjectReader reader = (TestObjectReader)cb.obj;
test(reader.called);
test(reader.obj != null);
test(reader.obj.s.e == Test.MyEnum.enum2);
factoryWrapper.setFactory(null);
}
{
@out = new Ice.OutputStream(communicator);
Test.MyException ex = new Test.MyException();
Test.MyClass c = new Test.MyClass();
c.c = c;
c.o = c;
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum2;
c.seq1 = new bool[] { true, false, true, false };
c.seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 };
c.seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 };
c.seq4 = new int[] { 1, 2, 3, 4 };
c.seq5 = new long[] { 1, 2, 3, 4 };
c.seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 };
c.seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 };
c.seq8 = new string[] { "string1", "string2", "string3", "string4" };
c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 };
c.seq10 = new Test.MyClass[4]; // null elements.
c.d = new Dictionary <string, Test.MyClass>();
c.d.Add("hi", c);
ex.c = c;
@out.writeException(ex);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
try
{
@in.throwException();
test(false);
}
catch (Test.MyException ex1)
{
test(ex1.c.s.e == c.s.e);
test(Compare(ex1.c.seq1, c.seq1));
test(Compare(ex1.c.seq2, c.seq2));
test(Compare(ex1.c.seq3, c.seq3));
test(Compare(ex1.c.seq4, c.seq4));
test(Compare(ex1.c.seq5, c.seq5));
test(Compare(ex1.c.seq6, c.seq6));
test(Compare(ex1.c.seq7, c.seq7));
test(Compare(ex1.c.seq8, c.seq8));
test(Compare(ex1.c.seq9, c.seq9));
}
catch (Ice.UserException)
{
test(false);
}
}
{
Dictionary <byte, bool> dict = new Dictionary <byte, bool>();
dict.Add((byte)4, true);
dict.Add((byte)1, false);
@out = new Ice.OutputStream(communicator);
Test.ByteBoolDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary <byte, bool> dict2 = Test.ByteBoolDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary <short, int> dict = new Dictionary <short, int>();
dict.Add((short)1, 9);
dict.Add((short)4, 8);
@out = new Ice.OutputStream(communicator);
Test.ShortIntDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary <short, int> dict2 = Test.ShortIntDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary <long, float> dict = new Dictionary <long, float>();
dict.Add((long)123809828, (float)0.51f);
dict.Add((long)123809829, (float)0.56f);
@out = new Ice.OutputStream(communicator);
Test.LongFloatDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary <long, float> dict2 = Test.LongFloatDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary <string, string> dict = new Dictionary <string, string>();
dict.Add("key1", "value1");
dict.Add("key2", "value2");
@out = new Ice.OutputStream(communicator);
Test.StringStringDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary <string, string> dict2 = Test.StringStringDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Dictionary <string, Test.MyClass> dict = new Dictionary <string, Test.MyClass>();
Test.MyClass c;
c = new Test.MyClass();
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum2;
dict.Add("key1", c);
c = new Test.MyClass();
c.s = new Test.SmallStruct();
c.s.e = Test.MyEnum.enum3;
dict.Add("key2", c);
@out = new Ice.OutputStream(communicator);
Test.StringMyClassDHelper.write(@out, dict);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Dictionary <string, Test.MyClass> dict2 = Test.StringMyClassDHelper.read(@in);
@in.readPendingObjects();
test(dict2.Count == dict.Count);
test(dict2["key1"].s.e == Test.MyEnum.enum2);
test(dict2["key2"].s.e == Test.MyEnum.enum3);
}
{
bool[] arr =
{
true,
false,
true,
false
};
@out = new Ice.OutputStream(communicator);
List <bool> l = new List <bool>(arr);
Test.BoolListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <bool> l2 = Test.BoolListHelper.read(@in);
test(Compare(l, l2));
}
{
byte[] arr =
{
(byte)0x01,
(byte)0x11,
(byte)0x12,
(byte)0x22
};
@out = new Ice.OutputStream(communicator);
List <byte> l = new List <byte>(arr);
Test.ByteListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <byte> l2 = Test.ByteListHelper.read(@in);
test(Compare(l2, l));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
List <Test.MyEnum> l = new List <Test.MyEnum>(arr);
Test.MyEnumListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <Test.MyEnum> l2 = Test.MyEnumListHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
List <Test.SmallStruct> l = new List <Test.SmallStruct>(smallStructArray);
Test.SmallStructListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <Test.SmallStruct> l2 = Test.SmallStructListHelper.read(@in);
test(l2.Count == l.Count);
for (int i = 0; i < l2.Count; ++i)
{
test(l2[i].Equals(smallStructArray[i]));
}
}
{
@out = new Ice.OutputStream(communicator);
List <Test.MyClass> l = new List <Test.MyClass>(myClassArray);
Test.MyClassListHelper.write(@out, l);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <Test.MyClass> l2 = Test.MyClassListHelper.read(@in);
@in.readPendingObjects();
test(l2.Count == l.Count);
for (int i = 0; i < l2.Count; ++i)
{
test(l2[i] != null);
test(l2[i].c == l2[i]);
test(l2[i].o == l2[i]);
test(l2[i].s.e == Test.MyEnum.enum2);
test(Compare(l2[i].seq1, l[i].seq1));
test(Compare(l2[i].seq2, l[i].seq2));
test(Compare(l2[i].seq3, l[i].seq3));
test(Compare(l2[i].seq4, l[i].seq4));
test(Compare(l2[i].seq5, l[i].seq5));
test(Compare(l2[i].seq6, l[i].seq6));
test(Compare(l2[i].seq7, l[i].seq7));
test(Compare(l2[i].seq8, l[i].seq8));
test(Compare(l2[i].seq9, l[i].seq9));
test(l2[i].d["hi"].Equals(l2[i]));
}
}
{
Test.MyClassPrx[] arr = new Test.MyClassPrx[2];
arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
@out = new Ice.OutputStream(communicator);
List <Test.MyClassPrx> l = new List <Test.MyClassPrx>(arr);
Test.MyClassProxyListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <Test.MyClassPrx> l2 = Test.MyClassProxyListHelper.read(@in);
test(Compare(l2, l));
}
{
short[] arr =
{
(short)0x01,
(short)0x11,
(short)0x12,
(short)0x22
};
@out = new Ice.OutputStream(communicator);
LinkedList <short> l = new LinkedList <short>(arr);
Test.ShortLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList <short> l2 = Test.ShortLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
int[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
LinkedList <int> l = new LinkedList <int>(arr);
Test.IntLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList <int> l2 = Test.IntLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
LinkedList <Test.MyEnum> l = new LinkedList <Test.MyEnum>(arr);
Test.MyEnumLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList <Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
LinkedList <Test.SmallStruct> l = new LinkedList <Test.SmallStruct>(smallStructArray);
Test.SmallStructLinkedListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
LinkedList <Test.SmallStruct> l2 = Test.SmallStructLinkedListHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator <Test.SmallStruct> e = l.GetEnumerator();
IEnumerator <Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
long[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Stack <long> l = new Stack <long>(arr);
Test.LongStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack <long> l2 = Test.LongStackHelper.read(@in);
test(Compare(l2, l));
}
{
float[] arr =
{
(float)1,
(float)2,
(float)3,
(float)4
};
@out = new Ice.OutputStream(communicator);
Stack <float> l = new Stack <float>(arr);
Test.FloatStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack <float> l2 = Test.FloatStackHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
Stack <Test.SmallStruct> l = new Stack <Test.SmallStruct>(smallStructArray);
Test.SmallStructStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack <Test.SmallStruct> l2 = Test.SmallStructStackHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator <Test.SmallStruct> e = l.GetEnumerator();
IEnumerator <Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
Test.MyClassPrx[] arr = new Test.MyClassPrx[2];
arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero"));
arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one"));
@out = new Ice.OutputStream(communicator);
Stack <Test.MyClassPrx> l = new Stack <Test.MyClassPrx>(arr);
Test.MyClassProxyStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack <Test.MyClassPrx> l2 = Test.MyClassProxyStackHelper.read(@in);
test(Compare(l2, l));
}
{
double[] arr =
{
(double)1,
(double)2,
(double)3,
(double)4
};
@out = new Ice.OutputStream(communicator);
Queue <double> l = new Queue <double>(arr);
Test.DoubleQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue <double> l2 = Test.DoubleQueueHelper.read(@in);
test(Compare(l2, l));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
@out = new Ice.OutputStream(communicator);
Queue <string> l = new Queue <string>(arr);
Test.StringQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue <string> l2 = Test.StringQueueHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
Queue <Test.SmallStruct> l = new Queue <Test.SmallStruct>(smallStructArray);
Test.SmallStructQueueHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Queue <Test.SmallStruct> l2 = Test.SmallStructQueueHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator <Test.SmallStruct> e = l.GetEnumerator();
IEnumerator <Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
bool[] arr =
{
true,
false,
true,
false
};
@out = new Ice.OutputStream(communicator);
Test.BoolCollection l = new Test.BoolCollection(arr);
Test.BoolCollectionHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.BoolCollection l2 = Test.BoolCollectionHelper.read(@in);
test(Compare(l, l2));
}
{
int[] arr =
{
0x01,
0x11,
0x12,
0x22
};
@out = new Ice.OutputStream(communicator);
Test.IntCollection l = new Test.IntCollection(arr);
Test.IntCollectionHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.IntCollection l2 = Test.IntCollectionHelper.read(@in);
test(Compare(l2, l));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
@out = new Ice.OutputStream(communicator);
Test.StringCollection l = new Test.StringCollection(arr);
Test.StringCollectionHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.StringCollection l2 = Test.StringCollectionHelper.read(@in);
test(Compare(l2, l));
}
{
Test.MyEnum[] arr =
{
Test.MyEnum.enum3,
Test.MyEnum.enum2,
Test.MyEnum.enum1,
Test.MyEnum.enum2
};
@out = new Ice.OutputStream(communicator);
Test.MyEnumCollection l = new Test.MyEnumCollection(arr);
Test.MyEnumCollectionHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyEnumCollection l2 = Test.MyEnumCollectionHelper.read(@in);
test(Compare(l2, l));
}
{
@out = new Ice.OutputStream(communicator);
Test.SmallStructCollection l = new Test.SmallStructCollection(smallStructArray);
Test.SmallStructCollectionHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.SmallStructCollection l2 = Test.SmallStructCollectionHelper.read(@in);
test(l2.Count == l.Count);
IEnumerator <Test.SmallStruct> e = l.GetEnumerator();
IEnumerator <Test.SmallStruct> e2 = l2.GetEnumerator();
while (e.MoveNext() && e2.MoveNext())
{
test(e.Current.Equals(e2.Current));
}
}
{
@out = new Ice.OutputStream(communicator);
Test.MyClassCollection l = new Test.MyClassCollection(myClassArray);
Test.MyClassCollectionHelper.write(@out, l);
@out.writePendingObjects();
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.MyClassCollection l2 = Test.MyClassCollectionHelper.read(@in);
@in.readPendingObjects();
test(l2.Count == l.Count);
for (int i = 0; i < l2.Count; ++i)
{
test(l2[i] != null);
test(l2[i].c == l2[i]);
test(l2[i].o == l2[i]);
test(l2[i].s.e == Test.MyEnum.enum2);
test(Compare(l2[i].seq1, l[i].seq1));
test(Compare(l2[i].seq2, l[i].seq2));
test(Compare(l2[i].seq3, l[i].seq3));
test(Compare(l2[i].seq4, l[i].seq4));
test(Compare(l2[i].seq5, l[i].seq5));
test(Compare(l2[i].seq6, l[i].seq6));
test(Compare(l2[i].seq7, l[i].seq7));
test(Compare(l2[i].seq8, l[i].seq8));
test(Compare(l2[i].seq9, l[i].seq9));
test(l2[i].d["hi"].Equals(l2[i]));
}
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
List <string[]> l = new List <string[]>(arrS);
Test.StringSListHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
List <string[]> l2 = Test.StringSListHelper.read(@in);
test(Compare(l2, l));
}
{
string[] arr =
{
"string1",
"string2",
"string3",
"string4"
};
string[][] arrS =
{
arr,
new string[0],
arr
};
@out = new Ice.OutputStream(communicator);
Stack <string[]> l = new Stack <string[]>(arrS);
Test.StringSStackHelper.write(@out, l);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Stack <string[]> l2 = Test.StringSStackHelper.read(@in);
test(Compare(l2, l));
}
#if !SILVERLIGHT
{
#if COMPACT
SortedList <string, string> dict = new SortedList <string, string>();
#else
SortedDictionary <string, string> dict = new SortedDictionary <string, string>();
#endif
dict.Add("key1", "value1");
dict.Add("key2", "value2");
@out = new Ice.OutputStream(communicator);
Test.SortedStringStringDHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
IDictionary <string, string> dict2 = Test.SortedStringStringDHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
{
Test.StringIntDCollection dict = new Test.StringIntDCollection();
dict.Add("key1", 1);
dict.Add("key2", 2);
@out = new Ice.OutputStream(communicator);
Test.StringIntDCollectionHelper.write(@out, dict);
byte[] data = @out.finished();
@in = new Ice.InputStream(communicator, data);
Test.StringIntDCollection dict2 = Test.StringIntDCollectionHelper.read(@in);
test(Ice.CollectionComparer.Equals(dict2, dict));
}
#endif
WriteLine("ok");
#if !SILVERLIGHT
return(0);
#endif
}
internal static void twowaysAMI(Ice.Communicator communicator, Test.MyClassPrx p)
{
{
Dictionary <int, int> i = new Dictionary <int, int>();
i[0] = 1;
i[1] = 0;
Callback cb = new Callback();
p.begin_opNV(i, null, cb.opNVI, i);
cb.check();
}
{
Dictionary <string, string> i = new Dictionary <string, string>();
i["a"] = "b";
i["b"] = "a";
Callback cb = new Callback();
p.begin_opNR(i, null, cb.opNRI, i);
cb.check();
}
{
Dictionary <string, Dictionary <int, int> > i = new Dictionary <string, Dictionary <int, int> >();
Dictionary <int, int> id = new Dictionary <int, int>();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
Callback cb = new Callback();
p.begin_opNDV(i, null, cb.opNDVI, i);
cb.check();
}
{
Dictionary <string, Dictionary <string, string> > i = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, string> id = new Dictionary <string, string>();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
Callback cb = new Callback();
p.begin_opNDR(i, null, cb.opNDRI, i);
cb.check();
}
{
int[] ii = new int[] { 1, 2 };
Dictionary <string, int[]> i = new Dictionary <string, int[]>();
i["a"] = ii;
i["b"] = ii;
Callback cb = new Callback();
p.begin_opNDAIS(i, null, cb.opNDAISI, i);
cb.check();
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
Dictionary <string, List <int> > i = new Dictionary <string, List <int> >();
i["a"] = ii;
i["b"] = ii;
Callback cb = new Callback();
p.begin_opNDGIS(i, null, cb.opNDGISI, i);
cb.check();
}
{
string[] ii = new string[] { "a", "b" };
Dictionary <string, string[]> i = new Dictionary <string, string[]>();
i["a"] = ii;
i["b"] = ii;
Callback cb = new Callback();
p.begin_opNDASS(i, null, cb.opNDASSI, i);
cb.check();
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
Dictionary <string, List <string> > i = new Dictionary <string, List <string> >();
i["a"] = ii;
i["b"] = ii;
Callback cb = new Callback();
p.begin_opNDGSS(i, null, cb.opNDGSSI, i);
cb.check();
}
}
internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p)
{
{
Dictionary <int, int> i = new Dictionary <int, int>();
i[0] = 1;
i[1] = 0;
Dictionary <int, int> o;
Dictionary <int, int> r;
r = p.opNV(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Dictionary <string, string> i = new Dictionary <string, string>();
i["a"] = "b";
i["b"] = "a";
Dictionary <string, string> o;
Dictionary <string, string> r;
r = p.opNR(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Dictionary <string, Dictionary <int, int> > i = new Dictionary <string, Dictionary <int, int> >();
Dictionary <int, int> id = new Dictionary <int, int>();
id[0] = 1;
id[1] = 0;
i["a"] = id;
i["b"] = id;
Dictionary <string, Dictionary <int, int> > o;
Dictionary <string, Dictionary <int, int> > r;
r = p.opNDV(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
Dictionary <string, Dictionary <string, string> > i = new Dictionary <string, Dictionary <string, string> >();
Dictionary <string, string> id = new Dictionary <string, string>();
id["a"] = "b";
id["b"] = "a";
i["a"] = id;
i["b"] = id;
Dictionary <string, Dictionary <string, string> > o;
Dictionary <string, Dictionary <string, string> > r;
r = p.opNDR(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
int[] ii = new int[] { 1, 2 };
Dictionary <string, int[]> i = new Dictionary <string, int[]>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, int[]> o;
Dictionary <string, int[]> r;
r = p.opNDAIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
List <int> ii = new List <int>();
ii.Add(1);
ii.Add(2);
Dictionary <string, List <int> > i = new Dictionary <string, List <int> >();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, List <int> > o;
Dictionary <string, List <int> > r;
r = p.opNDGIS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
string[] ii = new string[] { "a", "b" };
Dictionary <string, string[]> i = new Dictionary <string, string[]>();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, string[]> o;
Dictionary <string, string[]> r;
r = p.opNDASS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
{
List <string> ii = new List <string>();
ii.Add("a");
ii.Add("b");
Dictionary <string, List <string> > i = new Dictionary <string, List <string> >();
i["a"] = ii;
i["b"] = ii;
Dictionary <string, List <string> > o;
Dictionary <string, List <string> > r;
r = p.opNDGSS(i, out o);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
}
}
