public Serialize.Struct opSerialStructCSharp(Serialize.Struct i, out Serialize.Struct o,
Ice.Current current)
{
o = i;
return(i);
}
opSerialStructCSharpAsync(Serialize.Struct i, Ice.Current current)
{
return(Task.FromResult(new Test.MyClass_OpSerialStructCSharpResult(i, i)));
}
public (Serialize.Struct, Serialize.Struct) opSerialStructCSharp(Serialize.Struct i, Current current) => (i, i);
opSerialStructCSharpAsync(Serialize.Struct i, Current current) => Task.FromResult(new Test.IMyClass.OpSerialStructCSharpReturnValue(i, i));
internal static void twowaysAMI(Ice.Communicator communicator, Test.IMyClassPrx p)
{
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToArray();
var r = p.opAByteSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToList();
var r = p.opLByteSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var r = p.opKByteSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var r = p.opQByteSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var r = p.opSByteSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray();
var r = p.opABoolSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToList();
var r = p.opLBoolSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var r = p.opKBoolSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var r = p.opQBoolSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var r = p.opSBoolSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToArray();
var r = p.opAShortSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToList();
var r = p.opLShortSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var r = p.opKShortSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var r = p.opQShortSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var r = p.opSShortSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToArray();
var r = p.opAIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToList();
var r = p.opLIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <int>(Enumerable.Range(0, Length).ToArray());
var r = p.opKIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <int>(Enumerable.Range(0, Length).ToArray());
var r = p.opQIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <int>(Enumerable.Range(0, Length).ToArray());
var r = p.opSIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToArray();
var r = p.opALongSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToList();
var r = p.opLLongSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var r = p.opKLongSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var r = p.opQLongSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var r = p.opSLongSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToArray();
var r = p.opAFloatSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToList();
var r = p.opLFloatSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var r = p.opKFloatSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var r = p.opQFloatSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var r = p.opSFloatSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToArray();
var r = p.opADoubleSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToList();
var r = p.opLDoubleSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var r = p.opKDoubleSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var r = p.opQDoubleSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var r = p.opSDoubleSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray();
var r = p.opAStringSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToList();
var r = p.opLStringSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var r = p.opKStringSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var r = p.opQStringSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var r = p.opSStringSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as AnyClass).ToArray();
var r = p.opAObjectSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as AnyClass).ToList <AnyClass?>();
var r = p.opLObjectSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray();
var r = p.opAObjectPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToList <IObjectPrx?>();
var r = p.opLObjectPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <IObjectPrx?>(Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray());
var r = p.opQObjectPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <IObjectPrx?>(Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray());
var r = p.opSObjectPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray();
var r = p.opAStructSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToList();
var r = p.opLStructSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var r = p.opKStructSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var r = p.opQStructSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var r = p.opSStructSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToArray();
var r = p.opACVSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList <Test.CV?>();
var r = p.opLCVSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToArray();
var r = p.opAIPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToList <Test.IIPrx?>();
var r = p.opLIPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToArray());
var r = p.opKIPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToArray());
var r = p.opQIPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToArray());
var r = p.opSIPrxSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToArray();
var r = p.opACRSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CRComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToList <Test.CR?>();
var r = p.opLCRSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CRComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToArray();
var r = p.opAEnSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList();
var r = p.opLEnSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new LinkedList <Test.En>(Enumerable.Range(0, Length).Select(
x => (Test.En)(x % 3)).ToArray());
var r = p.opKEnSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Queue <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToArray());
var r = p.opQEnSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Stack <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToArray());
var r = p.opSEnSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Custom <int>(Enumerable.Range(0, Length).ToList());
var r = p.opCustomIntSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Custom <Test.CV?>(
Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList <Test.CV?>());
var r = p.opCustomCVSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i, new CVComparer()));
}
{
var i = new Custom <Custom <int> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <int>(Enumerable.Range(0, Length).ToList()));
}
var r = p.opCustomIntSSAsync(i).Result;
TestHelper.Assert(r.o.SequenceEqual(i));
TestHelper.Assert(r.ReturnValue.SequenceEqual(i));
}
{
var i = new Custom <Custom <Test.CV?> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <Test.CV?>(Enumerable.Range(0, Length).Select(
x => new Test.CV(x)).ToList <Test.CV?>()));
}
var r = p.opCustomCVSSAsync(i).Result;
for (int c = 0; c < Length; ++c)
{
TestHelper.Assert(r.o[c].SequenceEqual(i[c], new CVComparer()));
TestHelper.Assert(r.ReturnValue[c].SequenceEqual(i[c], new CVComparer()));
}
}
{
var i = new Serialize.Small();
i.i = 99;
(Serialize.Small ReturnValue, Serialize.Small o) = p.opSerialSmallCSharpAsync(i).Result;
TestHelper.Assert(o.i == 99);
TestHelper.Assert(ReturnValue.i == 99);
}
{
var 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;
i.d11 = 11.0;
i.s1 = Serialize.Large.LargeString;
(Serialize.Large ReturnValue, Serialize.Large o) = p.opSerialLargeCSharpAsync(i).Result;
TestHelper.Assert(o.d1 == 1.0);
TestHelper.Assert(o.d2 == 2.0);
TestHelper.Assert(o.d3 == 3.0);
TestHelper.Assert(o.d4 == 4.0);
TestHelper.Assert(o.d5 == 5.0);
TestHelper.Assert(o.d6 == 6.0);
TestHelper.Assert(o.d7 == 7.0);
TestHelper.Assert(o.d8 == 8.0);
TestHelper.Assert(o.d9 == 9.0);
TestHelper.Assert(o.d10 == 10.0);
TestHelper.Assert(o.d11 == 11.0);
TestHelper.Assert(o.s1 == Serialize.Large.LargeString);
TestHelper.Assert(ReturnValue.d1 == 1.0);
TestHelper.Assert(ReturnValue.d2 == 2.0);
TestHelper.Assert(ReturnValue.d3 == 3.0);
TestHelper.Assert(ReturnValue.d4 == 4.0);
TestHelper.Assert(ReturnValue.d5 == 5.0);
TestHelper.Assert(ReturnValue.d6 == 6.0);
TestHelper.Assert(ReturnValue.d7 == 7.0);
TestHelper.Assert(ReturnValue.d8 == 8.0);
TestHelper.Assert(ReturnValue.d9 == 9.0);
TestHelper.Assert(ReturnValue.d10 == 10.0);
TestHelper.Assert(ReturnValue.d11 == 11.0);
TestHelper.Assert(ReturnValue.s1 == Serialize.Large.LargeString);
}
{
var i = new Serialize.Struct();
i.o = null;
i.o2 = i;
i.s = null;
i.s2 = "Hello";
(Serialize.Struct ReturnValue, Serialize.Struct o) = p.opSerialStructCSharpAsync(i).Result;
TestHelper.Assert(o.o == null);
TestHelper.Assert(o.o2 == o);
TestHelper.Assert(o.s == null);
TestHelper.Assert(o.s2 == "Hello");
TestHelper.Assert(ReturnValue.o == null);
TestHelper.Assert(ReturnValue.o2 == ReturnValue);
TestHelper.Assert(ReturnValue.s == null);
TestHelper.Assert(ReturnValue.s2 == "Hello");
}
}
opSerialStructCSharpAsync(Serialize.Struct i, Current current)
{
return(Task.FromResult((i, i)));
}
internal static void twoways(Communicator communicator, Test.IMyClassPrx p)
{
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToArray();
var(r, o) = p.opAByteS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToList();
var(r, o) = p.opLByteS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var(r, o) = p.opKByteS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var(r, o) = p.opQByteS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
var(r, o) = p.opSByteS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray();
var(r, o) = p.opABoolS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToList();
var(r, o) = p.opLBoolS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var(r, o) = p.opKBoolS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var(r, o) = p.opQBoolS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
var(r, o) = p.opSBoolS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToArray();
var(r, o) = p.opAShortS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToList();
var(r, o) = p.opLShortS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var(r, o) = p.opKShortS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var(r, o) = p.opQShortS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
var(r, o) = p.opSShortS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToArray();
var(r, o) = p.opAIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToList();
var(r, o) = p.opLIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <int>(Enumerable.Range(0, Length).ToArray());
var(r, o) = p.opKIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <int>(Enumerable.Range(0, Length).ToArray());
var(r, o) = p.opQIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <int>(Enumerable.Range(0, Length).ToArray());
var(r, o) = p.opSIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToArray();
var(r, o) = p.opALongS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToList();
var(r, o) = p.opLLongS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var(r, o) = p.opKLongS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var(r, o) = p.opQLongS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
var(r, o) = p.opSLongS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToArray();
var(r, o) = p.opAFloatS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToList();
var(r, o) = p.opLFloatS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var(r, o) = p.opKFloatS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var(r, o) = p.opQFloatS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
var(r, o) = p.opSFloatS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToArray();
var(r, o) = p.opADoubleS(i);
TestHelper.Assert(o.SequenceEqual(i));
TestHelper.Assert(r.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToList();
var(r, o) = p.opLDoubleS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var(r, o) = p.opKDoubleS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var(r, o) = p.opQDoubleS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
var(r, o) = p.opSDoubleS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray();
var(r, o) = p.opAStringS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToList();
var(r, o) = p.opLStringS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var(r, o) = p.opKStringS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var(r, o) = p.opQStringS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
var(r, o) = p.opSStringS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as AnyClass).ToArray();
var(r, o) = p.opAObjectS(i);
TestHelper.Assert(r.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as AnyClass).ToList <AnyClass?>();
var(r, o) = p.opLObjectS(i);
TestHelper.Assert(r.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray();
var(r, o) = p.opAObjectPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToList <IObjectPrx?>();
var(r, o) = p.opLObjectPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <IObjectPrx?>(Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray());
var(r, o) = p.opKObjectPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <IObjectPrx?>(Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray());
var(r, o) = p.opQObjectPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <IObjectPrx?>(Enumerable.Range(0, Length).Select(
x => IObjectPrx.Parse(x.ToString(), communicator)).ToArray());
var(r, o) = p.opSObjectPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray();
var(r, o) = p.opAStructS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToList();
var(r, o) = p.opLStructS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var(r, o) = p.opKStructS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var(r, o) = p.opQStructS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
var(r, o) = p.opSStructS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToArray();
var(r, o) = p.opAStructSD(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList();
var(r, o) = p.opLStructSD(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
var(r, o) = p.opKStructSD(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
var(r, o) = p.opQStructSD(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
var(r, o) = p.opSStructSD(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToArray();
var(r, o) = p.opACVS(i);
TestHelper.Assert(r.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList <Test.CV?>();
var(r, o) = p.opLCVS(i);
TestHelper.Assert(r.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToArray();
var(r, o) = p.opACRS(i);
TestHelper.Assert(r.SequenceEqual(i, new CRComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToList <Test.CR?>();
var(r, o) = p.opLCRS(i);
TestHelper.Assert(r.SequenceEqual(i, new CRComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToArray();
var(r, o) = p.opAEnS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList();
var(r, o) = p.opLEnS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
var(r, o) = p.opKEnS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
var(r, o) = p.opQEnS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
var(r, o) = p.opSEnS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToArray();
var(r, o) = p.opAIPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToList <Test.IIPrx?>();
var(r, o) = p.opLIPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToList());
var(r, o) = p.opKIPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Queue <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToList());
var(r, o) = p.opQIPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Stack <Test.IIPrx?>(Enumerable.Range(0, Length).Select(
x => Test.IIPrx.Parse(x.ToString(), communicator)).ToList());
var(r, o) = p.opSIPrxS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Custom <int>(Enumerable.Range(0, Length).ToList());
var(r, o) = p.opCustomIntS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Custom <Test.CV?>(
Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList <Test.CV?>());
var(r, o) = p.opCustomCVS(i);
TestHelper.Assert(r.SequenceEqual(i, new CVComparer()));
TestHelper.Assert(o.SequenceEqual(i, new CVComparer()));
}
{
var i = new Custom <Custom <int> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <int>(Enumerable.Range(0, Length).ToList()));
}
var(r, o) = p.opCustomIntSS(i);
TestHelper.Assert(r.SequenceEqual(i));
TestHelper.Assert(o.SequenceEqual(i));
}
{
var i = new Custom <Custom <Test.CV?> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <Test.CV?>(Enumerable.Range(0, Length).Select(
x => new Test.CV(x)).ToList <Test.CV?>()));
}
var(r, o) = p.opCustomCVSS(i);
for (int c = 0; c < Length; ++c)
{
TestHelper.Assert(r[c].SequenceEqual(i[c], new CVComparer()));
TestHelper.Assert(o[c].SequenceEqual(i[c], new CVComparer()));
}
}
{
Serialize.Small?i = null;
Serialize.Small?o;
Serialize.Small?r;
(r, o) = p.opSerialSmallCSharp(i);
TestHelper.Assert(o == null);
TestHelper.Assert(r == null);
}
{
Serialize.Small i = new Serialize.Small();
i.i = 99;
Serialize.Small?o;
Serialize.Small?r;
try
{
(r, o) = p.opSerialSmallCSharp(i);
TestHelper.Assert(o !.i == 99);
TestHelper.Assert(r !.i == 99);
}
catch (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;
i.d11 = 11.0;
i.s1 = Serialize.Large.LargeString;
Serialize.Large?o;
Serialize.Large?r;
try
{
(r, o) = p.opSerialLargeCSharp(i);
TestHelper.Assert(r != null && o != null);
TestHelper.Assert(o.d1 == 1.0);
TestHelper.Assert(o.d2 == 2.0);
TestHelper.Assert(o.d3 == 3.0);
TestHelper.Assert(o.d4 == 4.0);
TestHelper.Assert(o.d5 == 5.0);
TestHelper.Assert(o.d6 == 6.0);
TestHelper.Assert(o.d7 == 7.0);
TestHelper.Assert(o.d8 == 8.0);
TestHelper.Assert(o.d9 == 9.0);
TestHelper.Assert(o.d10 == 10.0);
TestHelper.Assert(o.d11 == 11.0);
TestHelper.Assert(o.s1 == Serialize.Large.LargeString);
TestHelper.Assert(r.d1 == 1.0);
TestHelper.Assert(r.d2 == 2.0);
TestHelper.Assert(r.d3 == 3.0);
TestHelper.Assert(r.d4 == 4.0);
TestHelper.Assert(r.d5 == 5.0);
TestHelper.Assert(r.d6 == 6.0);
TestHelper.Assert(r.d7 == 7.0);
TestHelper.Assert(r.d8 == 8.0);
TestHelper.Assert(r.d9 == 9.0);
TestHelper.Assert(r.d10 == 10.0);
TestHelper.Assert(r.d11 == 11.0);
TestHelper.Assert(r.s1 == Serialize.Large.LargeString);
}
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, o) = p.opSerialStructCSharp(i);
TestHelper.Assert(o != null && r != null);
TestHelper.Assert(o.o == null);
TestHelper.Assert(o.o2 != null);
TestHelper.Assert(((Serialize.Struct)(o.o2)).o == null);
TestHelper.Assert(((Serialize.Struct)(o.o2)).o2 == o.o2);
TestHelper.Assert(o.s == null);
TestHelper.Assert(o.s2 !.Equals("Hello"));
TestHelper.Assert(r.o == null);
TestHelper.Assert(r.o2 != null);
TestHelper.Assert(((Serialize.Struct)(r.o2)).o == null);
TestHelper.Assert(((Serialize.Struct)(r.o2)).o2 == r.o2);
TestHelper.Assert(r.s == null);
TestHelper.Assert(r.s2 !.Equals("Hello"));
}
catch (OperationNotExistException)
{
// OK, talking to non-C# server.
}
}
}
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 Test.CV[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new Test.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 (Test.CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((Test.CV)eo.Current).i);
test(obj.i == ((Test.CV)er.Current).i);
}
}
{
var i = new List <Ice.Value>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.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 (Test.CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((Test.CV)eo.Current).i);
test(obj.i == ((Test.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));
}
{
var i = new Test.S[_length];
for (int c = 0; c < _length; ++c)
{
i[c].i = c;
}
Test.S[] o;
Test.S[] r;
r = p.opAStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new List <Test.S>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.S(c));
}
List <Test.S> o;
List <Test.S> r;
r = p.opLStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new LinkedList <Test.S>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(new Test.S(c));
}
LinkedList <Test.S> o;
LinkedList <Test.S> r;
r = p.opKStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Queue <Test.S>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(new Test.S(c));
}
Queue <Test.S> o;
Queue <Test.S> r;
r = p.opQStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Stack <Test.S>();
for (int c = 0; c < _length; ++c)
{
i.Push(new Test.S(c));
}
Stack <Test.S> o;
Stack <Test.S> r;
r = p.opSStructS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Test.SD[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new Test.SD(c);
}
Test.SD[] o;
Test.SD[] r;
r = p.opAStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new List <Test.SD>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.SD(c));
}
List <Test.SD> o;
List <Test.SD> r;
r = p.opLStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new LinkedList <Test.SD>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(new Test.SD(c));
}
LinkedList <Test.SD> o;
LinkedList <Test.SD> r;
r = p.opKStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Queue <Test.SD>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(new Test.SD(c));
}
Queue <Test.SD> o;
Queue <Test.SD> r;
r = p.opQStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Stack <Test.SD>();
for (int c = 0; c < _length; ++c)
{
i.Push(new Test.SD(c));
}
Stack <Test.SD> o;
Stack <Test.SD> r;
r = p.opSStructSD(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Test.CV[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new Test.CV(c);
}
Test.CV[] o;
Test.CV[] r;
r = p.opACVS(i, out o);
System.Collections.IEnumerator eo = o.GetEnumerator();
System.Collections.IEnumerator er = r.GetEnumerator();
foreach (Test.CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == ((Test.CV)eo.Current).i);
test(obj.i == ((Test.CV)er.Current).i);
}
}
{
var i = new List <Test.CV>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.CV(c));
}
List <Test.CV> o;
List <Test.CV> r;
r = p.opLCVS(i, out o);
IEnumerator <Test.CV> eo = o.GetEnumerator();
IEnumerator <Test.CV> er = r.GetEnumerator();
foreach (Test.CV obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.i == eo.Current.i);
test(obj.i == er.Current.i);
}
}
{
var i = new Test.CR[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = new Test.CR(new Test.CV(c));
}
Test.CR[] o;
Test.CR[] r;
r = p.opACRS(i, out o);
System.Collections.IEnumerator eo = o.GetEnumerator();
System.Collections.IEnumerator er = r.GetEnumerator();
foreach (Test.CR obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.v.i == ((Test.CR)eo.Current).v.i);
test(obj.v.i == ((Test.CR)er.Current).v.i);
}
}
{
var i = new List <Test.CR>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.CR(new Test.CV(c)));
}
List <Test.CR> o;
List <Test.CR> r;
r = p.opLCRS(i, out o);
IEnumerator <Test.CR> eo = o.GetEnumerator();
IEnumerator <Test.CR> er = r.GetEnumerator();
foreach (Test.CR obj in i)
{
eo.MoveNext();
er.MoveNext();
test(obj.v.i == eo.Current.v.i);
test(obj.v.i == er.Current.v.i);
}
}
{
var i = new Test.En[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = (Test.En)(c % 3);
}
Test.En[] o;
Test.En[] r;
r = p.opAEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new List <Test.En>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add((Test.En)(c % 3));
}
List <Test.En> o;
List <Test.En> r;
r = p.opLEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new LinkedList <Test.En>();
for (int c = 0; c < _length; ++c)
{
i.AddLast((Test.En)(c % 3));
}
LinkedList <Test.En> o;
LinkedList <Test.En> r;
r = p.opKEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Queue <Test.En>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue((Test.En)(c % 3));
}
Queue <Test.En> o;
Queue <Test.En> r;
r = p.opQEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
var i = new Stack <Test.En>();
for (int c = 0; c < _length; ++c)
{
i.Push((Test.En)(c % 3));
}
Stack <Test.En> o;
Stack <Test.En> r;
r = p.opSEnS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Test.IPrx[] i = new Test.IPrx[_length];
for (int c = 0; c < _length; ++c)
{
i[c] = Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()));
}
Test.IPrx[] o;
Test.IPrx[] r;
r = p.opAIPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
List <Test.IPrx> i = new List <Test.IPrx>(_length);
for (int c = 0; c < _length; ++c)
{
i.Add(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
List <Test.IPrx> o;
List <Test.IPrx> r;
r = p.opLIPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
LinkedList <Test.IPrx> i = new LinkedList <Test.IPrx>();
for (int c = 0; c < _length; ++c)
{
i.AddLast(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
LinkedList <Test.IPrx> o;
LinkedList <Test.IPrx> r;
r = p.opKIPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Queue <Test.IPrx> i = new Queue <Test.IPrx>();
for (int c = 0; c < _length; ++c)
{
i.Enqueue(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
Queue <Test.IPrx> o;
Queue <Test.IPrx> r;
r = p.opQIPrxS(i, out o);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
}
{
Stack <Test.IPrx> i = new Stack <Test.IPrx>();
for (int c = 0; c < _length; ++c)
{
i.Push(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
}
Stack <Test.IPrx> o;
Stack <Test.IPrx> r;
r = p.opSIPrxS(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));
}
{
var i = new Custom <Test.CV>();
for (int c = 0; c < _length; ++c)
{
i.Add(new Test.CV(c));
}
i.Add(null);
Custom <Test.CV> o;
Custom <Test.CV> r;
r = p.opCustomCVS(i, out o);
var eo = o.GetEnumerator();
var er = r.GetEnumerator();
foreach (Test.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));
}
{
var i = new Custom <Custom <Test.CV> >();
for (int c = 0; c < _length; ++c)
{
var inner = new Custom <Test.CV>();
for (int j = 0; j < c; ++j)
{
inner.Add(new Test.CV(j));
}
i.Add(inner);
}
Custom <Custom <Test.CV> > o;
Custom <Custom <Test.CV> > r;
r = p.opCustomCVSS(i, out o);
var eo = o.GetEnumerator();
var er = r.GetEnumerator();
foreach (Custom <Test.CV> s in i)
{
eo.MoveNext();
er.MoveNext();
IEnumerator <Test.CV> io = eo.Current.GetEnumerator();
IEnumerator <Test.CV> ir = er.Current.GetEnumerator();
foreach (Test.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 twoways(Communicator communicator, Test.MyClassPrx p)
{
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToArray();
byte[] o;
var r = p.opAByteS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (byte)x).ToList();
List <byte> o;
var r = p.opLByteS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
LinkedList <byte> o;
var r = p.opKByteS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
Queue <byte> o;
var r = p.opQByteS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <byte>(Enumerable.Range(0, Length).Select(x => (byte)x).ToArray());
Stack <byte> o;
var r = p.opSByteS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray();
bool[] o;
var r = p.opABoolS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToList();
List <bool> o;
var r = p.opLBoolS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
LinkedList <bool> o;
var r = p.opKBoolS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
Queue <bool> o;
var r = p.opQBoolS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <bool>(Enumerable.Range(0, Length).Select(x => x % 1 == 1).ToArray());
Stack <bool> o;
var r = p.opSBoolS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToArray();
short[] o;
var r = p.opAShortS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (short)x).ToList();
List <short> o;
var r = p.opLShortS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
LinkedList <short> o;
var r = p.opKShortS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
Queue <short> o;
var r = p.opQShortS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <short>(Enumerable.Range(0, Length).Select(x => (short)x).ToArray());
Stack <short> o;
var r = p.opSShortS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToArray();
int[] o;
var r = p.opAIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).ToList();
List <int> o;
var r = p.opLIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <int>(Enumerable.Range(0, Length).ToArray());
LinkedList <int> o;
var r = p.opKIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <int>(Enumerable.Range(0, Length).ToArray());
Queue <int> o;
var r = p.opQIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <int>(Enumerable.Range(0, Length).ToArray());
Stack <int> o;
var r = p.opSIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToArray();
long[] o;
var r = p.opALongS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (long)x).ToList();
List <long> o;
var r = p.opLLongS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
LinkedList <long> o;
var r = p.opKLongS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
Queue <long> o;
var r = p.opQLongS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <long>(Enumerable.Range(0, Length).Select(x => (long)x).ToArray());
Stack <long> o;
var r = p.opSLongS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToArray();
float[] o;
var r = p.opAFloatS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (float)x).ToList();
List <float> o;
var r = p.opLFloatS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
LinkedList <float> o;
var r = p.opKFloatS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
Queue <float> o;
var r = p.opQFloatS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <float>(Enumerable.Range(0, Length).Select(x => (float)x).ToArray());
Stack <float> o;
var r = p.opSFloatS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToArray();
double[] o;
var r = p.opADoubleS(i, out o);
test(o.SequenceEqual(i));
test(r.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (double)x).ToList();
List <double> o;
var r = p.opLDoubleS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
LinkedList <double> o;
var r = p.opKDoubleS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
Queue <double> o;
var r = p.opQDoubleS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <double>(Enumerable.Range(0, Length).Select(x => (double)x).ToArray());
Stack <double> o;
var r = p.opSDoubleS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray();
string[] o;
var r = p.opAStringS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => x.ToString()).ToList();
List <string> o;
var r = p.opLStringS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
LinkedList <string> o;
var r = p.opKStringS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
Queue <string> o;
var r = p.opQStringS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <string>(Enumerable.Range(0, Length).Select(x => x.ToString()).ToArray());
Stack <string> o;
var r = p.opSStringS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as Value).ToArray();
Value[] o;
var r = p.opAObjectS(i, out o);
test(r.SequenceEqual(i, new CVComparer()));
test(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x) as Value).ToList();
List <Value> o;
var r = p.opLObjectS(i, out o);
test(r.SequenceEqual(i, new CVComparer()));
test(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(
x => communicator.stringToProxy(x.ToString())).ToArray();
ObjectPrx[] o;
var r = p.opAObjectPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => communicator.stringToProxy(x.ToString())).ToList();
List <ObjectPrx> o;
var r = p.opLObjectPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <ObjectPrx>(Enumerable.Range(0, Length).Select(
x => communicator.stringToProxy(x.ToString())).ToArray());
LinkedList <ObjectPrx> o;
var r = p.opKObjectPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <ObjectPrx>(Enumerable.Range(0, Length).Select(
x => communicator.stringToProxy(x.ToString())).ToArray());
Queue <ObjectPrx> o;
var r = p.opQObjectPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <ObjectPrx>(Enumerable.Range(0, Length).Select(
x => communicator.stringToProxy(x.ToString())).ToArray());
Stack <ObjectPrx> o;
var r = p.opSObjectPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray();
Test.S[] o;
var r = p.opAStructS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToList();
List <Test.S> o;
var r = p.opLStructS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
LinkedList <Test.S> o;
var r = p.opKStructS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
Queue <Test.S> o;
var r = p.opQStructS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <Test.S>(Enumerable.Range(0, Length).Select(x => new Test.S(x)).ToArray());
Stack <Test.S> o;
var r = p.opSStructS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToArray();
Test.SD[] o;
var r = p.opAStructSD(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList();
List <Test.SD> o;
var r = p.opLStructSD(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
LinkedList <Test.SD> o;
var r = p.opKStructSD(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
Queue <Test.SD> o;
var r = p.opQStructSD(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <Test.SD>(Enumerable.Range(0, Length).Select(x => new Test.SD(x)).ToList());
Stack <Test.SD> o;
var r = p.opSStructSD(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToArray();
Test.CV[] o;
var r = p.opACVS(i, out o);
test(r.SequenceEqual(i, new CVComparer()));
test(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList();
List <Test.CV> o;
var r = p.opLCVS(i, out o);
test(r.SequenceEqual(i, new CVComparer()));
test(o.SequenceEqual(i, new CVComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToArray();
Test.CR[] o;
var r = p.opACRS(i, out o);
test(r.SequenceEqual(i, new CRComparer()));
test(o.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => new Test.CR(new Test.CV(x))).ToList();
List <Test.CR> o;
var r = p.opLCRS(i, out o);
test(r.SequenceEqual(i, new CRComparer()));
test(o.SequenceEqual(i, new CRComparer()));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToArray();
Test.En[] o;
var r = p.opAEnS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList();
List <Test.En> o;
var r = p.opLEnS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
LinkedList <Test.En> o;
var r = p.opKEnS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
Queue <Test.En> o;
var r = p.opQEnS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <Test.En>(Enumerable.Range(0, Length).Select(x => (Test.En)(x % 3)).ToList());
Stack <Test.En> o;
var r = p.opSEnS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(x.ToString()))).ToArray();
Test.IPrx[] o;
var r = p.opAIPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = Enumerable.Range(0, Length).Select(
x => Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(x.ToString()))).ToList();
List <Test.IPrx> o;
var r = p.opLIPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new LinkedList <Test.IPrx>(Enumerable.Range(0, Length).Select(
x => Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(x.ToString()))).ToList());
LinkedList <Test.IPrx> o;
var r = p.opKIPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Queue <Test.IPrx>(Enumerable.Range(0, Length).Select(
x => Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(x.ToString()))).ToList());
Queue <Test.IPrx> o;
var r = p.opQIPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Stack <Test.IPrx>(Enumerable.Range(0, Length).Select(
x => Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(x.ToString()))).ToList());
Stack <Test.IPrx> o;
var r = p.opSIPrxS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Custom <int>(Enumerable.Range(0, Length).ToList());
Custom <int> o;
var r = p.opCustomIntS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Custom <Test.CV>(Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList());
Custom <Test.CV> o;
var r = p.opCustomCVS(i, out o);
test(r.SequenceEqual(i, new CVComparer()));
test(o.SequenceEqual(i, new CVComparer()));
}
{
var i = new Custom <Custom <int> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <int>(Enumerable.Range(0, Length).ToList()));
}
Custom <Custom <int> > o;
var r = p.opCustomIntSS(i, out o);
test(r.SequenceEqual(i));
test(o.SequenceEqual(i));
}
{
var i = new Custom <Custom <Test.CV> >();
for (int c = 0; c < Length; ++c)
{
i.Add(new Custom <Test.CV>(Enumerable.Range(0, Length).Select(x => new Test.CV(x)).ToList()));
}
Custom <Custom <Test.CV> > o;
var r = p.opCustomCVSS(i, out o);
for (int c = 0; c < Length; ++c)
{
test(r[c].SequenceEqual(i[c], new CVComparer()));
test(o[c].SequenceEqual(i[c], new CVComparer()));
}
}
{
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.
}
}
}
opSerialStructCSharp(Serialize.Struct i, Current current) => new Test.MyClass.OpSerialStructCSharpReturnValue(i, i);
