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 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 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 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 }