private void Store(SimpleEnum value, int count)
{
for (var idx = 0; idx < count; idx++)
{
Store(new Item(value));
}
}
private static IObjectSet RunSODAQuery(IObjectContainer db, SimpleEnum value)
{
IQuery query = db.Query();
query.Constrain(typeof(Container));
query.Descend("_simpleEnum").Constrain(value);
return query.Execute();
}
private static void AppendQueryResults(StringBuilder builder, SimpleEnum enumValue, IEnumerable result, string queryType)
{
builder.AppendFormat("[{1}] Quering for '{0}' returned objects: \r\n", enumValue, queryType);
foreach (Container container in result)
{
builder.AppendLine("\t" + container);
}
}
public string Run(SimpleEnum enumValue, bool runIndexed)
{
Stopwatch sw = new Stopwatch();
sw.Start();
string objectsMsg = PopulateDatabase(runIndexed);
string result = CollectResults(enumValue);
sw.Stop();
CleanUp();
return "\r\n" + objectsMsg + "\r\n" + result + "\r\nin " + sw.ElapsedMilliseconds + " ms.";
}
public void ConvertTo_DestinationTypeIsNull_ThrowsArgumentNullException()
{
// Setup
const SimpleEnum enumValue = SimpleEnum.FirstValue;
var converter = new NullableEnumConverter(typeof(SimpleEnum?));
// Call
TestDelegate test = () => converter.ConvertTo(enumValue, null);
// Assert
Assert.Throws <ArgumentNullException>(test);
}
public void ConvertFrom_ValueIsStringOfDisplayName_ReturnsExpectedEnum()
{
// Setup
const string second = "<second>";
var converter = new EnumTypeConverter(typeof(SimpleEnum));
// Call
object result = converter.ConvertFrom(second);
// Assert
const SimpleEnum expectedEnumValue = SimpleEnum.SecondValue;
Assert.AreEqual(expectedEnumValue, result);
}
public void ConvertFrom_ValueIsStringOfElementName_ReturnsExpectedEnum()
{
// Setup
string third = SimpleEnum.ThirdValue.ToString();
var converter = new EnumTypeConverter(typeof(SimpleEnum));
// Call
object result = converter.ConvertFrom(third);
// Assert
const SimpleEnum expectedEnumValue = SimpleEnum.ThirdValue;
Assert.AreEqual(expectedEnumValue, result);
}
public void EnumHelper_Parse()
{
SimpleEnum expected1 = SimpleEnum.One;
SimpleEnum expected2 = SimpleEnum.Two;
SimpleEnum expected6 = SimpleEnum.Six;
var actual1 = EnumHelper.Parse <SimpleEnum>("One");
var actual2 = EnumHelper.Parse <SimpleEnum>("two");
var actual6 = EnumHelper.Parse <SimpleEnum>("6");
Assert.AreEqual(expected1, actual1);
Assert.AreNotEqual(expected2, actual2);
Assert.AreEqual(expected6, actual6);
}
private string CollectResults(SimpleEnum enumValue)
{
StringBuilder builder = new StringBuilder(1000);
using (IObjectContainer db = OpenDatabase())
{
builder.AppendFormat("========== Db4o {0} =========={1}{1}", Db4oVersion.Name, Environment.NewLine);
builder.AppendFormat("SimpleEnum instance count: {0}\r\n\r\n", db.Ext().StoredClass(typeof(SimpleEnum)).InstanceCount());
AppendQueryResults(builder, enumValue, RunSODAQuery(db, enumValue), "SODA");
AppendQueryResults(builder, enumValue, RunNativeQuery(db, enumValue), "NQ");
}
return builder.ToString();
}
public string Run(SimpleEnum enumValue, bool runIndexed)
{
Stopwatch sw = new Stopwatch();
sw.Start();
string objectsMsg = PopulateDatabase(runIndexed);
string result = CollectResults(enumValue);
sw.Stop();
CleanUp();
return("\r\n" + objectsMsg + "\r\n" + result + "\r\nin " + sw.ElapsedMilliseconds + " ms.");
}
public void ConvertTo_DestinationTypeIsString_ReturnsExpectedEnumDisplayName()
{
// Setup
const SimpleEnum enumValue = SimpleEnum.FirstValue;
var converter = new EnumTypeConverter(typeof(SimpleEnum));
// Call
object result = converter.ConvertTo(enumValue, typeof(string));
// Assert
const string expectedText = "<first>";
Assert.AreEqual(expectedText, result);
}
private string CollectResults(SimpleEnum enumValue)
{
StringBuilder builder = new StringBuilder(1000);
using (IObjectContainer db = OpenDatabase())
{
builder.AppendFormat("========== Db4o {0} =========={1}{1}", Db4oVersion.Name, Environment.NewLine);
builder.AppendFormat("SimpleEnum instance count: {0}\r\n\r\n", db.Ext().StoredClass(typeof(SimpleEnum)).InstanceCount());
AppendQueryResults(builder, enumValue, RunSODAQuery(db, enumValue), "SODA");
AppendQueryResults(builder, enumValue, RunNativeQuery(db, enumValue), "NQ");
}
return(builder.ToString());
}
private static void SerializeEnumArrayNewtonsoft()
{
var array = new SimpleEnum[4, 3];
for (var i = 0; i <= 3; i++)
{
for (var j = 0; j <= 2; j++)
{
array[i, j] = SimpleEnum.Two;
}
}
var serialized = JsonConvert.SerializeObject(array);
Console.WriteLine(serialized);
}
private void AssertCount(SimpleEnum value, int count)
{
var consistencyReport = new ConsistencyChecker(FileSession()).CheckSlotConsistency
();
if (!consistencyReport.Consistent())
{
Runtime.Err.WriteLine(consistencyReport);
throw new InvalidOperationException("Inconsistency found");
}
var query = NewQuery(typeof (Item));
query.Descend("_value").Constrain(value);
var result = query.Execute();
Assert.AreEqual(count, result.Count);
while (result.HasNext())
{
Assert.AreEqual(value, ((Item) result.Next())._value);
}
}
public static void LotsaDefaults(
bool b = true,
char c = 'a',
sbyte sb = -2,
byte by = 0xfe,
short sh = -2,
ushort ush = 0xfedc,
int i = -2,
uint ui = 0xfedcba98,
long l = -2,
ulong ul = 0xfedcba9876543210,
float f = 1.5f,
double d = 1.5,
String s = "Hello",
String sn = null,
Object o = null,
SimpleEnum e = SimpleEnum.Blue
)
{
}
private void AssertCount(SimpleEnum value, int count)
{
var consistencyReport = new ConsistencyChecker(FileSession()).CheckSlotConsistency
();
if (!consistencyReport.Consistent())
{
Runtime.Err.WriteLine(consistencyReport);
throw new InvalidOperationException("Inconsistency found");
}
var query = NewQuery(typeof(Item));
query.Descend("_value").Constrain(value);
var result = query.Execute();
Assert.AreEqual(count, result.Count);
while (result.HasNext())
{
Assert.AreEqual(value, ((Item)result.Next())._value);
}
}
static void Main(string[] args)
{
SimpleStruct tp = new SimpleStruct(2);
object ob = tp;
if (ob != null)
{
Console.WriteLine("struct is an object : " + ob);
tp = (SimpleStruct)ob;
}
SimpleEnum tp2 = SimpleEnum.a;
ob = tp2;
if (ob != null)
{
Console.WriteLine("enum is an object : " + ob);
tp2 = (SimpleEnum)ob;
}
Console.ReadKey();
}
public static void PrintEnum(SimpleEnum e)
{
switch (e)
{
case SimpleEnum.Value1:
Console.Write("Value 1 = ");
break;
case SimpleEnum.Value2:
Console.Write("Value 2 = ");
break;
case SimpleEnum.Value3:
Console.Write("Value 3 = ");
break;
default:
Console.Write("Unknown =");
break;
}
Method1(e);
}
public static void PrintEnum(SimpleEnum e)
{
switch (e)
{
case SimpleEnum.Value1:
Console.Write("Value 1 = ");
break;
case SimpleEnum.Value2:
Console.Write("Value 2 = ");
break;
case SimpleEnum.Value3:
Console.Write("Value 3 = ");
break;
default:
Console.Write("Unknown =");
break;
}
Method1(e);
}
public string BoundFuncWithEnumParametersOnCollectionOfRoutingCustomer(SimpleEnum simpleEnum, FlagsEnum flagsEnum)
{
return "BoundFuncWithEnumParameters(" + simpleEnum + "," + flagsEnum + ")";
}
public string GetEnum(SimpleEnum id)
{
ThrowIfInsideThrowsController();
return(id.ToString());
}
public C05AnyEnumTypeToSystemEnum()
{
SimpleEnum a = SimpleEnum.First;
Enum a2 = a;
}
public void EnumSimpleTest()
{
SimpleEnum simpleEnum = SimpleEnum.SimpleElementOne | SimpleEnum.SimpleElementTwo;
Assert.AreEqual(2, NuGenEnum.FlagsSetOn(simpleEnum));
}
public SimpleAttribute(SimpleEnum someValue)
{
SomeValue = someValue;
}
public static void Method1(SimpleEnum e)
{
System.Console.WriteLine((int)e);
}
public static void Method1(SimpleEnum e)
{
System.Console.WriteLine((int)e);
}
public SimpleEnum GetEnum(SimpleEnum simpleEnum)
{
return(simpleEnum);
}
public static SimpleEnum ReturnEnum (SimpleEnum value) {
return value;
}
public static ITestIntfPrx allTests(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
string sref = "test:" + helper.GetTestEndpoint(0);
var obj = IObjectPrx.Parse(sref, communicator);
TestHelper.Assert(obj != null);
var proxy = ITestIntfPrx.UncheckedCast(obj);
TestHelper.Assert(proxy != null);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing enum values... ");
output.Flush();
TestHelper.Assert((int)ByteEnum.benum1 == 0);
TestHelper.Assert((int)ByteEnum.benum2 == 1);
TestHelper.Assert((int)ByteEnum.benum3 == Constants.ByteConst1);
TestHelper.Assert((int)ByteEnum.benum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum5 == Constants.ShortConst1);
TestHelper.Assert((int)ByteEnum.benum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum7 == Constants.IntConst1);
TestHelper.Assert((int)ByteEnum.benum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum9 == Constants.LongConst1);
TestHelper.Assert((int)ByteEnum.benum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum11 == Constants.ByteConst2);
TestHelper.Assert((int)ShortEnum.senum1 == 3);
TestHelper.Assert((int)ShortEnum.senum2 == 4);
TestHelper.Assert((int)ShortEnum.senum3 == Constants.ByteConst1);
TestHelper.Assert((int)ShortEnum.senum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum5 == Constants.ShortConst1);
TestHelper.Assert((int)ShortEnum.senum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum7 == Constants.IntConst1);
TestHelper.Assert((int)ShortEnum.senum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum9 == Constants.LongConst1);
TestHelper.Assert((int)ShortEnum.senum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum11 == Constants.ShortConst2);
TestHelper.Assert((int)IntEnum.ienum1 == 0);
TestHelper.Assert((int)IntEnum.ienum2 == 1);
TestHelper.Assert((int)IntEnum.ienum3 == Constants.ByteConst1);
TestHelper.Assert((int)IntEnum.ienum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum5 == Constants.ShortConst1);
TestHelper.Assert((int)IntEnum.ienum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum7 == Constants.IntConst1);
TestHelper.Assert((int)IntEnum.ienum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum9 == Constants.LongConst1);
TestHelper.Assert((int)IntEnum.ienum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum11 == Constants.IntConst2);
TestHelper.Assert((int)IntEnum.ienum12 == Constants.LongConst2);
TestHelper.Assert((int)SimpleEnum.red == 0);
TestHelper.Assert((int)SimpleEnum.green == 1);
TestHelper.Assert((int)SimpleEnum.blue == 2);
output.WriteLine("ok");
output.Write("testing enum operations... ");
output.Flush();
{
(ByteEnum r, ByteEnum o) = proxy.opByte(ByteEnum.benum1);
TestHelper.Assert(r == ByteEnum.benum1 && o == ByteEnum.benum1);
(r, o) = proxy.opByte(ByteEnum.benum11);
TestHelper.Assert(r == ByteEnum.benum11 && o == ByteEnum.benum11);
}
{
(ShortEnum r, ShortEnum o) = proxy.opShort(ShortEnum.senum1);
TestHelper.Assert(r == ShortEnum.senum1 && o == ShortEnum.senum1);
(r, o) = proxy.opShort(ShortEnum.senum11);
TestHelper.Assert(r == ShortEnum.senum11 && o == ShortEnum.senum11);
}
{
(IntEnum r, IntEnum o) = proxy.opInt(IntEnum.ienum1);
TestHelper.Assert(r == IntEnum.ienum1 && o == IntEnum.ienum1);
(r, o) = proxy.opInt(IntEnum.ienum11);
TestHelper.Assert(r == IntEnum.ienum11 && o == IntEnum.ienum11);
(r, o) = proxy.opInt(IntEnum.ienum12);
TestHelper.Assert(r == IntEnum.ienum12 && o == IntEnum.ienum12);
}
{
(SimpleEnum r, SimpleEnum o) = proxy.opSimple(SimpleEnum.green);
TestHelper.Assert(r == SimpleEnum.green && o == SimpleEnum.green);
}
output.WriteLine("ok");
output.Write("testing enum sequences operations... ");
output.Flush();
{
var b1 = new ByteEnum[11]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
(ByteEnum[] b3, ByteEnum[] b2) = proxy.opByteSeq(b1);
for (int i = 0; i < b1.Length; ++i)
{
TestHelper.Assert(b1[i] == b2[i]);
TestHelper.Assert(b1[i] == b3[i]);
}
}
{
var s1 = new ShortEnum[11]
{
ShortEnum.senum1,
ShortEnum.senum2,
ShortEnum.senum3,
ShortEnum.senum4,
ShortEnum.senum5,
ShortEnum.senum6,
ShortEnum.senum7,
ShortEnum.senum8,
ShortEnum.senum9,
ShortEnum.senum10,
ShortEnum.senum11
};
(ShortEnum[] s3, ShortEnum[] s2) = proxy.opShortSeq(s1);
for (int i = 0; i < s1.Length; ++i)
{
TestHelper.Assert(s1[i] == s2[i]);
TestHelper.Assert(s1[i] == s3[i]);
}
}
{
var i1 = new IntEnum[11]
{
IntEnum.ienum1,
IntEnum.ienum2,
IntEnum.ienum3,
IntEnum.ienum4,
IntEnum.ienum5,
IntEnum.ienum6,
IntEnum.ienum7,
IntEnum.ienum8,
IntEnum.ienum9,
IntEnum.ienum10,
IntEnum.ienum11
};
(IntEnum[] i3, IntEnum[] i2) = proxy.opIntSeq(i1);
for (int i = 0; i < i1.Length; ++i)
{
TestHelper.Assert(i1[i] == i2[i]);
TestHelper.Assert(i1[i] == i3[i]);
}
}
{
var s1 = new SimpleEnum[3]
{
SimpleEnum.red,
SimpleEnum.green,
SimpleEnum.blue
};
(SimpleEnum[] s3, SimpleEnum[] s2) = proxy.opSimpleSeq(s1);
for (int i = 0; i < s1.Length; ++i)
{
TestHelper.Assert(s1[i] == s2[i]);
TestHelper.Assert(s1[i] == s3[i]);
}
}
output.WriteLine("ok");
return(proxy);
}
private static IEnumerable RunNativeQuery(IObjectContainer db, SimpleEnum value)
{
return db.Query((Container c) => c.SimpleEnum == value);
}
public static SimpleEnum Or (SimpleEnum lhs, SimpleEnum rhs) {
return lhs | rhs;
}
public static TestIntfPrx allTests(Ice.Communicator communicator)
#endif
{
string sref = "test:default -p 12010";
Ice.ObjectPrx obj = communicator.stringToProxy(sref);
test(obj != null);
TestIntfPrx proxy = TestIntfPrxHelper.uncheckedCast(obj);
test(proxy != null);
Console.Out.Write("testing enum values... ");
Console.Out.Flush();
test((int)ByteEnum.benum1 == 0);
test((int)ByteEnum.benum2 == 1);
test((int)ByteEnum.benum3 == ByteConst1.value);
test((int)ByteEnum.benum4 == ByteConst1.value + 1);
test((int)ByteEnum.benum5 == ShortConst1.value);
test((int)ByteEnum.benum6 == ShortConst1.value + 1);
test((int)ByteEnum.benum7 == IntConst1.value);
test((int)ByteEnum.benum8 == IntConst1.value + 1);
test((int)ByteEnum.benum9 == LongConst1.value);
test((int)ByteEnum.benum10 == LongConst1.value + 1);
test((int)ByteEnum.benum11 == ByteConst2.value);
test((int)ShortEnum.senum1 == 3);
test((int)ShortEnum.senum2 == 4);
test((int)ShortEnum.senum3 == ByteConst1.value);
test((int)ShortEnum.senum4 == ByteConst1.value + 1);
test((int)ShortEnum.senum5 == ShortConst1.value);
test((int)ShortEnum.senum6 == ShortConst1.value + 1);
test((int)ShortEnum.senum7 == IntConst1.value);
test((int)ShortEnum.senum8 == IntConst1.value + 1);
test((int)ShortEnum.senum9 == LongConst1.value);
test((int)ShortEnum.senum10 == LongConst1.value + 1);
test((int)ShortEnum.senum11 == ShortConst2.value);
test((int)IntEnum.ienum1 == 0);
test((int)IntEnum.ienum2 == 1);
test((int)IntEnum.ienum3 == ByteConst1.value);
test((int)IntEnum.ienum4 == ByteConst1.value + 1);
test((int)IntEnum.ienum5 == ShortConst1.value);
test((int)IntEnum.ienum6 == ShortConst1.value + 1);
test((int)IntEnum.ienum7 == IntConst1.value);
test((int)IntEnum.ienum8 == IntConst1.value + 1);
test((int)IntEnum.ienum9 == LongConst1.value);
test((int)IntEnum.ienum10 == LongConst1.value + 1);
test((int)IntEnum.ienum11 == IntConst2.value);
test((int)IntEnum.ienum12 == LongConst2.value);
test((int)SimpleEnum.red == 0);
test((int)SimpleEnum.green == 1);
test((int)SimpleEnum.blue == 2);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum streaming... ");
Console.Out.Flush();
Ice.OutputStream ostr;
byte[] bytes;
bool encoding_1_0 = communicator.getProperties().getProperty("Ice.Default.EncodingVersion").Equals("1.0");
ostr = Ice.Util.createOutputStream(communicator);
ByteEnumHelper.write(ostr, ByteEnum.benum11);
bytes = ostr.finished();
test(bytes.Length == 1); // ByteEnum should require one byte
ostr = Ice.Util.createOutputStream(communicator);
ShortEnumHelper.write(ostr, ShortEnum.senum11);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 2 : 5));
ostr = Ice.Util.createOutputStream(communicator);
IntEnumHelper.write(ostr, IntEnum.ienum11);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 4 : 5));
ostr = Ice.Util.createOutputStream(communicator);
SimpleEnumHelper.write(ostr, SimpleEnum.blue);
bytes = ostr.finished();
test(bytes.Length == 1); // SimpleEnum should require one byte
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum operations... ");
Console.Out.Flush();
ByteEnum byteEnum;
test(proxy.opByte(ByteEnum.benum1, out byteEnum) == ByteEnum.benum1);
test(byteEnum == ByteEnum.benum1);
test(proxy.opByte(ByteEnum.benum11, out byteEnum) == ByteEnum.benum11);
test(byteEnum == ByteEnum.benum11);
ShortEnum shortEnum;
test(proxy.opShort(ShortEnum.senum1, out shortEnum) == ShortEnum.senum1);
test(shortEnum == ShortEnum.senum1);
test(proxy.opShort(ShortEnum.senum11, out shortEnum) == ShortEnum.senum11);
test(shortEnum == ShortEnum.senum11);
IntEnum intEnum;
test(proxy.opInt(IntEnum.ienum1, out intEnum) == IntEnum.ienum1);
test(intEnum == IntEnum.ienum1);
test(proxy.opInt(IntEnum.ienum11, out intEnum) == IntEnum.ienum11);
test(intEnum == IntEnum.ienum11);
test(proxy.opInt(IntEnum.ienum12, out intEnum) == IntEnum.ienum12);
test(intEnum == IntEnum.ienum12);
SimpleEnum s;
test(proxy.opSimple(SimpleEnum.green, out s) == SimpleEnum.green);
test(s == SimpleEnum.green);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum sequences operations... ");
Console.Out.Flush();
{
ByteEnum[] b1 = new ByteEnum[11]
{
ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5,
ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10,
ByteEnum.benum11
};
ByteEnum[] b2;
ByteEnum[] b3 = proxy.opByteSeq(b1, out b2);
for (int i = 0; i < b1.Length; ++i)
{
test(b1[i] == b2[i]);
test(b1[i] == b3[i]);
}
}
{
ShortEnum[] s1 = new ShortEnum[11]
{
ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5,
ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10,
ShortEnum.senum11
};
ShortEnum[] s2;
ShortEnum[] s3 = proxy.opShortSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
{
IntEnum[] i1 = new IntEnum[11]
{
IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5,
IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10,
IntEnum.ienum11
};
IntEnum[] i2;
IntEnum[] i3 = proxy.opIntSeq(i1, out i2);
for (int i = 0; i < i1.Length; ++i)
{
test(i1[i] == i2[i]);
test(i1[i] == i3[i]);
}
}
{
SimpleEnum[] s1 = new SimpleEnum[3]
{
SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue
};
SimpleEnum[] s2;
SimpleEnum[] s3 = proxy.opSimpleSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum exceptions... ");
Console.Out.Flush();
try
{
ostr = Ice.Util.createOutputStream(communicator);
ostr.writeByte((byte)128); // Invalid enumerator
Ice.InputStream istr = Ice.Util.createInputStream(communicator, ostr.finished());
ByteEnumHelper.read(istr);
test(false);
}
catch (Ice.MarshalException)
{
}
try
{
ostr = Ice.Util.createOutputStream(communicator);
ostr.writeShort((short)-1); // Negative enumerators are not supported
Ice.InputStream istr = Ice.Util.createInputStream(communicator, ostr.finished());
ShortEnumHelper.read(istr);
test(false);
}
catch (Ice.MarshalException)
{
}
try
{
ostr = Ice.Util.createOutputStream(communicator);
ostr.writeShort((short)0); // Invalid enumerator
Ice.InputStream istr = Ice.Util.createInputStream(communicator, ostr.finished());
ShortEnumHelper.read(istr);
test(false);
}
catch (Ice.MarshalException)
{
}
try
{
ostr = Ice.Util.createOutputStream(communicator);
ostr.writeShort((short)32767); // Invalid enumerator
Ice.InputStream istr = Ice.Util.createInputStream(communicator, ostr.finished());
ShortEnumHelper.read(istr);
test(false);
}
catch (Ice.MarshalException)
{
}
try
{
ostr = Ice.Util.createOutputStream(communicator);
ostr.writeInt(-1); // Negative enumerators are not supported
Ice.InputStream istr = Ice.Util.createInputStream(communicator, ostr.finished());
IntEnumHelper.read(istr);
test(false);
}
catch (Ice.MarshalException)
{
}
Console.Out.WriteLine("ok");
#if SILVERLIGHT
proxy.shutdown();
#else
return(proxy);
#endif
}
public Container(SimpleEnum simpleEnum, string name)
{
_simpleEnum = simpleEnum;
_name = name;
}
public string BoundFuncWithEnumParameter(SimpleEnum p1)
{
return "BoundFuncWithEnumParameterForAttributeRouting(" + p1 + ")";
}
public static TestIntfPrx allTests(TestCommon.Application app)
{
Ice.Communicator communicator = app.communicator();
string sref = "test:" + app.getTestEndpoint(0);
Ice.ObjectPrx obj = communicator.stringToProxy(sref);
test(obj != null);
TestIntfPrx proxy = TestIntfPrxHelper.uncheckedCast(obj);
test(proxy != null);
Console.Out.Write("testing enum values... ");
Console.Out.Flush();
test((int)ByteEnum.benum1 == 0);
test((int)ByteEnum.benum2 == 1);
test((int)ByteEnum.benum3 == ByteConst1.value);
test((int)ByteEnum.benum4 == ByteConst1.value + 1);
test((int)ByteEnum.benum5 == ShortConst1.value);
test((int)ByteEnum.benum6 == ShortConst1.value + 1);
test((int)ByteEnum.benum7 == IntConst1.value);
test((int)ByteEnum.benum8 == IntConst1.value + 1);
test((int)ByteEnum.benum9 == LongConst1.value);
test((int)ByteEnum.benum10 == LongConst1.value + 1);
test((int)ByteEnum.benum11 == ByteConst2.value);
test((int)ShortEnum.senum1 == 3);
test((int)ShortEnum.senum2 == 4);
test((int)ShortEnum.senum3 == ByteConst1.value);
test((int)ShortEnum.senum4 == ByteConst1.value + 1);
test((int)ShortEnum.senum5 == ShortConst1.value);
test((int)ShortEnum.senum6 == ShortConst1.value + 1);
test((int)ShortEnum.senum7 == IntConst1.value);
test((int)ShortEnum.senum8 == IntConst1.value + 1);
test((int)ShortEnum.senum9 == LongConst1.value);
test((int)ShortEnum.senum10 == LongConst1.value + 1);
test((int)ShortEnum.senum11 == ShortConst2.value);
test((int)IntEnum.ienum1 == 0);
test((int)IntEnum.ienum2 == 1);
test((int)IntEnum.ienum3 == ByteConst1.value);
test((int)IntEnum.ienum4 == ByteConst1.value + 1);
test((int)IntEnum.ienum5 == ShortConst1.value);
test((int)IntEnum.ienum6 == ShortConst1.value + 1);
test((int)IntEnum.ienum7 == IntConst1.value);
test((int)IntEnum.ienum8 == IntConst1.value + 1);
test((int)IntEnum.ienum9 == LongConst1.value);
test((int)IntEnum.ienum10 == LongConst1.value + 1);
test((int)IntEnum.ienum11 == IntConst2.value);
test((int)IntEnum.ienum12 == LongConst2.value);
test((int)SimpleEnum.red == 0);
test((int)SimpleEnum.green == 1);
test((int)SimpleEnum.blue == 2);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum streaming... ");
Console.Out.Flush();
Ice.OutputStream ostr;
byte[] bytes;
bool encoding_1_0 = communicator.getProperties().getProperty("Ice.Default.EncodingVersion").Equals("1.0");
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)ByteEnum.benum11, (int)ByteEnum.benum11);
bytes = ostr.finished();
test(bytes.Length == 1); // ByteEnum should require one byte
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)ShortEnum.senum11, (int)ShortEnum.senum11);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 2 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)IntEnum.ienum11, (int)IntEnum.ienum12);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 4 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)SimpleEnum.blue, (int)SimpleEnum.blue);
bytes = ostr.finished();
test(bytes.Length == 1); // SimpleEnum should require one byte
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum operations... ");
Console.Out.Flush();
ByteEnum byteEnum;
test(proxy.opByte(ByteEnum.benum1, out byteEnum) == ByteEnum.benum1);
test(byteEnum == ByteEnum.benum1);
test(proxy.opByte(ByteEnum.benum11, out byteEnum) == ByteEnum.benum11);
test(byteEnum == ByteEnum.benum11);
ShortEnum shortEnum;
test(proxy.opShort(ShortEnum.senum1, out shortEnum) == ShortEnum.senum1);
test(shortEnum == ShortEnum.senum1);
test(proxy.opShort(ShortEnum.senum11, out shortEnum) == ShortEnum.senum11);
test(shortEnum == ShortEnum.senum11);
IntEnum intEnum;
test(proxy.opInt(IntEnum.ienum1, out intEnum) == IntEnum.ienum1);
test(intEnum == IntEnum.ienum1);
test(proxy.opInt(IntEnum.ienum11, out intEnum) == IntEnum.ienum11);
test(intEnum == IntEnum.ienum11);
test(proxy.opInt(IntEnum.ienum12, out intEnum) == IntEnum.ienum12);
test(intEnum == IntEnum.ienum12);
SimpleEnum s;
test(proxy.opSimple(SimpleEnum.green, out s) == SimpleEnum.green);
test(s == SimpleEnum.green);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum sequences operations... ");
Console.Out.Flush();
{
ByteEnum[] b1 = new ByteEnum[11]
{
ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5,
ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10,
ByteEnum.benum11
};
ByteEnum[] b2;
ByteEnum[] b3 = proxy.opByteSeq(b1, out b2);
for (int i = 0; i < b1.Length; ++i)
{
test(b1[i] == b2[i]);
test(b1[i] == b3[i]);
}
}
{
ShortEnum[] s1 = new ShortEnum[11]
{
ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5,
ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10,
ShortEnum.senum11
};
ShortEnum[] s2;
ShortEnum[] s3 = proxy.opShortSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
{
IntEnum[] i1 = new IntEnum[11]
{
IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5,
IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10,
IntEnum.ienum11
};
IntEnum[] i2;
IntEnum[] i3 = proxy.opIntSeq(i1, out i2);
for (int i = 0; i < i1.Length; ++i)
{
test(i1[i] == i2[i]);
test(i1[i] == i3[i]);
}
}
{
SimpleEnum[] s1 = new SimpleEnum[3]
{
SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue
};
SimpleEnum[] s2;
SimpleEnum[] s3 = proxy.opSimpleSeq(s1, out s2);
for (int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
Console.Out.WriteLine("ok");
return(proxy);
}
public SimpleEnum GetEnum(SimpleEnum simpleEnum)
{
return simpleEnum;
}
public string BoundFuncWithEnumParameter(SimpleEnum p1)
{
return("BoundFuncWithEnumParameterForAttributeRouting(" + p1 + ")");
}
public static async Task RunAsync(TestHelper helper)
{
Communicator communicator = helper.Communicator;
var proxy = ITestIntfPrx.Parse(helper.GetTestProxy("test", 0), communicator);
System.IO.TextWriter output = helper.Output;
output.Write("testing enum values... ");
output.Flush();
TestHelper.Assert((int)ByteEnum.benum1 == 0);
TestHelper.Assert((int)ByteEnum.benum2 == 1);
TestHelper.Assert((int)ByteEnum.benum3 == Constants.ByteConst1);
TestHelper.Assert((int)ByteEnum.benum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum5 == Constants.ShortConst1);
TestHelper.Assert((int)ByteEnum.benum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum7 == Constants.IntConst1);
TestHelper.Assert((int)ByteEnum.benum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum9 == Constants.LongConst1);
TestHelper.Assert((int)ByteEnum.benum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum11 == Constants.ByteConst2);
TestHelper.Assert((int)ShortEnum.senum1 == 3);
TestHelper.Assert((int)ShortEnum.senum2 == 4);
TestHelper.Assert((int)ShortEnum.senum3 == Constants.ByteConst1);
TestHelper.Assert((int)ShortEnum.senum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum5 == Constants.ShortConst1);
TestHelper.Assert((int)ShortEnum.senum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum7 == Constants.IntConst1);
TestHelper.Assert((int)ShortEnum.senum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum9 == Constants.LongConst1);
TestHelper.Assert((int)ShortEnum.senum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum11 == Constants.ShortConst2);
TestHelper.Assert((int)IntEnum.ienum1 == 0);
TestHelper.Assert((int)IntEnum.ienum2 == 1);
TestHelper.Assert((int)IntEnum.ienum3 == Constants.ByteConst1);
TestHelper.Assert((int)IntEnum.ienum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum5 == Constants.ShortConst1);
TestHelper.Assert((int)IntEnum.ienum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum7 == Constants.IntConst1);
TestHelper.Assert((int)IntEnum.ienum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum9 == Constants.LongConst1);
TestHelper.Assert((int)IntEnum.ienum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum11 == Constants.IntConst2);
TestHelper.Assert((int)IntEnum.ienum12 == Constants.LongConst2);
TestHelper.Assert((int)SimpleEnum.red == 0);
TestHelper.Assert((int)SimpleEnum.green == 1);
TestHelper.Assert((int)SimpleEnum.blue == 2);
output.WriteLine("ok");
output.Write("testing enum operations... ");
output.Flush();
{
(ByteEnum r, ByteEnum o) = proxy.OpByte(ByteEnum.benum1);
TestHelper.Assert(r == ByteEnum.benum1 && o == ByteEnum.benum1);
(r, o) = proxy.OpByte(ByteEnum.benum11);
TestHelper.Assert(r == ByteEnum.benum11 && o == ByteEnum.benum11);
}
{
// 42 does not correspond to a ByteEnum enumerator, so we expect failure since ByteEnum is checked.
try
{
_ = proxy.OpByte((ByteEnum)42);
TestHelper.Assert(false);
}
catch (UnhandledException) // unhandled dispatch exception
{
// expected
}
}
{
(ByteEnum? r, ByteEnum? o) = proxy.OpTaggedByte(ByteEnum.benum1);
TestHelper.Assert(r == ByteEnum.benum1 && o == ByteEnum.benum1);
(r, o) = proxy.OpTaggedByte(ByteEnum.benum11);
TestHelper.Assert(r == ByteEnum.benum11 && o == ByteEnum.benum11);
(r, o) = proxy.OpTaggedByte(null);
TestHelper.Assert(r == null && o == null);
}
{
try
{
_ = proxy.OpTaggedByte((ByteEnum)42);
TestHelper.Assert(false);
}
catch (UnhandledException) // unhandled dispatch exception
{
// expected
}
}
{
(ShortEnum r, ShortEnum o) = proxy.OpShort(ShortEnum.senum1);
TestHelper.Assert(r == ShortEnum.senum1 && o == ShortEnum.senum1);
(r, o) = proxy.OpShort(ShortEnum.senum11);
TestHelper.Assert(r == ShortEnum.senum11 && o == ShortEnum.senum11);
}
{
(IntEnum r, IntEnum o) = proxy.OpInt(IntEnum.ienum1);
TestHelper.Assert(r == IntEnum.ienum1 && o == IntEnum.ienum1);
(r, o) = proxy.OpInt(IntEnum.ienum11);
TestHelper.Assert(r == IntEnum.ienum11 && o == IntEnum.ienum11);
(r, o) = proxy.OpInt(IntEnum.ienum12);
TestHelper.Assert(r == IntEnum.ienum12 && o == IntEnum.ienum12);
}
{
(SimpleEnum r, SimpleEnum o) = proxy.OpSimple(SimpleEnum.green);
TestHelper.Assert(r == SimpleEnum.green && o == SimpleEnum.green);
}
{
(FLByteEnum r, FLByteEnum o) = proxy.OpFLByte(FLByteEnum.benum1);
TestHelper.Assert(r == FLByteEnum.benum1 && o == FLByteEnum.benum1);
(r, o) = proxy.OpFLByte(FLByteEnum.benum11);
TestHelper.Assert(r == FLByteEnum.benum11 && o == FLByteEnum.benum11);
}
{
(FLByteEnum? r, FLByteEnum? o) = proxy.OpTaggedFLByte(FLByteEnum.benum1);
TestHelper.Assert(r == FLByteEnum.benum1 && o == FLByteEnum.benum1);
(r, o) = proxy.OpTaggedFLByte(FLByteEnum.benum11);
TestHelper.Assert(r == FLByteEnum.benum11 && o == FLByteEnum.benum11);
(r, o) = proxy.OpTaggedFLByte(null);
TestHelper.Assert(r == null && o == null);
}
{
(FLShortEnum r, FLShortEnum o) = proxy.OpFLShort(FLShortEnum.senum1);
TestHelper.Assert(r == FLShortEnum.senum1 && o == FLShortEnum.senum1);
(r, o) = proxy.OpFLShort(FLShortEnum.senum11);
TestHelper.Assert(r == FLShortEnum.senum11 && o == FLShortEnum.senum11);
}
{
(FLUShortEnum r, FLUShortEnum o) = proxy.OpFLUShort(FLUShortEnum.senum1);
TestHelper.Assert(r == FLUShortEnum.senum1 && o == FLUShortEnum.senum1);
(r, o) = proxy.OpFLUShort(FLUShortEnum.senum11);
TestHelper.Assert(r == FLUShortEnum.senum11 && o == FLUShortEnum.senum11);
}
{
(FLIntEnum r, FLIntEnum o) = proxy.OpFLInt(FLIntEnum.ienum1);
TestHelper.Assert(r == FLIntEnum.ienum1 && o == FLIntEnum.ienum1);
(r, o) = proxy.OpFLInt(FLIntEnum.ienum11);
TestHelper.Assert(r == FLIntEnum.ienum11 && o == FLIntEnum.ienum11);
(r, o) = proxy.OpFLInt(FLIntEnum.ienum12);
TestHelper.Assert(r == FLIntEnum.ienum12 && o == FLIntEnum.ienum12);
}
{
(FLUIntEnum r, FLUIntEnum o) = proxy.OpFLUInt(FLUIntEnum.ienum1);
TestHelper.Assert(r == FLUIntEnum.ienum1 && o == FLUIntEnum.ienum1);
(r, o) = proxy.OpFLUInt(FLUIntEnum.ienum11);
TestHelper.Assert(r == FLUIntEnum.ienum11 && o == FLUIntEnum.ienum11);
(r, o) = proxy.OpFLUInt(FLUIntEnum.ienum12);
TestHelper.Assert(r == FLUIntEnum.ienum12 && o == FLUIntEnum.ienum12);
}
{
(FLSimpleEnum r, FLSimpleEnum o) = proxy.OpFLSimple(FLSimpleEnum.green);
TestHelper.Assert(r == FLSimpleEnum.green && o == FLSimpleEnum.green);
}
output.WriteLine("ok");
output.Write("testing enum sequences operations... ");
output.Flush();
{
var b1 = new ByteEnum[11]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
(ByteEnum[] b3, ByteEnum[] b2) = proxy.OpByteSeq(b1);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
}
{
var b1 = new ByteEnum[12]
{
ByteEnum.benum1,
ByteEnum.benum2,
(ByteEnum)42,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
try
{
_ = proxy.OpByteSeq(b1);
TestHelper.Assert(false);
}
catch (UnhandledException)
{
// expected
}
}
{
var s1 = new ShortEnum[11]
{
ShortEnum.senum1,
ShortEnum.senum2,
ShortEnum.senum3,
ShortEnum.senum4,
ShortEnum.senum5,
ShortEnum.senum6,
ShortEnum.senum7,
ShortEnum.senum8,
ShortEnum.senum9,
ShortEnum.senum10,
ShortEnum.senum11
};
(ShortEnum[] s3, ShortEnum[] s2) = proxy.OpShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var i1 = new IntEnum[11]
{
IntEnum.ienum1,
IntEnum.ienum2,
IntEnum.ienum3,
IntEnum.ienum4,
IntEnum.ienum5,
IntEnum.ienum6,
IntEnum.ienum7,
IntEnum.ienum8,
IntEnum.ienum9,
IntEnum.ienum10,
IntEnum.ienum11
};
(IntEnum[] i3, IntEnum[] i2) = proxy.OpIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var s1 = new SimpleEnum[3]
{
SimpleEnum.red,
SimpleEnum.green,
SimpleEnum.blue
};
(SimpleEnum[] s3, SimpleEnum[] s2) = proxy.OpSimpleSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var b1 = new FLByteEnum[11]
{
FLByteEnum.benum1,
FLByteEnum.benum2,
FLByteEnum.benum3,
FLByteEnum.benum4,
FLByteEnum.benum5,
FLByteEnum.benum6,
FLByteEnum.benum7,
FLByteEnum.benum8,
FLByteEnum.benum9,
FLByteEnum.benum10,
FLByteEnum.benum11
};
(FLByteEnum[] b3, FLByteEnum[] b2) = proxy.OpFLByteSeq(b1);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
}
{
var s1 = new FLShortEnum[11]
{
FLShortEnum.senum1,
FLShortEnum.senum2,
FLShortEnum.senum3,
FLShortEnum.senum4,
FLShortEnum.senum5,
FLShortEnum.senum6,
FLShortEnum.senum7,
FLShortEnum.senum8,
FLShortEnum.senum9,
FLShortEnum.senum10,
FLShortEnum.senum11
};
(FLShortEnum[] s3, FLShortEnum[] s2) = proxy.OpFLShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var s1 = new FLUShortEnum[11]
{
FLUShortEnum.senum1,
FLUShortEnum.senum2,
FLUShortEnum.senum3,
FLUShortEnum.senum4,
FLUShortEnum.senum5,
FLUShortEnum.senum6,
FLUShortEnum.senum7,
FLUShortEnum.senum8,
FLUShortEnum.senum9,
FLUShortEnum.senum10,
FLUShortEnum.senum11
};
(FLUShortEnum[] s3, FLUShortEnum[] s2) = proxy.OpFLUShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var i1 = new FLIntEnum[11]
{
FLIntEnum.ienum1,
FLIntEnum.ienum2,
FLIntEnum.ienum3,
FLIntEnum.ienum4,
FLIntEnum.ienum5,
FLIntEnum.ienum6,
FLIntEnum.ienum7,
FLIntEnum.ienum8,
FLIntEnum.ienum9,
FLIntEnum.ienum10,
FLIntEnum.ienum11
};
(FLIntEnum[] i3, FLIntEnum[] i2) = proxy.OpFLIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var i1 = new FLUIntEnum[11]
{
FLUIntEnum.ienum1,
FLUIntEnum.ienum2,
FLUIntEnum.ienum3,
FLUIntEnum.ienum4,
FLUIntEnum.ienum5,
FLUIntEnum.ienum6,
FLUIntEnum.ienum7,
FLUIntEnum.ienum8,
FLUIntEnum.ienum9,
FLUIntEnum.ienum10,
FLUIntEnum.ienum11
};
(FLUIntEnum[] i3, FLUIntEnum[] i2) = proxy.OpFLUIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var s1 = new FLSimpleEnum[3]
{
FLSimpleEnum.red,
FLSimpleEnum.green,
FLSimpleEnum.blue
};
(FLSimpleEnum[] s3, FLSimpleEnum[] s2) = proxy.OpFLSimpleSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var b1 = new ByteEnum[11]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
(ByteEnum[]? b3, ByteEnum[]? b2) = proxy.OpTaggedByteSeq(b1);
TestHelper.Assert(b2 != null && b3 != null);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
(b3, b2) = proxy.OpTaggedByteSeq(null);
TestHelper.Assert(b2 == null && b3 == null);
}
{
var b1 = new ByteEnum[12]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
(ByteEnum)42,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
try
{
_ = proxy.OpTaggedByteSeq(b1);
TestHelper.Assert(false);
}
catch (UnhandledException)
{
// expected
}
}
{
var b1 = new FLByteEnum[11]
{
FLByteEnum.benum1,
FLByteEnum.benum2,
FLByteEnum.benum3,
FLByteEnum.benum4,
FLByteEnum.benum5,
FLByteEnum.benum6,
FLByteEnum.benum7,
FLByteEnum.benum8,
FLByteEnum.benum9,
FLByteEnum.benum10,
FLByteEnum.benum11
};
(FLByteEnum[]? b3, FLByteEnum[]? b2) = proxy.OpTaggedFLByteSeq(b1);
TestHelper.Assert(b2 != null && b3 != null);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
(b3, b2) = proxy.OpTaggedFLByteSeq(null);
TestHelper.Assert(b2 == null && b3 == null);
}
{
var i1 = new FLIntEnum[11]
{
FLIntEnum.ienum1,
FLIntEnum.ienum2,
FLIntEnum.ienum3,
FLIntEnum.ienum4,
FLIntEnum.ienum5,
FLIntEnum.ienum6,
FLIntEnum.ienum7,
FLIntEnum.ienum8,
FLIntEnum.ienum9,
FLIntEnum.ienum10,
FLIntEnum.ienum11
};
(FLIntEnum[]? i3, FLIntEnum[]? i2) = proxy.OpTaggedFLIntSeq(i1);
TestHelper.Assert(i2 != null && i3 != null);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
(i3, i2) = proxy.OpTaggedFLIntSeq(null);
TestHelper.Assert(i2 == null && i3 == null);
}
output.WriteLine("ok");
output.Write("testing unchecked enums... ");
output.Flush();
{
(MyFlags r, MyFlags f2) = proxy.OpMyFlags(MyFlags.E31);
TestHelper.Assert(r == MyFlags.E31 && f2 == r);
(r, f2) = proxy.OpMyFlags(MyFlags.E10 | MyFlags.E11);
TestHelper.Assert(r == (MyFlags.E10 | MyFlags.E11) && f2 == r);
}
output.Flush();
{
(MyFlags? r, MyFlags? f2) = proxy.OpTaggedMyFlags(null);
TestHelper.Assert(r == null && f2 == r);
(r, f2) = proxy.OpTaggedMyFlags(MyFlags.E10 | MyFlags.E11);
TestHelper.Assert(r == (MyFlags.E10 | MyFlags.E11) && f2 == r);
}
output.Flush();
{
var myFlagsSeq = new MyFlags[] { MyFlags.E10, MyFlags.E0, MyFlags.E5 | MyFlags.E6 };
(MyFlags[] r, MyFlags[] f2) = proxy.OpMyFlagsSeq(myFlagsSeq);
TestHelper.Assert(r.SequenceEqual(myFlagsSeq) && f2.SequenceEqual(myFlagsSeq));
}
output.Flush();
{
var myFlagsSeq = new MyFlags[] { MyFlags.E10, MyFlags.E0, MyFlags.E5 | MyFlags.E6 };
(MyFlags[]? r, MyFlags[]? f2) = proxy.OpTaggedMyFlagsSeq(myFlagsSeq);
TestHelper.Assert(r !.SequenceEqual(myFlagsSeq) && f2 !.SequenceEqual(myFlagsSeq));
}
output.WriteLine("ok");
await proxy.ShutdownAsync();
}
public AttributeWithSimpleEnumAttribute(SimpleEnum value)
{
}
public Item(SimpleEnum value)
{
_value = value;
}
public SimpleEnum MethodWithEnum(SimpleEnum x)
{
return(x);
}
public SimpleEnum GetEnum(SimpleEnum simpleEnum)
{
return simpleEnum;
}
public string BoundFuncWithEnumParametersOnCollectionOfRoutingCustomer(SimpleEnum simpleEnum, FlagsEnum flagsEnum)
{
return("BoundFuncWithEnumParameters(" + simpleEnum + "," + flagsEnum + ")");
}
public static ITestIntfPrx allTests(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
string sref = "test:" + helper.GetTestEndpoint(0);
var obj = IObjectPrx.Parse(sref, communicator);
TestHelper.Assert(obj != null);
var proxy = ITestIntfPrx.UncheckedCast(obj);
TestHelper.Assert(proxy != null);
System.IO.TextWriter output = helper.GetWriter();
output.Write("testing enum values... ");
output.Flush();
TestHelper.Assert((int)ByteEnum.benum1 == 0);
TestHelper.Assert((int)ByteEnum.benum2 == 1);
TestHelper.Assert((int)ByteEnum.benum3 == Constants.ByteConst1);
TestHelper.Assert((int)ByteEnum.benum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum5 == Constants.ShortConst1);
TestHelper.Assert((int)ByteEnum.benum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum7 == Constants.IntConst1);
TestHelper.Assert((int)ByteEnum.benum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum9 == Constants.LongConst1);
TestHelper.Assert((int)ByteEnum.benum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ByteEnum.benum11 == Constants.ByteConst2);
TestHelper.Assert((int)ShortEnum.senum1 == 3);
TestHelper.Assert((int)ShortEnum.senum2 == 4);
TestHelper.Assert((int)ShortEnum.senum3 == Constants.ByteConst1);
TestHelper.Assert((int)ShortEnum.senum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum5 == Constants.ShortConst1);
TestHelper.Assert((int)ShortEnum.senum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum7 == Constants.IntConst1);
TestHelper.Assert((int)ShortEnum.senum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum9 == Constants.LongConst1);
TestHelper.Assert((int)ShortEnum.senum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)ShortEnum.senum11 == Constants.ShortConst2);
TestHelper.Assert((int)IntEnum.ienum1 == 0);
TestHelper.Assert((int)IntEnum.ienum2 == 1);
TestHelper.Assert((int)IntEnum.ienum3 == Constants.ByteConst1);
TestHelper.Assert((int)IntEnum.ienum4 == Constants.ByteConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum5 == Constants.ShortConst1);
TestHelper.Assert((int)IntEnum.ienum6 == Constants.ShortConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum7 == Constants.IntConst1);
TestHelper.Assert((int)IntEnum.ienum8 == Constants.IntConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum9 == Constants.LongConst1);
TestHelper.Assert((int)IntEnum.ienum10 == Constants.LongConst1 + 1);
TestHelper.Assert((int)IntEnum.ienum11 == Constants.IntConst2);
TestHelper.Assert((int)IntEnum.ienum12 == Constants.LongConst2);
TestHelper.Assert((int)SimpleEnum.red == 0);
TestHelper.Assert((int)SimpleEnum.green == 1);
TestHelper.Assert((int)SimpleEnum.blue == 2);
output.WriteLine("ok");
output.Write("testing enum operations... ");
output.Flush();
{
(ByteEnum r, ByteEnum o) = proxy.OpByte(ByteEnum.benum1);
TestHelper.Assert(r == ByteEnum.benum1 && o == ByteEnum.benum1);
(r, o) = proxy.OpByte(ByteEnum.benum11);
TestHelper.Assert(r == ByteEnum.benum11 && o == ByteEnum.benum11);
}
{
(ByteEnum? r, ByteEnum? o) = proxy.OpTaggedByte(ByteEnum.benum1);
TestHelper.Assert(r == ByteEnum.benum1 && o == ByteEnum.benum1);
(r, o) = proxy.OpTaggedByte(ByteEnum.benum11);
TestHelper.Assert(r == ByteEnum.benum11 && o == ByteEnum.benum11);
(r, o) = proxy.OpTaggedByte(null);
TestHelper.Assert(r == null && o == null);
}
{
(ShortEnum r, ShortEnum o) = proxy.OpShort(ShortEnum.senum1);
TestHelper.Assert(r == ShortEnum.senum1 && o == ShortEnum.senum1);
(r, o) = proxy.OpShort(ShortEnum.senum11);
TestHelper.Assert(r == ShortEnum.senum11 && o == ShortEnum.senum11);
}
{
(IntEnum r, IntEnum o) = proxy.OpInt(IntEnum.ienum1);
TestHelper.Assert(r == IntEnum.ienum1 && o == IntEnum.ienum1);
(r, o) = proxy.OpInt(IntEnum.ienum11);
TestHelper.Assert(r == IntEnum.ienum11 && o == IntEnum.ienum11);
(r, o) = proxy.OpInt(IntEnum.ienum12);
TestHelper.Assert(r == IntEnum.ienum12 && o == IntEnum.ienum12);
}
{
(SimpleEnum r, SimpleEnum o) = proxy.OpSimple(SimpleEnum.green);
TestHelper.Assert(r == SimpleEnum.green && o == SimpleEnum.green);
}
{
(FLByteEnum r, FLByteEnum o) = proxy.OpFLByte(FLByteEnum.benum1);
TestHelper.Assert(r == FLByteEnum.benum1 && o == FLByteEnum.benum1);
(r, o) = proxy.OpFLByte(FLByteEnum.benum11);
TestHelper.Assert(r == FLByteEnum.benum11 && o == FLByteEnum.benum11);
}
{
(FLByteEnum? r, FLByteEnum? o) = proxy.OpTaggedFLByte(FLByteEnum.benum1);
TestHelper.Assert(r == FLByteEnum.benum1 && o == FLByteEnum.benum1);
(r, o) = proxy.OpTaggedFLByte(FLByteEnum.benum11);
TestHelper.Assert(r == FLByteEnum.benum11 && o == FLByteEnum.benum11);
(r, o) = proxy.OpTaggedFLByte(null);
TestHelper.Assert(r == null && o == null);
}
{
(FLShortEnum r, FLShortEnum o) = proxy.OpFLShort(FLShortEnum.senum1);
TestHelper.Assert(r == FLShortEnum.senum1 && o == FLShortEnum.senum1);
(r, o) = proxy.OpFLShort(FLShortEnum.senum11);
TestHelper.Assert(r == FLShortEnum.senum11 && o == FLShortEnum.senum11);
}
{
(FLUShortEnum r, FLUShortEnum o) = proxy.OpFLUShort(FLUShortEnum.senum1);
TestHelper.Assert(r == FLUShortEnum.senum1 && o == FLUShortEnum.senum1);
(r, o) = proxy.OpFLUShort(FLUShortEnum.senum11);
TestHelper.Assert(r == FLUShortEnum.senum11 && o == FLUShortEnum.senum11);
}
{
(FLIntEnum r, FLIntEnum o) = proxy.OpFLInt(FLIntEnum.ienum1);
TestHelper.Assert(r == FLIntEnum.ienum1 && o == FLIntEnum.ienum1);
(r, o) = proxy.OpFLInt(FLIntEnum.ienum11);
TestHelper.Assert(r == FLIntEnum.ienum11 && o == FLIntEnum.ienum11);
(r, o) = proxy.OpFLInt(FLIntEnum.ienum12);
TestHelper.Assert(r == FLIntEnum.ienum12 && o == FLIntEnum.ienum12);
}
{
(FLUIntEnum r, FLUIntEnum o) = proxy.OpFLUInt(FLUIntEnum.ienum1);
TestHelper.Assert(r == FLUIntEnum.ienum1 && o == FLUIntEnum.ienum1);
(r, o) = proxy.OpFLUInt(FLUIntEnum.ienum11);
TestHelper.Assert(r == FLUIntEnum.ienum11 && o == FLUIntEnum.ienum11);
(r, o) = proxy.OpFLUInt(FLUIntEnum.ienum12);
TestHelper.Assert(r == FLUIntEnum.ienum12 && o == FLUIntEnum.ienum12);
}
{
(FLSimpleEnum r, FLSimpleEnum o) = proxy.OpFLSimple(FLSimpleEnum.green);
TestHelper.Assert(r == FLSimpleEnum.green && o == FLSimpleEnum.green);
}
output.WriteLine("ok");
output.Write("testing enum sequences operations... ");
output.Flush();
{
var b1 = new ByteEnum[11]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
(ByteEnum[] b3, ByteEnum[] b2) = proxy.OpByteSeq(b1);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
}
{
var s1 = new ShortEnum[11]
{
ShortEnum.senum1,
ShortEnum.senum2,
ShortEnum.senum3,
ShortEnum.senum4,
ShortEnum.senum5,
ShortEnum.senum6,
ShortEnum.senum7,
ShortEnum.senum8,
ShortEnum.senum9,
ShortEnum.senum10,
ShortEnum.senum11
};
(ShortEnum[] s3, ShortEnum[] s2) = proxy.OpShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var i1 = new IntEnum[11]
{
IntEnum.ienum1,
IntEnum.ienum2,
IntEnum.ienum3,
IntEnum.ienum4,
IntEnum.ienum5,
IntEnum.ienum6,
IntEnum.ienum7,
IntEnum.ienum8,
IntEnum.ienum9,
IntEnum.ienum10,
IntEnum.ienum11
};
(IntEnum[] i3, IntEnum[] i2) = proxy.OpIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var s1 = new SimpleEnum[3]
{
SimpleEnum.red,
SimpleEnum.green,
SimpleEnum.blue
};
(SimpleEnum[] s3, SimpleEnum[] s2) = proxy.OpSimpleSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var b1 = new FLByteEnum[11]
{
FLByteEnum.benum1,
FLByteEnum.benum2,
FLByteEnum.benum3,
FLByteEnum.benum4,
FLByteEnum.benum5,
FLByteEnum.benum6,
FLByteEnum.benum7,
FLByteEnum.benum8,
FLByteEnum.benum9,
FLByteEnum.benum10,
FLByteEnum.benum11
};
(FLByteEnum[] b3, FLByteEnum[] b2) = proxy.OpFLByteSeq(b1);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
}
{
var s1 = new FLShortEnum[11]
{
FLShortEnum.senum1,
FLShortEnum.senum2,
FLShortEnum.senum3,
FLShortEnum.senum4,
FLShortEnum.senum5,
FLShortEnum.senum6,
FLShortEnum.senum7,
FLShortEnum.senum8,
FLShortEnum.senum9,
FLShortEnum.senum10,
FLShortEnum.senum11
};
(FLShortEnum[] s3, FLShortEnum[] s2) = proxy.OpFLShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var s1 = new FLUShortEnum[11]
{
FLUShortEnum.senum1,
FLUShortEnum.senum2,
FLUShortEnum.senum3,
FLUShortEnum.senum4,
FLUShortEnum.senum5,
FLUShortEnum.senum6,
FLUShortEnum.senum7,
FLUShortEnum.senum8,
FLUShortEnum.senum9,
FLUShortEnum.senum10,
FLUShortEnum.senum11
};
(FLUShortEnum[] s3, FLUShortEnum[] s2) = proxy.OpFLUShortSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var i1 = new FLIntEnum[11]
{
FLIntEnum.ienum1,
FLIntEnum.ienum2,
FLIntEnum.ienum3,
FLIntEnum.ienum4,
FLIntEnum.ienum5,
FLIntEnum.ienum6,
FLIntEnum.ienum7,
FLIntEnum.ienum8,
FLIntEnum.ienum9,
FLIntEnum.ienum10,
FLIntEnum.ienum11
};
(FLIntEnum[] i3, FLIntEnum[] i2) = proxy.OpFLIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var i1 = new FLUIntEnum[11]
{
FLUIntEnum.ienum1,
FLUIntEnum.ienum2,
FLUIntEnum.ienum3,
FLUIntEnum.ienum4,
FLUIntEnum.ienum5,
FLUIntEnum.ienum6,
FLUIntEnum.ienum7,
FLUIntEnum.ienum8,
FLUIntEnum.ienum9,
FLUIntEnum.ienum10,
FLUIntEnum.ienum11
};
(FLUIntEnum[] i3, FLUIntEnum[] i2) = proxy.OpFLUIntSeq(i1);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
}
{
var s1 = new FLSimpleEnum[3]
{
FLSimpleEnum.red,
FLSimpleEnum.green,
FLSimpleEnum.blue
};
(FLSimpleEnum[] s3, FLSimpleEnum[] s2) = proxy.OpFLSimpleSeq(s1);
TestHelper.Assert(s1.SequenceEqual(s2));
TestHelper.Assert(s1.SequenceEqual(s3));
}
{
var b1 = new ByteEnum[11]
{
ByteEnum.benum1,
ByteEnum.benum2,
ByteEnum.benum3,
ByteEnum.benum4,
ByteEnum.benum5,
ByteEnum.benum6,
ByteEnum.benum7,
ByteEnum.benum8,
ByteEnum.benum9,
ByteEnum.benum10,
ByteEnum.benum11
};
(ByteEnum[]? b3, ByteEnum[]? b2) = proxy.OpTaggedByteSeq(b1);
TestHelper.Assert(b2 != null && b3 != null);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
(b3, b2) = proxy.OpTaggedByteSeq(null);
TestHelper.Assert(b2 == null && b3 == null);
}
{
var b1 = new FLByteEnum[11]
{
FLByteEnum.benum1,
FLByteEnum.benum2,
FLByteEnum.benum3,
FLByteEnum.benum4,
FLByteEnum.benum5,
FLByteEnum.benum6,
FLByteEnum.benum7,
FLByteEnum.benum8,
FLByteEnum.benum9,
FLByteEnum.benum10,
FLByteEnum.benum11
};
(FLByteEnum[]? b3, FLByteEnum[]? b2) = proxy.OpTaggedFLByteSeq(b1);
TestHelper.Assert(b2 != null && b3 != null);
TestHelper.Assert(b1.SequenceEqual(b2));
TestHelper.Assert(b1.SequenceEqual(b3));
(b3, b2) = proxy.OpTaggedFLByteSeq(null);
TestHelper.Assert(b2 == null && b3 == null);
}
{
var i1 = new FLIntEnum[11]
{
FLIntEnum.ienum1,
FLIntEnum.ienum2,
FLIntEnum.ienum3,
FLIntEnum.ienum4,
FLIntEnum.ienum5,
FLIntEnum.ienum6,
FLIntEnum.ienum7,
FLIntEnum.ienum8,
FLIntEnum.ienum9,
FLIntEnum.ienum10,
FLIntEnum.ienum11
};
(FLIntEnum[]? i3, FLIntEnum[]? i2) = proxy.OpTaggedFLIntSeq(i1);
TestHelper.Assert(i2 != null && i3 != null);
TestHelper.Assert(i1.SequenceEqual(i2));
TestHelper.Assert(i1.SequenceEqual(i3));
(i3, i2) = proxy.OpTaggedFLIntSeq(null);
TestHelper.Assert(i2 == null && i3 == null);
}
output.WriteLine("ok");
return(proxy);
}
public SimpleEnumCaAttribute(SimpleEnum e)
{
}
public string GetEnum(SimpleEnum id)
{
ThrowIfInsideThrowsController();
return id.ToString();
}
public static TestIntfPrx allTests(Ice.Communicator communicator)
#endif
{
string sref = "test:default -p 12010";
Ice.ObjectPrx obj = communicator.stringToProxy(sref);
test(obj != null);
TestIntfPrx proxy = TestIntfPrxHelper.uncheckedCast(obj);
test(proxy != null);
Console.Out.Write("testing enum values... ");
Console.Out.Flush();
test((int)ByteEnum.benum1 == 0);
test((int)ByteEnum.benum2 == 1);
test((int)ByteEnum.benum3 == ByteConst1.value);
test((int)ByteEnum.benum4 == ByteConst1.value + 1);
test((int)ByteEnum.benum5 == ShortConst1.value);
test((int)ByteEnum.benum6 == ShortConst1.value + 1);
test((int)ByteEnum.benum7 == IntConst1.value);
test((int)ByteEnum.benum8 == IntConst1.value + 1);
test((int)ByteEnum.benum9 == LongConst1.value);
test((int)ByteEnum.benum10 == LongConst1.value + 1);
test((int)ByteEnum.benum11 == ByteConst2.value);
test((int)ShortEnum.senum1 == 3);
test((int)ShortEnum.senum2 == 4);
test((int)ShortEnum.senum3 == ByteConst1.value);
test((int)ShortEnum.senum4 == ByteConst1.value + 1);
test((int)ShortEnum.senum5 == ShortConst1.value);
test((int)ShortEnum.senum6 == ShortConst1.value + 1);
test((int)ShortEnum.senum7 == IntConst1.value);
test((int)ShortEnum.senum8 == IntConst1.value + 1);
test((int)ShortEnum.senum9 == LongConst1.value);
test((int)ShortEnum.senum10 == LongConst1.value + 1);
test((int)ShortEnum.senum11 == ShortConst2.value);
test((int)IntEnum.ienum1 == 0);
test((int)IntEnum.ienum2 == 1);
test((int)IntEnum.ienum3 == ByteConst1.value);
test((int)IntEnum.ienum4 == ByteConst1.value + 1);
test((int)IntEnum.ienum5 == ShortConst1.value);
test((int)IntEnum.ienum6 == ShortConst1.value + 1);
test((int)IntEnum.ienum7 == IntConst1.value);
test((int)IntEnum.ienum8 == IntConst1.value + 1);
test((int)IntEnum.ienum9 == LongConst1.value);
test((int)IntEnum.ienum10 == LongConst1.value + 1);
test((int)IntEnum.ienum11 == IntConst2.value);
test((int)IntEnum.ienum12 == LongConst2.value);
test((int)SimpleEnum.red == 0);
test((int)SimpleEnum.green == 1);
test((int)SimpleEnum.blue == 2);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum streaming... ");
Console.Out.Flush();
Ice.OutputStream ostr;
byte[] bytes;
bool encoding_1_0 = communicator.getProperties().getProperty("Ice.Default.EncodingVersion").Equals("1.0");
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)ByteEnum.benum11, (int)ByteEnum.benum11);
bytes = ostr.finished();
test(bytes.Length == 1); // ByteEnum should require one byte
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)ShortEnum.senum11, (int)ShortEnum.senum11);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 2 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)IntEnum.ienum11, (int)IntEnum.ienum12);
bytes = ostr.finished();
test(bytes.Length == (encoding_1_0 ? 4 : 5));
ostr = new Ice.OutputStream(communicator);
ostr.writeEnum((int)SimpleEnum.blue, (int)SimpleEnum.blue);
bytes = ostr.finished();
test(bytes.Length == 1); // SimpleEnum should require one byte
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum operations... ");
Console.Out.Flush();
ByteEnum byteEnum;
test(proxy.opByte(ByteEnum.benum1, out byteEnum) == ByteEnum.benum1);
test(byteEnum == ByteEnum.benum1);
test(proxy.opByte(ByteEnum.benum11, out byteEnum) == ByteEnum.benum11);
test(byteEnum == ByteEnum.benum11);
ShortEnum shortEnum;
test(proxy.opShort(ShortEnum.senum1, out shortEnum) == ShortEnum.senum1);
test(shortEnum == ShortEnum.senum1);
test(proxy.opShort(ShortEnum.senum11, out shortEnum) == ShortEnum.senum11);
test(shortEnum == ShortEnum.senum11);
IntEnum intEnum;
test(proxy.opInt(IntEnum.ienum1, out intEnum) == IntEnum.ienum1);
test(intEnum == IntEnum.ienum1);
test(proxy.opInt(IntEnum.ienum11, out intEnum) == IntEnum.ienum11);
test(intEnum == IntEnum.ienum11);
test(proxy.opInt(IntEnum.ienum12, out intEnum) == IntEnum.ienum12);
test(intEnum == IntEnum.ienum12);
SimpleEnum s;
test(proxy.opSimple(SimpleEnum.green, out s) == SimpleEnum.green);
test(s == SimpleEnum.green);
Console.Out.WriteLine("ok");
Console.Out.Write("testing enum sequences operations... ");
Console.Out.Flush();
{
ByteEnum[] b1 = new ByteEnum[11]
{ ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5,
ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10,
ByteEnum.benum11};
ByteEnum[] b2;
ByteEnum[] b3 = proxy.opByteSeq(b1, out b2);
for(int i = 0; i < b1.Length; ++i)
{
test(b1[i] == b2[i]);
test(b1[i] == b3[i]);
}
}
{
ShortEnum[] s1 = new ShortEnum[11]
{ ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5,
ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10,
ShortEnum.senum11};
ShortEnum[] s2;
ShortEnum[] s3 = proxy.opShortSeq(s1, out s2);
for(int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
{
IntEnum[] i1 = new IntEnum[11]
{ IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5,
IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10,
IntEnum.ienum11};
IntEnum[] i2;
IntEnum[] i3 = proxy.opIntSeq(i1, out i2);
for(int i = 0; i < i1.Length; ++i)
{
test(i1[i] == i2[i]);
test(i1[i] == i3[i]);
}
}
{
SimpleEnum[] s1 = new SimpleEnum[3]
{ SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue };
SimpleEnum[] s2;
SimpleEnum[] s3 = proxy.opSimpleSeq(s1, out s2);
for(int i = 0; i < s1.Length; ++i)
{
test(s1[i] == s2[i]);
test(s1[i] == s3[i]);
}
}
Console.Out.WriteLine("ok");
#if SILVERLIGHT
proxy.shutdown();
#else
return proxy;
#endif
}
public Item(SimpleEnum value)
{
_value = value;
}
