public static Test.MyClassPrx allTests(Ice.Communicator communicator, bool collocated) #endif { #if SILVERLIGHT bool collocated = false; #endif Flush(); string rf = "test:default -p 12010"; Ice.ObjectPrx baseProxy = communicator.stringToProxy(rf); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); Write("testing twoway operations... "); Flush(); Twoways.twoways(communicator, cl); WriteLine("ok"); if (!collocated) { Write("testing twoway operations with AMI... "); Flush(); TwowaysAMI.twowaysAMI(communicator, cl); WriteLine("ok"); } #if SILVERLIGHT cl.shutdown(); #else return(cl); #endif }
opMyClassAsync(Test.MyClassPrx p1, Ice.Current current) { var p2 = p1; var p3 = Test.MyClassPrx.UncheckedCast(current.Adapter.CreateProxy("noSuchIdentity")); return(Task.FromResult((Test.MyClassPrx.UncheckedCast(current.Adapter.CreateProxy(current.Id)), p2, p3))); }
internal static void oneways(TestCommon.Application app, Test.MyClassPrx p) { Ice.Communicator communicator = app.communicator(); p = Test.MyClassPrxHelper.uncheckedCast(p.ice_oneway()); { p.ice_ping(); } { p.opVoid(); } { p.opIdempotent(); } { p.opNonmutating(); } { byte b; try { p.opByte((byte)0xff, (byte)0x0f, out b); test(false); } catch (System.ArgumentException) { } } }
public Test.MyClassPrx opMyClass(Test.MyClassPrx p1, out Test.MyClassPrx p2, out Test.MyClassPrx p3, Current current) { p2 = p1; p3 = Test.MyClassPrx.UncheckedCast(current.adapter.CreateProxy("noSuchIdentity")); return(Test.MyClassPrx.UncheckedCast(current.adapter.CreateProxy(current.id))); }
internal static void oneways(global::Test.TestHelper helper, Test.MyClassPrx p) { Communicator communicator = helper.communicator(); p = p.Clone(oneway: true); { p.IcePing(); } { p.opVoid(); } { p.opIdempotent(); } { p.opNonmutating(); } { byte b; try { p.opByte(0xff, 0x0f, out b); test(false); } catch (TwowayOnlyException) { } } }
public static Test.MyClassPrx allTests(global::Test.TestHelper helper, bool collocated) { var communicator = helper.communicator(); var output = helper.getWriter(); output.Flush(); string rf = "test:" + helper.getTestEndpoint(0); var baseProxy = communicator.stringToProxy(rf); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); output.Write("testing twoway operations... "); output.Flush(); Twoways.twoways(communicator, cl); output.WriteLine("ok"); if (!collocated) { output.Write("testing twoway operations with AMI... "); output.Flush(); TwowaysAMI.twowaysAMI(communicator, cl); output.WriteLine("ok"); } return(cl); }
public void opMyClass_async(Test.AMD_MyClass_opMyClass cb, Test.MyClassPrx p1, Ice.Current current) { Test.MyClassPrx p2 = p1; Test.MyClassPrx p3 = Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( current.adapter.getCommunicator().stringToIdentity("noSuchIdentity"))); cb.ice_response(Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3); }
internal static void oneways(Ice.Communicator communicator, Test.MyClassPrx p) { p = Test.MyClassPrxHelper.uncheckedCast(p.ice_oneway()); { p.ice_ping(); } { p.opVoid(); } { p.opIdempotent(); } { p.opNonmutating(); } { byte b; try { p.opByte((byte)0xff, (byte)0x0f, out b); test(false); } catch (Ice.TwowayOnlyException) { } } }
public Test.MyClassPrx opMyClass(Test.MyClassPrx p1, out Test.MyClassPrx p2, out Test.MyClassPrx p3, Ice.Current current) { p2 = p1; p3 = Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( Ice.Util.stringToIdentity("noSuchIdentity"))); return(Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id))); }
private static int run(String[] args, Ice.Communicator communicator) { Test.MyClassPrx myClass = AllTests.allTests(communicator); myClass.shutdown(); return(0); }
public override Test.MyClassPrx opMyClass(Test.MyClassPrx p1, out Test.MyClassPrx p2, out Test.MyClassPrx p3, Ice.Current current) { p2 = p1; p3 = Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( current.adapter.getCommunicator().stringToIdentity("noSuchIdentity"))); return(Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id))); }
opMyClassAsync(Test.MyClassPrx p1, Ice.Current current) { var p2 = p1; var p3 = Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy( Ice.Util.stringToIdentity("noSuchIdentity"))); return(Task.FromResult(new Test.MyClass_OpMyClassResult( Test.MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3))); }
private static int run(String[] args, Ice.Communicator communicator) { Test.MyClassPrx myClass = AllTests.allTests(communicator, false); Console.Out.Write("shutting down server... "); Console.Out.Flush(); myClass.shutdown(); Console.Out.WriteLine("ok"); return(0); }
public override int run(string[] args) { Test.MyClassPrx myClass = AllTests.allTests(this, false); Console.Out.Write("shutting down server... "); Console.Out.Flush(); myClass.shutdown(); Console.Out.WriteLine("ok"); return(0); }
public static Test.MyClassPrx allTests(Ice.Communicator communicator) #endif { Flush(); string rf = "test:default -p 12010"; Ice.ObjectPrx baseProxy = communicator.stringToProxy(rf); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); Test.MyDerivedClassPrx derivedProxy = Test.MyDerivedClassPrxHelper.checkedCast(cl); Write("testing twoway operations... "); Flush(); Twoways.twoways(communicator, cl); Twoways.twoways(communicator, derivedProxy); derivedProxy.opDerived(); WriteLine("ok"); Write("testing oneway operations... "); Flush(); Oneways.oneways(communicator, cl); WriteLine("ok"); Write("testing twoway operations with AMI... "); Flush(); TwowaysAMI.twowaysAMI(communicator, cl); TwowaysAMI.twowaysAMI(communicator, derivedProxy); WriteLine("ok"); Write("testing oneway operations with AMI... "); Flush(); OnewaysAMI.onewaysAMI(communicator, cl); WriteLine("ok"); Write("testing batch oneway operations... "); Flush(); BatchOneways.batchOneways(cl); BatchOneways.batchOneways(derivedProxy); WriteLine("ok"); Write("testing batch AMI oneway operations... "); Flush(); BatchOnewaysAMI.batchOneways(cl); BatchOnewaysAMI.batchOneways(derivedProxy); WriteLine("ok"); #if SILVERLIGHT cl.shutdown(); #else return(cl); #endif }
public static Test.MyClassPrx allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Flush(); string rf = "test:" + app.getTestEndpoint(0); Ice.ObjectPrx baseProxy = communicator.stringToProxy(rf); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); Test.MyDerivedClassPrx derivedProxy = Test.MyDerivedClassPrxHelper.checkedCast(cl); Write("testing twoway operations... "); Flush(); Twoways.twoways(app, cl); Twoways.twoways(app, derivedProxy); derivedProxy.opDerived(); WriteLine("ok"); Write("testing oneway operations... "); Flush(); Oneways.oneways(app, cl); WriteLine("ok"); Write("testing twoway operations with AMI... "); Flush(); TwowaysAMI.twowaysAMI(app, cl); TwowaysAMI.twowaysAMI(app, derivedProxy); WriteLine("ok"); Write("testing oneway operations with AMI... "); Flush(); OnewaysAMI.onewaysAMI(app, cl); WriteLine("ok"); Write("testing batch oneway operations... "); Flush(); BatchOneways.batchOneways(cl); BatchOneways.batchOneways(derivedProxy); WriteLine("ok"); Write("testing batch AMI oneway operations... "); Flush(); BatchOnewaysAMI.batchOneways(cl); BatchOnewaysAMI.batchOneways(derivedProxy); WriteLine("ok"); return(cl); }
public override int run(string[] args) { Test.MyClassPrx myClass = AllTests.allTests(this); Console.Out.Write("testing server shutdown... "); Console.Out.Flush(); myClass.shutdown(); try { myClass.ice_timeout(100).ice_ping(); // Use timeout to speed up testing on Windows throw new System.Exception(); } catch (Ice.LocalException) { Console.Out.WriteLine("ok"); } return(0); }
internal static void onewaysAMI(Ice.Communicator communicator, Test.MyClassPrx p) { p = Test.MyClassPrxHelper.uncheckedCast(p.ice_oneway()); { AMI_MyClass_opVoidI cb = new AMI_MyClass_opVoidI(); p.opVoid_async(cb); // Let's check if we can reuse the same callback object for another call. p.opVoid_async(cb); } { AMI_MyClass_opIdempotentI cb = new AMI_MyClass_opIdempotentI(); p.opIdempotent_async(cb); } { AMI_MyClass_opNonmutatingI cb = new AMI_MyClass_opNonmutatingI(); p.opNonmutating_async(cb); } { // Check that a call to a void operation raises NoEndpointException // in the ice_exception() callback instead of at the point of call. Test.MyClassPrx indirect = Test.MyClassPrxHelper.uncheckedCast(p.ice_adapterId("dummy")); AMI_MyClass_opVoidExI cb = new AMI_MyClass_opVoidExI(); try { indirect.opVoid_async(cb); } catch (System.Exception) { test(false); } cb.check(); } { AMI_MyClass_opByteExI cb = new AMI_MyClass_opByteExI(); p.opByte_async(cb, (byte)0xff, (byte)0x0f); cb.check(); } }
private static int run(string[] args, Ice.Communicator communicator) { Test.MyClassPrx myClass = AllTests.allTests(communicator); Console.Out.Write("testing server shutdown... "); Console.Out.Flush(); myClass.shutdown(); try { myClass.opVoid(); throw new System.Exception(); } catch (Ice.LocalException) { Console.Out.WriteLine("ok"); } return(0); }
public override int run(string[] args) { Test.MyClassPrx myClass = AllTests.allTests(this); Console.Out.Write("testing server shutdown... "); Console.Out.Flush(); myClass.shutdown(); try { myClass.opVoid(); throw new System.Exception(); } catch (Ice.LocalException) { Console.Out.WriteLine("ok"); } return(0); }
public override void ice_response(Test.MyClassPrx r, Test.MyClassPrx c1, Test.MyClassPrx c2) { test(c1.ice_getIdentity().Equals(_communicator.stringToIdentity("test"))); test(c2.ice_getIdentity().Equals(_communicator.stringToIdentity("noSuchIdentity"))); test(r.ice_getIdentity().Equals(_communicator.stringToIdentity("test"))); // We can't do the callbacks below in thread per connection mode. if (_communicator.getProperties().getPropertyAsInt("Ice.ThreadPool.Client.Serialize") == 0) { r.opVoid(); c1.opVoid(); try { c2.opVoid(); test(false); } catch (Ice.ObjectNotExistException) { } } callback.called(); }
public static Test.MyClassPrx allTests(TestCommon.Application app, bool collocated) { Ice.Communicator communicator = app.communicator(); Flush(); string rf = "test:" + app.getTestEndpoint(0); Ice.ObjectPrx baseProxy = communicator.stringToProxy(rf); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); Write("testing twoway operations... "); Flush(); Twoways.twoways(communicator, cl); WriteLine("ok"); if (!collocated) { Write("testing twoway operations with AMI... "); Flush(); TwowaysAMI.twowaysAMI(communicator, cl); WriteLine("ok"); } return(cl); }
internal static void batchOneways(global::Test.TestHelper helper, Test.MyClassPrx p) { byte[] bs1 = new byte[10 * 1024]; Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch.ice_flushBatchRequests(); // Empty flush p.opByteSOnewayCallCount(); // Reset the call count for (int i = 0; i < 30; ++i) { try { batch.opByteSOneway(bs1); test(true); } catch (Ice.MemoryLimitException) { test(false); } } int count = 0; while (count < 27) // 3 * 9 requests auto-flushed. { count += p.opByteSOnewayCallCount(); System.Threading.Thread.Sleep(10); } if (batch.ice_getConnection() != null) { Test.MyClassPrx batch1 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch1.ice_ping(); batch2.ice_ping(); batch1.ice_flushBatchRequests(); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.ice_ping(); batch2.ice_ping(); batch1.ice_getConnection(); batch2.ice_getConnection(); batch1.ice_ping(); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.ice_ping(); batch2.ice_ping(); } Ice.Identity identity = new Ice.Identity(); identity.name = "invalid"; Ice.ObjectPrx batch3 = batch.ice_identity(identity); batch3.ice_ping(); batch3.ice_flushBatchRequests(); // Make sure that a bogus batch request doesn't cause troubles to other ones. batch3.ice_ping(); batch.ice_ping(); batch.ice_flushBatchRequests(); batch.ice_ping(); if (batch.ice_getConnection() != null) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = p.ice_getCommunicator().getProperties().ice_clone_(); BatchRequestInterceptorI interceptor = new BatchRequestInterceptorI(); initData.batchRequestInterceptor = interceptor.enqueue; Ice.Communicator ic = helper.initialize(initData); batch = Test.MyClassPrxHelper.uncheckedCast(ic.stringToProxy(p.ToString()).ice_batchOneway()); test(interceptor.count() == 0); batch.ice_ping(); batch.ice_ping(); batch.ice_ping(); test(interceptor.count() == 0); interceptor.setEnqueue(true); batch.ice_ping(); batch.ice_ping(); batch.ice_ping(); test(interceptor.count() == 3); batch.ice_flushBatchRequests(); batch.ice_ping(); test(interceptor.count() == 1); batch.opByteSOneway(bs1); test(interceptor.count() == 2); batch.opByteSOneway(bs1); test(interceptor.count() == 3); batch.opByteSOneway(bs1); // This should trigger the flush batch.ice_ping(); test(interceptor.count() == 2); ic.destroy(); } p.ice_ping(); bool supportsCompress = true; try { supportsCompress = p.supportsCompress(); } catch (Ice.OperationNotExistException) { } if (supportsCompress && p.ice_getConnection() != null && p.ice_getCommunicator().getProperties().getProperty("Ice.Override.Compress").Equals("")) { Ice.ObjectPrx prx = p.ice_getConnection().createProxy(p.ice_getIdentity()).ice_batchOneway(); Test.MyClassPrx batchC1 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(false)); Test.MyClassPrx batchC2 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(true)); Test.MyClassPrx batchC3 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_identity(identity)); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.Yes); batchC2.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.No); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); batchC1.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); batchC1.opByteSOneway(bs1); batchC3.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); } }
public static Test.MyClassPrx allTests(Ice.Communicator communicator) { Write("testing stringToProxy... "); Flush(); string rf = "test:default -p 12010"; Ice.ObjectPrx baseProxy = communicator.stringToProxy(rf); test(baseProxy != null); Ice.ObjectPrx b1 = communicator.stringToProxy("test"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getAdapterId().Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy("test "); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy(" test "); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy(" test"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy("'test -f facet'"); test(b1.ice_getIdentity().name.Equals("test -f facet") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); try { b1 = communicator.stringToProxy("\"test -f facet'"); test(false); } catch (Ice.ProxyParseException) { } b1 = communicator.stringToProxy("\"test -f facet\""); test(b1.ice_getIdentity().name.Equals("test -f facet") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy("\"test -f facet@test\""); test(b1.ice_getIdentity().name.Equals("test -f facet@test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); b1 = communicator.stringToProxy("\"test -f facet@test @test\""); test(b1.ice_getIdentity().name.Equals("test -f facet@test @test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Length == 0); try { b1 = communicator.stringToProxy("test test"); test(false); } catch (Ice.ProxyParseException) { } b1 = communicator.stringToProxy("test\\040test"); test(b1.ice_getIdentity().name.Equals("test test") && b1.ice_getIdentity().category.Length == 0); try { b1 = communicator.stringToProxy("test\\777"); test(false); } catch (Ice.IdentityParseException) { } b1 = communicator.stringToProxy("test\\40test"); test(b1.ice_getIdentity().name.Equals("test test")); // Test some octal and hex corner cases. b1 = communicator.stringToProxy("test\\4test"); test(b1.ice_getIdentity().name.Equals("test\u0004test")); b1 = communicator.stringToProxy("test\\04test"); test(b1.ice_getIdentity().name.Equals("test\u0004test")); b1 = communicator.stringToProxy("test\\004test"); test(b1.ice_getIdentity().name.Equals("test\u0004test")); b1 = communicator.stringToProxy("test\\1114test"); test(b1.ice_getIdentity().name.Equals("test\u00494test")); b1 = communicator.stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test"); test(b1.ice_getIdentity().name.Equals("test\b\f\n\r\t\'\"\\test") && b1.ice_getIdentity().category.Length == 0); b1 = communicator.stringToProxy("category/test"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category") && b1.ice_getAdapterId().Length == 0); b1 = communicator.stringToProxy(""); test(b1 == null); b1 = communicator.stringToProxy("\"\""); test(b1 == null); try { b1 = communicator.stringToProxy("\"\" test"); // Invalid trailing characters. test(false); } catch (Ice.ProxyParseException) { } try { b1 = communicator.stringToProxy("test:"); // Missing endpoint. test(false); } catch (Ice.EndpointParseException) { } b1 = communicator.stringToProxy("test@adapter"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getAdapterId().Equals("adapter")); try { b1 = communicator.stringToProxy("id@adapter test"); test(false); } catch (Ice.ProxyParseException) { } b1 = communicator.stringToProxy("category/test@adapter"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category") && b1.ice_getAdapterId().Equals("adapter")); b1 = communicator.stringToProxy("category/test@adapter:tcp"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category") && b1.ice_getAdapterId().Equals("adapter:tcp")); b1 = communicator.stringToProxy("'category 1/test'@adapter"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category 1") && b1.ice_getAdapterId().Equals("adapter")); b1 = communicator.stringToProxy("'category/test 1'@adapter"); test(b1.ice_getIdentity().name.Equals("test 1") && b1.ice_getIdentity().category.Equals("category") && b1.ice_getAdapterId().Equals("adapter")); b1 = communicator.stringToProxy("'category/test'@'adapter 1'"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category") && b1.ice_getAdapterId().Equals("adapter 1")); b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@adapter"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category /test@foo") && b1.ice_getAdapterId().Equals("adapter")); b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@\"adapter:tcp\""); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Equals("category /test@foo") && b1.ice_getAdapterId().Equals("adapter:tcp")); b1 = communicator.stringToProxy("id -f facet"); test(b1.ice_getIdentity().name.Equals("id") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet")); b1 = communicator.stringToProxy("id -f 'facet x'"); test(b1.ice_getIdentity().name.Equals("id") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet x")); b1 = communicator.stringToProxy("id -f \"facet x\""); test(b1.ice_getIdentity().name.Equals("id") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet x")); try { b1 = communicator.stringToProxy("id -f \"facet x"); test(false); } catch (Ice.ProxyParseException) { } try { b1 = communicator.stringToProxy("id -f \'facet x"); test(false); } catch (Ice.ProxyParseException) { } b1 = communicator.stringToProxy("test -f facet:tcp"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet") && b1.ice_getAdapterId().Length == 0); b1 = communicator.stringToProxy("test -f \"facet:tcp\""); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet:tcp") && b1.ice_getAdapterId().Length == 0); b1 = communicator.stringToProxy("test -f facet@test"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet") && b1.ice_getAdapterId().Equals("test")); b1 = communicator.stringToProxy("test -f 'facet@test'"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet@test") && b1.ice_getAdapterId().Length == 0); b1 = communicator.stringToProxy("test -f 'facet@test'@test"); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getFacet().Equals("facet@test") && b1.ice_getAdapterId().Equals("test")); try { b1 = communicator.stringToProxy("test -f facet@test @test"); test(false); } catch (Ice.ProxyParseException) { } b1 = communicator.stringToProxy("test"); test(b1.ice_isTwoway()); b1 = communicator.stringToProxy("test -t"); test(b1.ice_isTwoway()); b1 = communicator.stringToProxy("test -o"); test(b1.ice_isOneway()); b1 = communicator.stringToProxy("test -O"); test(b1.ice_isBatchOneway()); b1 = communicator.stringToProxy("test -d"); test(b1.ice_isDatagram()); b1 = communicator.stringToProxy("test -D"); test(b1.ice_isBatchDatagram()); b1 = communicator.stringToProxy("test"); test(!b1.ice_isSecure()); b1 = communicator.stringToProxy("test -s"); test(b1.ice_isSecure()); test(b1.ice_getEncodingVersion().Equals(Ice.Util.currentEncoding)); b1 = communicator.stringToProxy("test -e 1.0"); test(b1.ice_getEncodingVersion().major == 1 && b1.ice_getEncodingVersion().minor == 0); b1 = communicator.stringToProxy("test -e 6.5"); test(b1.ice_getEncodingVersion().major == 6 && b1.ice_getEncodingVersion().minor == 5); b1 = communicator.stringToProxy("test -p 1.0 -e 1.0"); test(b1.ToString().Equals("test -t -e 1.0")); b1 = communicator.stringToProxy("test -p 6.5 -e 1.0"); test(b1.ToString().Equals("test -t -p 6.5 -e 1.0")); try { b1 = communicator.stringToProxy("test:tcp@adapterId"); test(false); } catch (Ice.EndpointParseException) { } // This is an unknown endpoint warning, not a parse exception. // //try //{ // b1 = communicator.stringToProxy("test -f the:facet:tcp"); // test(false); //} //catch(Ice.EndpointParseException) //{ //} try { b1 = communicator.stringToProxy("test::tcp"); test(false); } catch (Ice.EndpointParseException) { } // // Test for bug ICE-5543: escaped escapes in stringToIdentity // Ice.Identity id = new Ice.Identity("test", ",X2QNUAzSBcJ_e$AV;E\\"); Ice.Identity id2 = communicator.stringToIdentity(communicator.identityToString(id)); test(id.Equals(id2)); id = new Ice.Identity("test", ",X2QNUAz\\SB\\/cJ_e$AV;E\\\\"); id2 = communicator.stringToIdentity(communicator.identityToString(id)); test(id.Equals(id2)); WriteLine("ok"); Write("testing propertyToProxy... "); Flush(); Ice.Properties prop = communicator.getProperties(); String propertyPrefix = "Foo.Proxy"; prop.setProperty(propertyPrefix, "test:default -p 12010"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getIdentity().name.Equals("test") && b1.ice_getIdentity().category.Length == 0 && b1.ice_getAdapterId().Length == 0 && b1.ice_getFacet().Length == 0); String property; property = propertyPrefix + ".Locator"; test(b1.ice_getLocator() == null); prop.setProperty(property, "locator:default -p 10000"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getLocator() != null && b1.ice_getLocator().ice_getIdentity().name.Equals("locator")); try { prop.setProperty(property, ""); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } property = propertyPrefix + ".LocatorCacheTimeout"; test(b1.ice_getLocatorCacheTimeout() == -1); prop.setProperty(property, "1"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getLocatorCacheTimeout() == 1); prop.setProperty(property, ""); // Now retest with an indirect proxy. prop.setProperty(propertyPrefix, "test"); property = propertyPrefix + ".Locator"; prop.setProperty(property, "locator:default -p 10000"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getLocator() != null && b1.ice_getLocator().ice_getIdentity().name.Equals("locator")); prop.setProperty(property, ""); property = propertyPrefix + ".LocatorCacheTimeout"; test(b1.ice_getLocatorCacheTimeout() == -1); prop.setProperty(property, "1"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getLocatorCacheTimeout() == 1); prop.setProperty(property, ""); // This cannot be tested so easily because the property is cached // on communicator initialization. // //prop.setProperty("Ice.Default.LocatorCacheTimeout", "60"); //b1 = communicator.propertyToProxy(propertyPrefix); //test(b1.ice_getLocatorCacheTimeout() == 60); //prop.setProperty("Ice.Default.LocatorCacheTimeout", ""); prop.setProperty(propertyPrefix, "test:default -p 12010"); property = propertyPrefix + ".Router"; test(b1.ice_getRouter() == null); prop.setProperty(property, "router:default -p 10000"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getRouter() != null && b1.ice_getRouter().ice_getIdentity().name.Equals("router")); prop.setProperty(property, ""); property = propertyPrefix + ".PreferSecure"; test(!b1.ice_isPreferSecure()); prop.setProperty(property, "1"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_isPreferSecure()); prop.setProperty(property, ""); property = propertyPrefix + ".ConnectionCached"; test(b1.ice_isConnectionCached()); prop.setProperty(property, "0"); b1 = communicator.propertyToProxy(propertyPrefix); test(!b1.ice_isConnectionCached()); prop.setProperty(property, ""); property = propertyPrefix + ".InvocationTimeout"; test(b1.ice_getInvocationTimeout() == -1); prop.setProperty(property, "1000"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getInvocationTimeout() == 1000); prop.setProperty(property, ""); property = propertyPrefix + ".EndpointSelection"; test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random); prop.setProperty(property, "Random"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random); prop.setProperty(property, "Ordered"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered); prop.setProperty(property, ""); property = propertyPrefix + ".CollocationOptimized"; test(b1.ice_isCollocationOptimized()); prop.setProperty(property, "0"); b1 = communicator.propertyToProxy(propertyPrefix); test(!b1.ice_isCollocationOptimized()); prop.setProperty(property, ""); property = propertyPrefix + ".Context.c1"; test(!b1.ice_getContext().ContainsKey("c1")); prop.setProperty(property, "TEST"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getContext()["c1"].Equals("TEST")); property = propertyPrefix + ".Context.c2"; test(!b1.ice_getContext().ContainsKey("c2")); prop.setProperty(property, "TEST"); b1 = communicator.propertyToProxy(propertyPrefix); test(b1.ice_getContext()["c2"].Equals("TEST")); prop.setProperty(propertyPrefix + ".Context.c1", ""); prop.setProperty(propertyPrefix + ".Context.c2", ""); WriteLine("ok"); Write("testing proxyToProperty... "); Flush(); b1 = communicator.stringToProxy("test"); b1 = b1.ice_collocationOptimized(true); b1 = b1.ice_connectionCached(true); b1 = b1.ice_preferSecure(false); b1 = b1.ice_endpointSelection(Ice.EndpointSelectionType.Ordered); b1 = b1.ice_locatorCacheTimeout(100); b1 = b1.ice_invocationTimeout(1234); b1 = b1.ice_encodingVersion(new Ice.EncodingVersion(1, 0)); Ice.ObjectPrx router = communicator.stringToProxy("router"); router = router.ice_collocationOptimized(false); router = router.ice_connectionCached(true); router = router.ice_preferSecure(true); router = router.ice_endpointSelection(Ice.EndpointSelectionType.Random); router = router.ice_locatorCacheTimeout(200); router = router.ice_invocationTimeout(1500); Ice.ObjectPrx locator = communicator.stringToProxy("locator"); locator = locator.ice_collocationOptimized(true); locator = locator.ice_connectionCached(false); locator = locator.ice_preferSecure(true); locator = locator.ice_endpointSelection(Ice.EndpointSelectionType.Random); locator = locator.ice_locatorCacheTimeout(300); locator = locator.ice_invocationTimeout(1500); locator = locator.ice_router(Ice.RouterPrxHelper.uncheckedCast(router)); b1 = b1.ice_locator(Ice.LocatorPrxHelper.uncheckedCast(locator)); Dictionary <string, string> proxyProps = communicator.proxyToProperty(b1, "Test"); test(proxyProps.Count == 21); test(proxyProps["Test"].Equals("test -t -e 1.0")); test(proxyProps["Test.CollocationOptimized"].Equals("1")); test(proxyProps["Test.ConnectionCached"].Equals("1")); test(proxyProps["Test.PreferSecure"].Equals("0")); test(proxyProps["Test.EndpointSelection"].Equals("Ordered")); test(proxyProps["Test.LocatorCacheTimeout"].Equals("100")); test(proxyProps["Test.InvocationTimeout"].Equals("1234")); test(proxyProps["Test.Locator"].Equals( "locator -t -e " + Ice.Util.encodingVersionToString(Ice.Util.currentEncoding))); // Locator collocation optimization is always disabled. //test(proxyProps["Test.Locator.CollocationOptimized"].Equals("1")); test(proxyProps["Test.Locator.ConnectionCached"].Equals("0")); test(proxyProps["Test.Locator.PreferSecure"].Equals("1")); test(proxyProps["Test.Locator.EndpointSelection"].Equals("Random")); test(proxyProps["Test.Locator.LocatorCacheTimeout"].Equals("300")); test(proxyProps["Test.Locator.InvocationTimeout"].Equals("1500")); test(proxyProps["Test.Locator.Router"].Equals( "router -t -e " + Ice.Util.encodingVersionToString(Ice.Util.currentEncoding))); test(proxyProps["Test.Locator.Router.CollocationOptimized"].Equals("0")); test(proxyProps["Test.Locator.Router.ConnectionCached"].Equals("1")); test(proxyProps["Test.Locator.Router.PreferSecure"].Equals("1")); test(proxyProps["Test.Locator.Router.EndpointSelection"].Equals("Random")); test(proxyProps["Test.Locator.Router.LocatorCacheTimeout"].Equals("200")); test(proxyProps["Test.Locator.Router.InvocationTimeout"].Equals("1500")); WriteLine("ok"); Write("testing ice_getCommunicator... "); Flush(); test(baseProxy.ice_getCommunicator() == communicator); WriteLine("ok"); Write("testing proxy methods... "); test(communicator.identityToString( baseProxy.ice_identity(communicator.stringToIdentity("other")).ice_getIdentity()).Equals("other")); test(baseProxy.ice_facet("facet").ice_getFacet().Equals("facet")); test(baseProxy.ice_adapterId("id").ice_getAdapterId().Equals("id")); test(baseProxy.ice_twoway().ice_isTwoway()); test(baseProxy.ice_oneway().ice_isOneway()); test(baseProxy.ice_batchOneway().ice_isBatchOneway()); test(baseProxy.ice_datagram().ice_isDatagram()); test(baseProxy.ice_batchDatagram().ice_isBatchDatagram()); test(baseProxy.ice_secure(true).ice_isSecure()); test(!baseProxy.ice_secure(false).ice_isSecure()); test(baseProxy.ice_collocationOptimized(true).ice_isCollocationOptimized()); test(!baseProxy.ice_collocationOptimized(false).ice_isCollocationOptimized()); test(baseProxy.ice_preferSecure(true).ice_isPreferSecure()); test(!baseProxy.ice_preferSecure(false).ice_isPreferSecure()); try { baseProxy.ice_timeout(0); test(false); } catch (ArgumentException) { } try { baseProxy.ice_timeout(-1); } catch (ArgumentException) { test(false); } try { baseProxy.ice_timeout(-2); test(false); } catch (ArgumentException) { } try { baseProxy.ice_invocationTimeout(0); test(false); } catch (ArgumentException) { } try { baseProxy.ice_invocationTimeout(-1); baseProxy.ice_invocationTimeout(-2); } catch (ArgumentException) { test(false); } try { baseProxy.ice_invocationTimeout(-3); test(false); } catch (ArgumentException) { } try { baseProxy.ice_locatorCacheTimeout(0); } catch (ArgumentException) { test(false); } try { baseProxy.ice_locatorCacheTimeout(-1); } catch (ArgumentException) { test(false); } try { baseProxy.ice_locatorCacheTimeout(-2); test(false); } catch (ArgumentException) { } WriteLine("ok"); Write("testing proxy comparison... "); Flush(); test(communicator.stringToProxy("foo").Equals(communicator.stringToProxy("foo"))); test(!communicator.stringToProxy("foo").Equals(communicator.stringToProxy("foo2"))); Ice.ObjectPrx compObj = communicator.stringToProxy("foo"); test(compObj.ice_facet("facet").Equals(compObj.ice_facet("facet"))); test(!compObj.ice_facet("facet").Equals(compObj.ice_facet("facet1"))); test(compObj.ice_oneway().Equals(compObj.ice_oneway())); test(!compObj.ice_oneway().Equals(compObj.ice_twoway())); test(compObj.ice_secure(true).Equals(compObj.ice_secure(true))); test(!compObj.ice_secure(false).Equals(compObj.ice_secure(true))); test(compObj.ice_collocationOptimized(true).Equals(compObj.ice_collocationOptimized(true))); test(!compObj.ice_collocationOptimized(false).Equals(compObj.ice_collocationOptimized(true))); test(compObj.ice_connectionCached(true).Equals(compObj.ice_connectionCached(true))); test(!compObj.ice_connectionCached(false).Equals(compObj.ice_connectionCached(true))); test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random).Equals( compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random))); test(!compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random).Equals( compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered))); test(compObj.ice_connectionId("id2").Equals(compObj.ice_connectionId("id2"))); test(!compObj.ice_connectionId("id1").Equals(compObj.ice_connectionId("id2"))); test(compObj.ice_connectionId("id1").ice_getConnectionId().Equals("id1")); test(compObj.ice_connectionId("id2").ice_getConnectionId().Equals("id2")); test(compObj.ice_compress(true).Equals(compObj.ice_compress(true))); test(!compObj.ice_compress(false).Equals(compObj.ice_compress(true))); test(compObj.ice_timeout(20).Equals(compObj.ice_timeout(20))); test(!compObj.ice_timeout(10).Equals(compObj.ice_timeout(20))); Ice.LocatorPrx loc1 = Ice.LocatorPrxHelper.uncheckedCast(communicator.stringToProxy("loc1:default -p 10000")); Ice.LocatorPrx loc2 = Ice.LocatorPrxHelper.uncheckedCast(communicator.stringToProxy("loc2:default -p 10000")); test(compObj.ice_locator(null).Equals(compObj.ice_locator(null))); test(compObj.ice_locator(loc1).Equals(compObj.ice_locator(loc1))); test(!compObj.ice_locator(loc1).Equals(compObj.ice_locator(null))); test(!compObj.ice_locator(null).Equals(compObj.ice_locator(loc2))); test(!compObj.ice_locator(loc1).Equals(compObj.ice_locator(loc2))); Ice.RouterPrx rtr1 = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("rtr1:default -p 10000")); Ice.RouterPrx rtr2 = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("rtr2:default -p 10000")); test(compObj.ice_router(null).Equals(compObj.ice_router(null))); test(compObj.ice_router(rtr1).Equals(compObj.ice_router(rtr1))); test(!compObj.ice_router(rtr1).Equals(compObj.ice_router(null))); test(!compObj.ice_router(null).Equals(compObj.ice_router(rtr2))); test(!compObj.ice_router(rtr1).Equals(compObj.ice_router(rtr2))); Dictionary <string, string> ctx1 = new Dictionary <string, string>(); ctx1["ctx1"] = "v1"; Dictionary <string, string> ctx2 = new Dictionary <string, string>(); ctx2["ctx2"] = "v2"; test(compObj.ice_context(null).Equals(compObj.ice_context(null))); test(compObj.ice_context(ctx1).Equals(compObj.ice_context(ctx1))); test(!compObj.ice_context(ctx1).Equals(compObj.ice_context(null))); test(!compObj.ice_context(null).Equals(compObj.ice_context(ctx2))); test(!compObj.ice_context(ctx1).Equals(compObj.ice_context(ctx2))); test(compObj.ice_preferSecure(true).Equals(compObj.ice_preferSecure(true))); test(!compObj.ice_preferSecure(true).Equals(compObj.ice_preferSecure(false))); Ice.ObjectPrx compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000"); Ice.ObjectPrx compObj2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001"); test(!compObj1.Equals(compObj2)); compObj1 = communicator.stringToProxy("foo@MyAdapter1"); compObj2 = communicator.stringToProxy("foo@MyAdapter2"); test(!compObj1.Equals(compObj2)); test(compObj1.ice_locatorCacheTimeout(20).Equals(compObj1.ice_locatorCacheTimeout(20))); test(!compObj1.ice_locatorCacheTimeout(10).Equals(compObj1.ice_locatorCacheTimeout(20))); test(compObj1.ice_invocationTimeout(20).Equals(compObj1.ice_invocationTimeout(20))); test(!compObj1.ice_invocationTimeout(10).Equals(compObj1.ice_invocationTimeout(20))); compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 1000"); compObj2 = communicator.stringToProxy("foo@MyAdapter1"); test(!compObj1.Equals(compObj2)); Ice.Endpoint[] endpts1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000").ice_getEndpoints(); Ice.Endpoint[] endpts2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001").ice_getEndpoints(); test(!endpts1[0].Equals(endpts2[0])); test(endpts1[0].Equals(communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000").ice_getEndpoints()[0])); // // TODO: Ideally we should also test comparison of fixed proxies. // WriteLine("ok"); Write("testing checked cast... "); Flush(); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); test(cl != null); Test.MyDerivedClassPrx derived = Test.MyDerivedClassPrxHelper.checkedCast(cl); test(derived != null); test(cl.Equals(baseProxy)); test(derived.Equals(baseProxy)); test(cl.Equals(derived)); WriteLine("ok"); Write("testing checked cast with context... "); Flush(); Dictionary <string, string> c = cl.getContext(); test(c == null || c.Count == 0); c = new Dictionary <string, string>(); c["one"] = "hello"; c["two"] = "world"; cl = Test.MyClassPrxHelper.checkedCast(baseProxy, c); Dictionary <string, string> c2 = cl.getContext(); test(Ice.CollectionComparer.Equals(c, c2)); WriteLine("ok"); Write("testing encoding versioning... "); Flush(); string ref20 = "test -e 2.0:default -p 12010"; Test.MyClassPrx cl20 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref20)); try { cl20.ice_ping(); test(false); } catch (Ice.UnsupportedEncodingException) { // Server 2.0 endpoint doesn't support 1.1 version. } string ref10 = "test -e 1.0:default -p 12010"; Test.MyClassPrx cl10 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref10)); cl10.ice_ping(); cl10.ice_encodingVersion(Ice.Util.Encoding_1_0).ice_ping(); cl.ice_encodingVersion(Ice.Util.Encoding_1_0).ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.1, the // call will use the 1.1 encoding string ref13 = "test -e 1.3:default -p 12010"; Test.MyClassPrx cl13 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref13)); cl13.ice_ping(); cl13.end_ice_ping(cl13.begin_ice_ping()); try { // Send request with bogus 1.2 encoding. Ice.EncodingVersion version = new Ice.EncodingVersion(1, 2); Ice.OutputStream os = new Ice.OutputStream(communicator); os.startEncapsulation(); os.endEncapsulation(); byte[] inEncaps = os.finished(); inEncaps[4] = version.major; inEncaps[5] = version.minor; byte[] outEncaps; cl.ice_invoke("ice_ping", Ice.OperationMode.Normal, inEncaps, out outEncaps); test(false); } catch (Ice.UnknownLocalException ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.IndexOf("UnsupportedEncodingException") > 0); } try { // Send request with bogus 2.0 encoding. Ice.EncodingVersion version = new Ice.EncodingVersion(2, 0); Ice.OutputStream os = new Ice.OutputStream(communicator); os.startEncapsulation(); os.endEncapsulation(); byte[] inEncaps = os.finished(); inEncaps[4] = version.major; inEncaps[5] = version.minor; byte[] outEncaps; cl.ice_invoke("ice_ping", Ice.OperationMode.Normal, inEncaps, out outEncaps); test(false); } catch (Ice.UnknownLocalException ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.IndexOf("UnsupportedEncodingException") > 0); } WriteLine("ok"); Write("testing protocol versioning... "); Flush(); ref20 = "test -p 2.0:default -p 12010"; cl20 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref20)); try { cl20.ice_ping(); test(false); } catch (Ice.UnsupportedProtocolException) { // Server 2.0 proxy doesn't support 1.0 version. } ref10 = "test -p 1.0:default -p 12010"; cl10 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref10)); cl10.ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.1, the // call will use the 1.1 protocol ref13 = "test -p 1.3:default -p 12010"; cl13 = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy(ref13)); cl13.ice_ping(); cl13.end_ice_ping(cl13.begin_ice_ping()); WriteLine("ok"); Write("testing opaque endpoints... "); Flush(); try { // Invalid -x option communicator.stringToProxy("id:opaque -t 99 -v abc -x abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Missing -t and -v communicator.stringToProxy("id:opaque"); test(false); } catch (Ice.EndpointParseException) { } try { // Repeated -t communicator.stringToProxy("id:opaque -t 1 -t 1 -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Repeated -v communicator.stringToProxy("id:opaque -t 1 -v abc -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Missing -t communicator.stringToProxy("id:opaque -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Missing -v communicator.stringToProxy("id:opaque -t 1"); test(false); } catch (Ice.EndpointParseException) { } try { // Missing arg for -t communicator.stringToProxy("id:opaque -t -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Missing arg for -v communicator.stringToProxy("id:opaque -t 1 -v"); test(false); } catch (Ice.EndpointParseException) { } try { // Not a number for -t communicator.stringToProxy("id:opaque -t x -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // < 0 for -t communicator.stringToProxy("id:opaque -t -1 -v abc"); test(false); } catch (Ice.EndpointParseException) { } try { // Invalid char for -v communicator.stringToProxy("id:opaque -t 99 -v x?c"); test(false); } catch (Ice.EndpointParseException) { } // Legal TCP endpoint expressed as opaque endpoint Ice.ObjectPrx p1 = communicator.stringToProxy("test -e 1.1:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); string pstr = communicator.proxyToString(p1); test(pstr.Equals("test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000")); // Opaque endpoint encoded with 1.1 encoding. Ice.ObjectPrx p2 = communicator.stringToProxy("test -e 1.1:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); test(communicator.proxyToString(p2).Equals("test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000")); if (communicator.getProperties().getPropertyAsInt("Ice.IPv6") == 0) { // Working? bool ssl = communicator.getProperties().getProperty("Ice.Default.Protocol").Equals("ssl"); bool tcp = communicator.getProperties().getProperty("Ice.Default.Protocol").Equals("tcp"); if (tcp) { p1.ice_encodingVersion(Ice.Util.Encoding_1_0).ice_ping(); } // Two legal TCP endpoints expressed as opaque endpoints p1 = communicator.stringToProxy("test -e 1.0:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="); pstr = communicator.proxyToString(p1); test(pstr.Equals("test -t -e 1.0:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000")); // Test that an SSL endpoint and a nonsense endpoint get written back out as an opaque endpoint. p1 = communicator.stringToProxy("test -e 1.0:opaque -e 1.0 -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -e 1.0 -t 99 -v abch"); pstr = communicator.proxyToString(p1); if (ssl) { test(pstr.Equals("test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch")); } else if (tcp) { test(pstr.Equals( "test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch")); } } WriteLine("ok"); return(cl); }
internal static void batchOneways(Test.MyClassPrx p) { byte[] bs1 = new byte[10 * 1024]; Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests()); test(batch.begin_ice_flushBatchRequests().isSent()); test(batch.begin_ice_flushBatchRequests().isCompleted_()); test(batch.begin_ice_flushBatchRequests().sentSynchronously()); for (int i = 0; i < 30; ++i) { batch.begin_opByteSOneway(bs1).whenCompleted( () => { }, (Ice.Exception ex) => { test(false); }); } int count = 0; while (count < 27) // 3 * 9 requests auto-flushed. { count += p.opByteSOnewayCallCount(); System.Threading.Thread.Sleep(10); } if (batch.ice_getConnection() != null) { Test.MyClassPrx batch1 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch1.begin_ice_ping(); batch2.begin_ice_ping(); batch1.end_ice_flushBatchRequests(batch1.begin_ice_flushBatchRequests()); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.begin_ice_ping(); batch2.begin_ice_ping(); batch1.ice_getConnection(); batch2.ice_getConnection(); batch1.begin_ice_ping(); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.begin_ice_ping(); batch2.begin_ice_ping(); } Ice.Identity identity = new Ice.Identity(); identity.name = "invalid"; Ice.ObjectPrx batch3 = batch.ice_identity(identity); batch3.begin_ice_ping(); batch3.end_ice_flushBatchRequests(batch3.begin_ice_flushBatchRequests()); // Make sure that a bogus batch request doesn't cause troubles to other ones. batch3.begin_ice_ping(); batch.begin_ice_ping(); batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests()); batch.begin_ice_ping(); }
internal static void twowaysNewAMI(Ice.Communicator communicator, Test.MyClassPrx p) { { Ice.AsyncResult r = p.begin_ice_ping(); p.end_ice_ping(r); } { Callback cb = new Callback(); p.begin_ice_ping().whenCompleted(cb.ice_ping, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_ice_isA(Test.MyClass.ice_staticId()); test(p.end_ice_isA(r)); } { Callback cb = new Callback(); p.begin_ice_isA(Test.MyClass.ice_staticId()).whenCompleted(cb.ice_isA, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_ice_ids(); test(p.end_ice_ids(r).Length == 3); } { Callback cb = new Callback(); p.begin_ice_ids().whenCompleted(cb.ice_ids, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_ice_id(); test(p.end_ice_id(r).Equals(Test.MyDerivedClass.ice_staticId())); } { Callback cb = new Callback(); p.begin_ice_id().whenCompleted(cb.ice_id, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_opVoid(); p.end_opVoid(r); } { Callback cb = new Callback(); p.begin_opVoid().whenCompleted(cb.opVoid, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_opByte(0xff, 0x0f); byte p3; byte ret = p.end_opByte(out p3, r); test(p3 == 0xf0); test(ret == 0xff); } { Callback cb = new Callback(); p.begin_opByte(0xff, 0x0f).whenCompleted(cb.opByte, cb.exCB); cb.check(); } { Callback cb = new Callback(); p.begin_opBool(true, false).whenCompleted(cb.opBool, cb.exCB); cb.check(); } { Callback cb = new Callback(); p.begin_opShortIntLong(10, 11, 12).whenCompleted(cb.opShortIntLong, cb.exCB); cb.check(); } { Callback cb = new Callback(); p.begin_opFloatDouble(3.14f, 1.1E10).whenCompleted(cb.opFloatDouble, cb.exCB); cb.check(); } { Callback cb = new Callback(); p.begin_opString("hello", "world").whenCompleted(cb.opString, cb.exCB); cb.check(); } { Callback cb = new Callback(); p.begin_opMyEnum(Test.MyEnum.enum2).whenCompleted(cb.opMyEnum, cb.exCB); cb.check(); } { Callback cb = new Callback(communicator); p.begin_opMyClass(p).whenCompleted(cb.opMyClass, cb.exCB); cb.check(); } { Test.Structure si1 = new Test.Structure(); si1.p = p; si1.e = Test.MyEnum.enum3; si1.s = new Test.AnotherStruct(); si1.s.s = "abc"; Test.Structure si2 = new Test.Structure(); si2.p = null; si2.e = Test.MyEnum.enum2; si2.s = new Test.AnotherStruct(); si2.s.s = "def"; Callback cb = new Callback(communicator); p.begin_opStruct(si1, si2).whenCompleted(cb.opStruct, cb.exCB); cb.check(); } { byte[] tbsi1 = new byte[] { 0x01, 0x11, 0x12, 0x22 }; Test.ByteS bsi1 = new Test.ByteS(tbsi1); byte[] tbsi2 = new byte[] { 0xf1, 0xf2, 0xf3, 0xf4 }; Test.ByteS bsi2 = new Test.ByteS(tbsi2); Callback cb = new Callback(); p.begin_opByteS(bsi1, bsi2).whenCompleted(cb.opByteS, cb.exCB); cb.check(); } { bool[] tbsi1 = new bool[] { true, true, false }; Test.BoolS bsi1 = new Test.BoolS(tbsi1); bool[] tbsi2 = new bool[] { false }; Test.BoolS bsi2 = new Test.BoolS(tbsi2); Callback cb = new Callback(); p.begin_opBoolS(bsi1, bsi2).whenCompleted(cb.opBoolS, cb.exCB); cb.check(); } { short[] tssi = new short[] { 1, 2, 3 }; Test.ShortS ssi = new Test.ShortS(tssi); int[] tisi = new int[] { 5, 6, 7, 8 }; Test.IntS isi = new Test.IntS(tisi); long[] tlsi = new long[] { 10, 30, 20 }; Test.LongS lsi = new Test.LongS(tlsi); Callback cb = new Callback(); p.begin_opShortIntLongS(ssi, isi, lsi).whenCompleted(cb.opShortIntLongS, cb.exCB); cb.check(); } { float[] tfsi = new float[] { 3.14f, 1.11f }; Test.FloatS fsi = new Test.FloatS(tfsi); double[] tdsi = new double[] { 1.1e10, 1.2e10, 1.3e10 }; Test.DoubleS dsi = new Test.DoubleS(tdsi); Callback cb = new Callback(); p.begin_opFloatDoubleS(fsi, dsi).whenCompleted(cb.opFloatDoubleS, cb.exCB); cb.check(); } { string[] tssi1 = new string[] { "abc", "de", "fghi" }; Test.StringS ssi1 = new Test.StringS(tssi1); string[] tssi2 = new string[] { "xyz" }; Test.StringS ssi2 = new Test.StringS(tssi2); Callback cb = new Callback(); p.begin_opStringS(ssi1, ssi2).whenCompleted(cb.opStringS, cb.exCB); cb.check(); } { Test.ByteS s11 = new Test.ByteS(new byte[] { 0x01, 0x11, 0x12 }); Test.ByteS s12 = new Test.ByteS(new byte[] { 0xff }); Test.ByteSS bsi1 = new Test.ByteSS(new Test.ByteS[] { s11, s12 }); Test.ByteS s21 = new Test.ByteS(new byte[] { 0x0e }); Test.ByteS s22 = new Test.ByteS(new byte[] { 0xf2, 0xf1 }); Test.ByteSS bsi2 = new Test.ByteSS(new Test.ByteS[] { s21, s22 }); Callback cb = new Callback(); p.begin_opByteSS(bsi1, bsi2).whenCompleted(cb.opByteSS, cb.exCB); cb.check(); } { Test.FloatS f11 = new Test.FloatS(new float[] { 3.14f }); Test.FloatS f12 = new Test.FloatS(new float[] { 1.11f }); Test.FloatS f13 = new Test.FloatS(new float[] { }); Test.FloatSS fsi = new Test.FloatSS(new Test.FloatS[] { f11, f12, f13 }); Test.DoubleS d11 = new Test.DoubleS(new double[] { 1.1e10, 1.2e10, 1.3e10 }); Test.DoubleSS dsi = new Test.DoubleSS(new Test.DoubleS[] { d11 }); Callback cb = new Callback(); p.begin_opFloatDoubleSS(fsi, dsi).whenCompleted(cb.opFloatDoubleSS, cb.exCB); cb.check(); } { Test.StringS s11 = new Test.StringS(); s11.Add("abc"); Test.StringS s12 = new Test.StringS(); s12.Add("de"); s12.Add("fghi"); Test.StringSS ssi1 = new Test.StringSS(); ssi1.Add(s11); ssi1.Add(s12); Test.StringS s21 = new Test.StringS(); Test.StringS s22 = new Test.StringS(); Test.StringS s23 = new Test.StringS(); s23.Add("xyz"); Test.StringSS ssi2 = new Test.StringSS(); ssi2.Add(s21); ssi2.Add(s22); ssi2.Add(s23); Callback cb = new Callback(); p.begin_opStringSS(ssi1, ssi2).whenCompleted(cb.opStringSS, cb.exCB); cb.check(); } { Test.StringSS[] sssi1 = { new Test.StringSS(), new Test.StringSS() }; sssi1[0].Add(new Test.StringS()); sssi1[0].Add(new Test.StringS()); sssi1[0][0].Add("abc"); sssi1[0][0].Add("de"); sssi1[0][1].Add("xyz"); sssi1[1].Add(new Test.StringS()); sssi1[1][0].Add("hello"); Test.StringSS[] sssi2 = { new Test.StringSS(), new Test.StringSS(), new Test.StringSS() }; sssi2[0].Add(new Test.StringS()); sssi2[0].Add(new Test.StringS()); sssi2[0][0].Add(""); sssi2[0][0].Add(""); sssi2[0][1].Add("abcd"); sssi2[1].Add(new Test.StringS()); sssi2[1][0].Add(""); Callback cb = new Callback(); p.begin_opStringSSS(sssi1, sssi2).whenCompleted(cb.opStringSSS, cb.exCB); cb.check(); } { Dictionary <byte, bool> di1 = new Dictionary <byte, bool>(); di1[10] = true; di1[100] = false; Dictionary <byte, bool> di2 = new Dictionary <byte, bool>(); di2[10] = true; di2[11] = false; di2[101] = true; Callback cb = new Callback(); p.begin_opByteBoolD(di1, di2).whenCompleted(cb.opByteBoolD, cb.exCB); cb.check(); } { Dictionary <short, int> di1 = new Dictionary <short, int>(); di1[110] = -1; di1[1100] = 123123; Dictionary <short, int> di2 = new Dictionary <short, int>(); di2[110] = -1; di2[111] = -100; di2[1101] = 0; Callback cb = new Callback(); p.begin_opShortIntD(di1, di2).whenCompleted(cb.opShortIntD, cb.exCB); cb.check(); } { Dictionary <long, float> di1 = new Dictionary <long, float>(); di1[999999110L] = -1.1f; di1[999999111L] = 123123.2f; Dictionary <long, float> di2 = new Dictionary <long, float>(); di2[999999110L] = -1.1f; di2[999999120L] = -100.4f; di2[999999130L] = 0.5f; Callback cb = new Callback(); p.begin_opLongFloatD(di1, di2).whenCompleted(cb.opLongFloatD, cb.exCB); cb.check(); } { Dictionary <string, string> di1 = new Dictionary <string, string>(); di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Dictionary <string, string> di2 = new Dictionary <string, string>(); di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Callback cb = new Callback(); p.begin_opStringStringD(di1, di2).whenCompleted(cb.opStringStringD, cb.exCB); cb.check(); } { Dictionary <string, Test.MyEnum> di1 = new Dictionary <string, Test.MyEnum>(); di1["abc"] = Test.MyEnum.enum1; di1[""] = Test.MyEnum.enum2; Dictionary <string, Test.MyEnum> di2 = new Dictionary <string, Test.MyEnum>(); di2["abc"] = Test.MyEnum.enum1; di2["qwerty"] = Test.MyEnum.enum3; di2["Hello!!"] = Test.MyEnum.enum2; Callback cb = new Callback(); p.begin_opStringMyEnumD(di1, di2).whenCompleted(cb.opStringMyEnumD, cb.exCB); cb.check(); } { Dictionary <Test.MyEnum, string> di1 = new Dictionary <Test.MyEnum, string>(); di1[Test.MyEnum.enum1] = "abc"; Dictionary <Test.MyEnum, string> di2 = new Dictionary <Test.MyEnum, string>(); di2[Test.MyEnum.enum2] = "Hello!!"; di2[Test.MyEnum.enum3] = "qwerty"; Callback cb = new Callback(); p.begin_opMyEnumStringD(di1, di2).whenCompleted(cb.opMyEnumStringD, cb.exCB); cb.check(); } { Test.MyStruct s11 = new Test.MyStruct(1, 1); Test.MyStruct s12 = new Test.MyStruct(1, 2); Dictionary <Test.MyStruct, Test.MyEnum> di1 = new Dictionary <Test.MyStruct, Test.MyEnum>(); di1[s11] = Test.MyEnum.enum1; di1[s12] = Test.MyEnum.enum2; Test.MyStruct s22 = new Test.MyStruct(2, 2); Test.MyStruct s23 = new Test.MyStruct(2, 3); Dictionary <Test.MyStruct, Test.MyEnum> di2 = new Dictionary <Test.MyStruct, Test.MyEnum>(); di2[s11] = Test.MyEnum.enum1; di2[s22] = Test.MyEnum.enum3; di2[s23] = Test.MyEnum.enum2; Callback cb = new Callback(); p.begin_opMyStructMyEnumD(di1, di2).whenCompleted(cb.opMyStructMyEnumD, cb.exCB); cb.check(); } { int[] lengths = new int[] { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 }; for (int l = 0; l < lengths.Length; ++l) { Test.IntS s = new Test.IntS(); for (int i = 0; i < lengths[l]; ++i) { s.Add(i); } Callback cb = new Callback(lengths[l]); p.begin_opIntS(s).whenCompleted(cb.opIntS, cb.exCB); cb.check(); } } { Dictionary <string, string> ctx = new Dictionary <string, string>(); ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; { test(p.ice_getContext().Count == 0); Callback cb = new Callback(ctx); p.begin_opContext().whenCompleted(cb.opContextNotEqual, cb.exCB); cb.check(); } { test(p.ice_getContext().Count == 0); Callback cb = new Callback(ctx); p.begin_opContext(ctx).whenCompleted(cb.opContextEqual, cb.exCB); cb.check(); } { Test.MyClassPrx p2 = Test.MyClassPrxHelper.checkedCast(p.ice_context(ctx)); test(Ice.CollectionComparer.Equals(p2.ice_getContext(), ctx)); Callback cb = new Callback(ctx); p2.begin_opContext().whenCompleted(cb.opContextEqual, cb.exCB); cb.check(); } { Test.MyClassPrx p2 = Test.MyClassPrxHelper.checkedCast(p.ice_context(ctx)); Callback cb = new Callback(ctx); p2.begin_opContext(ctx).whenCompleted(cb.opContextEqual, cb.exCB); cb.check(); } } { // // Test implicit context propagation // string[] impls = { "Shared", "PerThread" }; for (int i = 0; i < 2; i++) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.ImplicitContext", impls[i]); Ice.Communicator ic = Ice.Util.initialize(initData); Dictionary <string, string> ctx = new Dictionary <string, string>(); ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; Test.MyClassPrx p3 = Test.MyClassPrxHelper.uncheckedCast( ic.stringToProxy("test:default -p 12010")); ic.getImplicitContext().setContext(ctx); test(Ice.CollectionComparer.Equals(ic.getImplicitContext().getContext(), ctx)); { Ice.AsyncResult r = p3.begin_opContext(); Dictionary <string, string> c = p3.end_opContext(r); test(Ice.CollectionComparer.Equals(c, ctx)); } ic.getImplicitContext().put("zero", "ZERO"); ctx = ic.getImplicitContext().getContext(); { Ice.AsyncResult r = p3.begin_opContext(); Dictionary <string, string> c = p3.end_opContext(r); test(Ice.CollectionComparer.Equals(c, ctx)); } Dictionary <string, string> prxContext = new Dictionary <string, string>(); prxContext["one"] = "UN"; prxContext["four"] = "QUATRE"; Dictionary <string, string> combined = prxContext; foreach (KeyValuePair <string, string> e in ctx) { try { combined.Add(e.Key, e.Value); } catch (System.ArgumentException) { // Ignore. } } test(combined["one"].Equals("UN")); p3 = Test.MyClassPrxHelper.uncheckedCast(p.ice_context(prxContext)); ic.getImplicitContext().setContext(null); { Ice.AsyncResult r = p3.begin_opContext(); Dictionary <string, string> c = p3.end_opContext(r); test(Ice.CollectionComparer.Equals(c, prxContext)); } ic.getImplicitContext().setContext(ctx); { Ice.AsyncResult r = p3.begin_opContext(); Dictionary <string, string> c = p3.end_opContext(r); test(Ice.CollectionComparer.Equals(c, combined)); } //ic.getImplicitContext().setContext(null); ic.destroy(); } } { Ice.AsyncResult r = p.begin_opIdempotent(); p.end_opIdempotent(r); } { Callback cb = new Callback(); p.begin_opIdempotent().whenCompleted(cb.opIdempotent, cb.exCB); cb.check(); } { Ice.AsyncResult r = p.begin_opNonmutating(); p.end_opNonmutating(r); } { Callback cb = new Callback(); p.begin_opNonmutating().whenCompleted(cb.opNonmutating, cb.exCB); cb.check(); } { Test.MyDerivedClassPrx derived = Test.MyDerivedClassPrxHelper.checkedCast(p); test(derived != null); Callback cb = new Callback(); derived.begin_opDerived().whenCompleted(cb.opDerived, cb.exCB); cb.check(); } }
public static Test.MyClassPrx allTests(Ice.Communicator communicator) #endif { Ice.ObjectPrx baseProxy = communicator.stringToProxy("test:default -p 12010"); Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(baseProxy); Test.MyClassPrx oneway = Test.MyClassPrxHelper.uncheckedCast(cl.ice_oneway()); Test.MyClassPrx batchOneway = Test.MyClassPrxHelper.uncheckedCast(cl.ice_batchOneway()); Write("testing ice_invoke... "); Flush(); { byte[] inEncaps, outEncaps; if (!oneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)) { test(false); } test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); batchOneway.ice_flushBatchRequests(); Ice.OutputStream outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeString(testString); outS.endEncapsulation(); inEncaps = outS.finished(); if (cl.ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, out outEncaps)) { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); string s = inS.readString(); test(s.Equals(testString)); s = inS.readString(); inS.endEncapsulation(); test(s.Equals(testString)); } else { test(false); } } { byte[] outEncaps; if (cl.ice_invoke("opException", Ice.OperationMode.Normal, null, out outEncaps)) { test(false); } else { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); try { inS.throwException(); } catch (Test.MyException) { inS.endEncapsulation(); } catch (System.Exception) { test(false); } } } WriteLine("ok"); Write("testing asynchronous ice_invoke... "); Flush(); { byte[] inEncaps, outEncaps; Ice.AsyncResult result = oneway.begin_ice_invoke("opOneway", Ice.OperationMode.Normal, null); if (!oneway.end_ice_invoke(out outEncaps, result)) { test(false); } Ice.OutputStream outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeString(testString); outS.endEncapsulation(); inEncaps = outS.finished(); // begin_ice_invoke with no callback result = cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps); if (cl.end_ice_invoke(out outEncaps, result)) { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); string s = inS.readString(); test(s.Equals(testString)); s = inS.readString(); inS.endEncapsulation(); test(s.Equals(testString)); } else { test(false); } // begin_ice_invoke with Callback Callback cb = new Callback(communicator, false); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, cb.opString, null); cb.check(); // begin_ice_invoke with Callback with cookie cb = new Callback(communicator, true); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, cb.opString, new Cookie()); cb.check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, true); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps).whenCompleted(cb.opStringNC, null); cb.check(); } { // begin_ice_invoke with no callback Ice.AsyncResult result = cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null); byte[] outEncaps; if (cl.end_ice_invoke(out outEncaps, result)) { test(false); } else { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); try { inS.throwException(); } catch (Test.MyException) { inS.endEncapsulation(); } catch (System.Exception) { test(false); } } // begin_ice_invoke with Callback Callback cb = new Callback(communicator, false); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null, cb.opException, null); cb.check(); // begin_ice_invoke with Callback with cookie cb = new Callback(communicator, true); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null, cb.opException, new Cookie()); cb.check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, true); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null).whenCompleted(cb.opExceptionNC, null); cb.check(); } WriteLine("ok"); #if SILVERLIGHT cl.shutdown(); #else return(cl); #endif }
internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p) { { Dictionary <int, int> i = new Dictionary <int, int>(); i[0] = 1; i[1] = 0; Dictionary <int, int> o; Dictionary <int, int> r; r = p.opNV(i, out o); test(Ice.Collections.Equals(i, o)); test(Ice.Collections.Equals(i, r)); } { Dictionary <string, string> i = new Dictionary <string, string>(); i["a"] = "b"; i["b"] = "a"; Dictionary <string, string> o; Dictionary <string, string> r; r = p.opNR(i, out o); test(Ice.Collections.Equals(i, o)); test(Ice.Collections.Equals(i, r)); } { Dictionary <string, Dictionary <int, int> > i = new Dictionary <string, Dictionary <int, int> >(); Dictionary <int, int> id = new Dictionary <int, int>(); id[0] = 1; id[1] = 0; i["a"] = id; i["b"] = id; Dictionary <string, Dictionary <int, int> > o; Dictionary <string, Dictionary <int, int> > r; r = p.opNDV(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } { Dictionary <string, Dictionary <string, string> > i = new Dictionary <string, Dictionary <string, string> >(); Dictionary <string, string> id = new Dictionary <string, string>(); id["a"] = "b"; id["b"] = "a"; i["a"] = id; i["b"] = id; Dictionary <string, Dictionary <string, string> > o; Dictionary <string, Dictionary <string, string> > r; r = p.opNDR(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } { int[] ii = new int[] { 1, 2 }; Dictionary <string, int[]> i = new Dictionary <string, int[]>(); i["a"] = ii; i["b"] = ii; Dictionary <string, int[]> o; Dictionary <string, int[]> r; r = p.opNDAIS(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } { List <int> ii = new List <int>(); ii.Add(1); ii.Add(2); Dictionary <string, List <int> > i = new Dictionary <string, List <int> >(); i["a"] = ii; i["b"] = ii; Dictionary <string, List <int> > o; Dictionary <string, List <int> > r; r = p.opNDGIS(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } { string[] ii = new string[] { "a", "b" }; Dictionary <string, string[]> i = new Dictionary <string, string[]>(); i["a"] = ii; i["b"] = ii; Dictionary <string, string[]> o; Dictionary <string, string[]> r; r = p.opNDASS(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } { List <string> ii = new List <string>(); ii.Add("a"); ii.Add("b"); Dictionary <string, List <string> > i = new Dictionary <string, List <string> >(); i["a"] = ii; i["b"] = ii; Dictionary <string, List <string> > o; Dictionary <string, List <string> > r; r = p.opNDGSS(i, out o); foreach (string key in i.Keys) { test(Ice.Collections.Equals(i[key], o[key])); test(Ice.Collections.Equals(i[key], r[key])); } } }
internal static void onewaysAMI(TestCommon.Application app, Test.MyClassPrx proxy) { Ice.Communicator communicator = app.communicator(); Test.MyClassPrx p = Test.MyClassPrxHelper.uncheckedCast(proxy.ice_oneway()); { Callback cb = new Callback(); p.ice_pingAsync(progress: new Progress <bool>( sentSynchronously => { cb.sent(sentSynchronously); })); cb.check(); } { Callback cb = new Callback(); p.begin_ice_ping().whenCompleted(cb.noException).whenSent(cb.sent); cb.check(); } { Callback cb = new Callback(); p.begin_ice_ping().whenCompleted( (Ice.Exception ex) => { cb.noException(ex); } ).whenSent( (bool sentSynchronously) => { cb.sent(sentSynchronously); }); cb.check(); } { try { p.ice_isAAsync("::Test::MyClass"); test(false); } catch (Ice.TwowayOnlyException) { } } { try { p.begin_ice_isA("::Test::MyClass"); test(false); } catch (Ice.TwowayOnlyException) { } } { try { p.ice_idAsync(); test(false); } catch (Ice.TwowayOnlyException) { } } { try { p.begin_ice_id(); test(false); } catch (Ice.TwowayOnlyException) { } } { try { p.begin_ice_ids(); test(false); } catch (Ice.TwowayOnlyException) { } } { Callback cb = new Callback(); p.opVoidAsync(progress: new Progress <bool>( sentSynchronously => { cb.sent(sentSynchronously); })); cb.check(); } { Callback cb = new Callback(); p.begin_opVoid().whenCompleted(cb.noException).whenSent(cb.sent); cb.check(); } { Callback cb = new Callback(); p.begin_opVoid().whenCompleted( (Ice.Exception ex) => { cb.noException(ex); } ).whenSent( (bool sentSynchronously) => { cb.sent(sentSynchronously); }); cb.check(); } { Callback cb = new Callback(); p.opIdempotentAsync(progress: new Progress <bool>( sentSynchronously => { cb.sent(sentSynchronously); })); cb.check(); } { Callback cb = new Callback(); p.begin_opIdempotent().whenCompleted(cb.noException).whenSent(cb.sent); cb.check(); } { Callback cb = new Callback(); p.begin_opIdempotent().whenCompleted( (Ice.Exception ex) => { cb.noException(ex); } ).whenSent( (bool sentSynchronously) => { cb.sent(sentSynchronously); }); cb.check(); } { Callback cb = new Callback(); p.opNonmutatingAsync(progress: new Progress <bool>( sentSynchronously => { cb.sent(sentSynchronously); })); cb.check(); } { Callback cb = new Callback(); p.begin_opNonmutating().whenCompleted(cb.noException).whenSent(cb.sent); cb.check(); } { Callback cb = new Callback(); p.begin_opNonmutating().whenCompleted( (Ice.Exception ex) => { cb.noException(ex); } ).whenSent( (bool sentSynchronously) => { cb.sent(sentSynchronously); }); cb.check(); } { try { p.opByteAsync(0xff, 0x0f); test(false); } catch (Ice.TwowayOnlyException) { } } { try { p.begin_opByte(0xff, 0x0f); test(false); } catch (Ice.TwowayOnlyException) { } } }
public override int run(string[] args) { Test.MyClassPrx myClass = AllTests.allTests(this); myClass.shutdown(); return(0); }
public PerThreadContextInvokeThread(Test.MyClassPrx proxy) { _proxy = proxy; }
private static int run(string[] args, Ice.Communicator communicator) { MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper(); communicator.addObjectFactory(factoryWrapper, Test.MyClass.ice_staticId()); communicator.addObjectFactory(new MyInterfaceFactory(), Test.MyInterfaceDisp_.ice_staticId()); Ice.InputStream @in; Ice.OutputStream @out; Console.Write("testing primitive types... "); Console.Out.Flush(); { byte[] data = new byte[0]; @in = Ice.Util.createInputStream(communicator, data); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.startEncapsulation(); @out.writeBool(true); @out.endEncapsulation(); byte[] data = @out.finished(); @out.destroy(); @in = Ice.Util.createInputStream(communicator, data); @in.startEncapsulation(); test(@in.readBool()); @in.endEncapsulation(); @in.destroy(); } { byte[] data = new byte[0]; @in = Ice.Util.createInputStream(communicator, data); try { @in.readBool(); test(false); } catch(Ice.UnmarshalOutOfBoundsException) { } @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeBool(true); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readBool()); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeByte((byte)1); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readByte() == (byte)1); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeShort((short)2); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readShort() == (short)2); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeInt(3); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readInt() == 3); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeLong(4); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readLong() == 4); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeFloat((float)5.0); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readFloat() == (float)5.0); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeDouble(6.0); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readDouble() == 6.0); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); @out.writeString("hello world"); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(@in.readString().Equals("hello world")); @out.destroy(); @in.destroy(); } Console.WriteLine("ok"); Console.Write("testing constructed types... "); Console.Out.Flush(); { @out = Ice.Util.createOutputStream(communicator); Test.MyEnumHelper.write(@out, Test.MyEnum.enum3); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); test(Test.MyEnumHelper.read(@in) == Test.MyEnum.enum3); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.SmallStruct s = new Test.SmallStruct(); s.bo = true; s.by = (byte)1; s.sh = (short)2; s.i = 3; s.l = 4; s.f = (float)5.0; s.d = 6.0; s.str = "7"; s.e = Test.MyEnum.enum2; s.p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default")); s.ice_write(@out); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.SmallStruct s2 = new Test.SmallStruct(); s2.ice_read(@in); test(s2.Equals(s)); @out.destroy(); @in.destroy(); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); Ice.BoolSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); bool[] arr2 = Ice.BoolSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); bool[][] arrS = { arr, new bool[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.BoolSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); bool[][] arr2S = Test.BoolSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { byte[] arr = { (byte)0x01, (byte)0x11, (byte)0x12, (byte)0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.ByteSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); byte[] arr2 = Ice.ByteSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); byte[][] arrS = { arr, new byte[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.ByteSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); byte[][] arr2S = Test.ByteSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } #if !COMPACT { Serialize.Small small = new Serialize.Small(); small.i = 99; @out = Ice.Util.createOutputStream(communicator); @out.writeSerializable(small); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Serialize.Small small2 = (Serialize.Small)@in.readSerializable(); test(small2.i == 99); @out.destroy(); @in.destroy(); } #endif { short[] arr = { (short)0x01, (short)0x11, (short)0x12, (short)0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.ShortSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); short[] arr2 = Ice.ShortSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); short[][] arrS = { arr, new short[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.ShortSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); short[][] arr2S = Test.ShortSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.IntSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); int[] arr2 = Ice.IntSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); int[][] arrS = { arr, new int[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.IntSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); int[][] arr2S = Test.IntSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Ice.LongSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); long[] arr2 = Ice.LongSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); long[][] arrS = { arr, new long[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.LongSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); long[][] arr2S = Test.LongSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { float[] arr = { (float)1, (float)2, (float)3, (float)4 }; @out = Ice.Util.createOutputStream(communicator); Ice.FloatSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); float[] arr2 = Ice.FloatSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); float[][] arrS = { arr, new float[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.FloatSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); float[][] arr2S = Test.FloatSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { double[] arr = { (double)1, (double)2, (double)3, (double)4 }; @out = Ice.Util.createOutputStream(communicator); Ice.DoubleSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); double[] arr2 = Ice.DoubleSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); double[][] arrS = { arr, new double[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.DoubleSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); double[][] arr2S = Test.DoubleSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Ice.StringSeqHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); string[] arr2 = Ice.StringSeqHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.StringSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); string[][] arr2S = Test.StringSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumSHelper.write(@out, arr); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnum[] arr2 = Test.MyEnumSHelper.read(@in); test(Compare(arr2, arr)); @out.destroy(); @in.destroy(); Test.MyEnum[][] arrS = { arr, new Test.MyEnum[0], arr }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnum[][] arr2S = Test.MyEnumSSHelper.read(@in); test(Compare(arr2S, arrS)); @out.destroy(); @in.destroy(); } Test.SmallStruct[] smallStructArray = new Test.SmallStruct[3]; for(int i = 0; i < smallStructArray.Length; ++i) { smallStructArray[i] = new Test.SmallStruct(); smallStructArray[i].bo = true; smallStructArray[i].by = (byte)1; smallStructArray[i].sh = (short)2; smallStructArray[i].i = 3; smallStructArray[i].l = 4; smallStructArray[i].f = (float)5.0; smallStructArray[i].d = 6.0; smallStructArray[i].str = "7"; smallStructArray[i].e = Test.MyEnum.enum2; smallStructArray[i].p = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("test:default")); } Test.MyClass[] myClassArray = new Test.MyClass[4]; for(int i = 0; i < myClassArray.Length; ++i) { myClassArray[i] = new Test.MyClass(); myClassArray[i].c = myClassArray[i]; myClassArray[i].o = myClassArray[i]; myClassArray[i].s = new Test.SmallStruct(); myClassArray[i].s.e = Test.MyEnum.enum2; myClassArray[i].seq1 = new bool[] { true, false, true, false }; myClassArray[i].seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }; myClassArray[i].seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 }; myClassArray[i].seq4 = new int[] { 1, 2, 3, 4 }; myClassArray[i].seq5 = new long[] { 1, 2, 3, 4 }; myClassArray[i].seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 }; myClassArray[i].seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 }; myClassArray[i].seq8 = new string[] { "string1", "string2", "string3", "string4" }; myClassArray[i].seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; myClassArray[i].seq10 = new Test.MyClass[4]; // null elements. myClassArray[i].d = new System.Collections.Generic.Dictionary<string, Test.MyClass>(); myClassArray[i].d["hi"] = myClassArray[i]; } { @out = Ice.Util.createOutputStream(communicator); Test.MyClassSHelper.write(@out, myClassArray); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClass[] arr2 = Test.MyClassSHelper.read(@in); @in.readPendingObjects(); test(arr2.Length == myClassArray.Length); for(int i = 0; i < arr2.Length; ++i) { test(arr2[i] != null); test(arr2[i].c == arr2[i]); test(arr2[i].o == arr2[i]); test(arr2[i].s.e == Test.MyEnum.enum2); test(Compare(arr2[i].seq1, myClassArray[i].seq1)); test(Compare(arr2[i].seq2, myClassArray[i].seq2)); test(Compare(arr2[i].seq3, myClassArray[i].seq3)); test(Compare(arr2[i].seq4, myClassArray[i].seq4)); test(Compare(arr2[i].seq5, myClassArray[i].seq5)); test(Compare(arr2[i].seq6, myClassArray[i].seq6)); test(Compare(arr2[i].seq7, myClassArray[i].seq7)); test(Compare(arr2[i].seq8, myClassArray[i].seq8)); test(Compare(arr2[i].seq9, myClassArray[i].seq9)); test(arr2[i].d["hi"].Equals(arr2[i])); } @out.destroy(); @in.destroy(); Test.MyClass[][] arrS = { myClassArray, new Test.MyClass[0], myClassArray }; @out = Ice.Util.createOutputStream(communicator); Test.MyClassSSHelper.write(@out, arrS); data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClass[][] arr2S = Test.MyClassSSHelper.read(@in); test(arr2S.Length == arrS.Length); test(arr2S[0].Length == arrS[0].Length); test(arr2S[1].Length == arrS[1].Length); test(arr2S[2].Length == arrS[2].Length); @out.destroy(); @in.destroy(); } { Test.MyInterface i = new MyInterfaceI(); @out = Ice.Util.createOutputStream(communicator); Test.MyInterfaceHelper.write(@out, i); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyInterfaceHelper helper = new Test.MyInterfaceHelper(@in); helper.read(); @in.readPendingObjects(); test(helper.value != null); } { @out = Ice.Util.createOutputStream(communicator); Test.MyClass obj = new Test.MyClass(); obj.s = new Test.SmallStruct(); obj.s.e = Test.MyEnum.enum2; TestObjectWriter writer = new TestObjectWriter(obj); @out.writeObject(writer); @out.writePendingObjects(); byte[] data = @out.finished(); test(writer.called); factoryWrapper.setFactory(new TestObjectFactory()); @in = Ice.Util.createInputStream(communicator, data); TestReadObjectCallback cb = new TestReadObjectCallback(); @in.readObject(cb); @in.readPendingObjects(); test(cb.obj != null); test(cb.obj is TestObjectReader); TestObjectReader reader = (TestObjectReader)cb.obj; test(reader.called); test(reader.obj != null); test(reader.obj.s.e == Test.MyEnum.enum2); @out.destroy(); @in.destroy(); factoryWrapper.setFactory(null); } { @out = Ice.Util.createOutputStream(communicator); Test.MyException ex = new Test.MyException(); Test.MyClass c = new Test.MyClass(); c.c = c; c.o = c; c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; c.seq1 = new bool[] { true, false, true, false }; c.seq2 = new byte[] { (byte)1, (byte)2, (byte)3, (byte)4 }; c.seq3 = new short[] { (short)1, (short)2, (short)3, (short)4 }; c.seq4 = new int[] { 1, 2, 3, 4 }; c.seq5 = new long[] { 1, 2, 3, 4 }; c.seq6 = new float[] { (float)1, (float)2, (float)3, (float)4 }; c.seq7 = new double[] { (double)1, (double)2, (double)3, (double)4 }; c.seq8 = new string[] { "string1", "string2", "string3", "string4" }; c.seq9 = new Test.MyEnum[] { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1 }; c.seq10 = new Test.MyClass[4]; // null elements. c.d = new Dictionary<string, Test.MyClass>(); c.d.Add("hi", c); ex.c = c; @out.writeException(ex); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); try { @in.throwException(); test(false); } catch(Test.MyException ex1) { test(ex1.c.s.e == c.s.e); test(Compare(ex1.c.seq1, c.seq1)); test(Compare(ex1.c.seq2, c.seq2)); test(Compare(ex1.c.seq3, c.seq3)); test(Compare(ex1.c.seq4, c.seq4)); test(Compare(ex1.c.seq5, c.seq5)); test(Compare(ex1.c.seq6, c.seq6)); test(Compare(ex1.c.seq7, c.seq7)); test(Compare(ex1.c.seq8, c.seq8)); test(Compare(ex1.c.seq9, c.seq9)); } catch(Ice.UserException) { test(false); } } { Dictionary<byte, bool> dict = new Dictionary<byte, bool>(); dict.Add((byte)4, true); dict.Add((byte)1, false); @out = Ice.Util.createOutputStream(communicator); Test.ByteBoolDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<byte, bool> dict2 = Test.ByteBoolDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<short, int> dict = new Dictionary<short, int>(); dict.Add((short)1, 9); dict.Add((short)4, 8); @out = Ice.Util.createOutputStream(communicator); Test.ShortIntDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<short, int> dict2 = Test.ShortIntDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<long, float> dict = new Dictionary<long, float>(); dict.Add((long)123809828, (float)0.51f); dict.Add((long)123809829, (float)0.56f); @out = Ice.Util.createOutputStream(communicator); Test.LongFloatDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<long, float> dict2 = Test.LongFloatDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<string, string> dict = new Dictionary<string, string>(); dict.Add("key1", "value1"); dict.Add("key2", "value2"); @out = Ice.Util.createOutputStream(communicator); Test.StringStringDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<string, string> dict2 = Test.StringStringDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Dictionary<string, Test.MyClass> dict = new Dictionary<string, Test.MyClass>(); Test.MyClass c; c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum2; dict.Add("key1", c); c = new Test.MyClass(); c.s = new Test.SmallStruct(); c.s.e = Test.MyEnum.enum3; dict.Add("key2", c); @out = Ice.Util.createOutputStream(communicator); Test.StringMyClassDHelper.write(@out, dict); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Dictionary<string, Test.MyClass> dict2 = Test.StringMyClassDHelper.read(@in); @in.readPendingObjects(); test(dict2.Count == dict.Count); test(dict2["key1"].s.e == Test.MyEnum.enum2); test(dict2["key2"].s.e == Test.MyEnum.enum3); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); List<bool> l = new List<bool>(arr); Test.BoolListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<bool> l2 = Test.BoolListHelper.read(@in); test(Compare(l, l2)); @out.destroy(); @in.destroy(); } { byte[] arr = { (byte)0x01, (byte)0x11, (byte)0x12, (byte)0x22 }; @out = Ice.Util.createOutputStream(communicator); List<byte> l = new List<byte>(arr); Test.ByteListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<byte> l2 = Test.ByteListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); List<Test.MyEnum> l = new List<Test.MyEnum>(arr); Test.MyEnumListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyEnum> l2 = Test.MyEnumListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); List<Test.SmallStruct> l = new List<Test.SmallStruct>(smallStructArray); Test.SmallStructListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.SmallStruct> l2 = Test.SmallStructListHelper.read(@in); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i].Equals(smallStructArray[i])); } @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); List<Test.MyClass> l = new List<Test.MyClass>(myClassArray); Test.MyClassListHelper.write(@out, l); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyClass> l2 = Test.MyClassListHelper.read(@in); @in.readPendingObjects(); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } @out.destroy(); @in.destroy(); } { Test.MyClassPrx[] arr = new Test.MyClassPrx[2]; arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero")); arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one")); @out = Ice.Util.createOutputStream(communicator); List<Test.MyClassPrx> l = new List<Test.MyClassPrx>(arr); Test.MyClassProxyListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<Test.MyClassPrx> l2 = Test.MyClassProxyListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { short[] arr = { (short)0x01, (short)0x11, (short)0x12, (short)0x22 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<short> l = new LinkedList<short>(arr); Test.ShortLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<short> l2 = Test.ShortLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<int> l = new LinkedList<int>(arr); Test.IntLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<int> l2 = Test.IntLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); LinkedList<Test.MyEnum> l = new LinkedList<Test.MyEnum>(arr); Test.MyEnumLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<Test.MyEnum> l2 = Test.MyEnumLinkedListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); LinkedList<Test.SmallStruct> l = new LinkedList<Test.SmallStruct>(smallStructArray); Test.SmallStructLinkedListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); LinkedList<Test.SmallStruct> l2 = Test.SmallStructLinkedListHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { long[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Stack<long> l = new Stack<long>(arr); Test.LongStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<long> l2 = Test.LongStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { float[] arr = { (float)1, (float)2, (float)3, (float)4 }; @out = Ice.Util.createOutputStream(communicator); Stack<float> l = new Stack<float>(arr); Test.FloatStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<float> l2 = Test.FloatStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Stack<Test.SmallStruct> l = new Stack<Test.SmallStruct>(smallStructArray); Test.SmallStructStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<Test.SmallStruct> l2 = Test.SmallStructStackHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { Test.MyClassPrx[] arr = new Test.MyClassPrx[2]; arr[0] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("zero")); arr[1] = Test.MyClassPrxHelper.uncheckedCast(communicator.stringToProxy("one")); @out = Ice.Util.createOutputStream(communicator); Stack<Test.MyClassPrx> l = new Stack<Test.MyClassPrx>(arr); Test.MyClassProxyStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<Test.MyClassPrx> l2 = Test.MyClassProxyStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { double[] arr = { (double)1, (double)2, (double)3, (double)4 }; @out = Ice.Util.createOutputStream(communicator); Queue<double> l = new Queue<double>(arr); Test.DoubleQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<double> l2 = Test.DoubleQueueHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Queue<string> l = new Queue<string>(arr); Test.StringQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<string> l2 = Test.StringQueueHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Queue<Test.SmallStruct> l = new Queue<Test.SmallStruct>(smallStructArray); Test.SmallStructQueueHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Queue<Test.SmallStruct> l2 = Test.SmallStructQueueHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { bool[] arr = { true, false, true, false }; @out = Ice.Util.createOutputStream(communicator); Test.BoolCollection l = new Test.BoolCollection(arr); Test.BoolCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.BoolCollection l2 = Test.BoolCollectionHelper.read(@in); test(Compare(l, l2)); @out.destroy(); @in.destroy(); } { int[] arr = { 0x01, 0x11, 0x12, 0x22 }; @out = Ice.Util.createOutputStream(communicator); Test.IntCollection l = new Test.IntCollection(arr); Test.IntCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.IntCollection l2 = Test.IntCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; @out = Ice.Util.createOutputStream(communicator); Test.StringCollection l = new Test.StringCollection(arr); Test.StringCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.StringCollection l2 = Test.StringCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { Test.MyEnum[] arr = { Test.MyEnum.enum3, Test.MyEnum.enum2, Test.MyEnum.enum1, Test.MyEnum.enum2 }; @out = Ice.Util.createOutputStream(communicator); Test.MyEnumCollection l = new Test.MyEnumCollection(arr); Test.MyEnumCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyEnumCollection l2 = Test.MyEnumCollectionHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.SmallStructCollection l = new Test.SmallStructCollection(smallStructArray); Test.SmallStructCollectionHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.SmallStructCollection l2 = Test.SmallStructCollectionHelper.read(@in); test(l2.Count == l.Count); IEnumerator<Test.SmallStruct> e = l.GetEnumerator(); IEnumerator<Test.SmallStruct> e2 = l2.GetEnumerator(); while(e.MoveNext() && e2.MoveNext()) { test(e.Current.Equals(e2.Current)); } @out.destroy(); @in.destroy(); } { @out = Ice.Util.createOutputStream(communicator); Test.MyClassCollection l = new Test.MyClassCollection(myClassArray); Test.MyClassCollectionHelper.write(@out, l); @out.writePendingObjects(); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.MyClassCollection l2 = Test.MyClassCollectionHelper.read(@in); @in.readPendingObjects(); test(l2.Count == l.Count); for(int i = 0; i < l2.Count; ++i) { test(l2[i] != null); test(l2[i].c == l2[i]); test(l2[i].o == l2[i]); test(l2[i].s.e == Test.MyEnum.enum2); test(Compare(l2[i].seq1, l[i].seq1)); test(Compare(l2[i].seq2, l[i].seq2)); test(Compare(l2[i].seq3, l[i].seq3)); test(Compare(l2[i].seq4, l[i].seq4)); test(Compare(l2[i].seq5, l[i].seq5)); test(Compare(l2[i].seq6, l[i].seq6)); test(Compare(l2[i].seq7, l[i].seq7)); test(Compare(l2[i].seq8, l[i].seq8)); test(Compare(l2[i].seq9, l[i].seq9)); test(l2[i].d["hi"].Equals(l2[i])); } @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); List<string[]> l = new List<string[]>(arrS); Test.StringSListHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); List<string[]> l2 = Test.StringSListHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { string[] arr = { "string1", "string2", "string3", "string4" }; string[][] arrS = { arr, new string[0], arr }; @out = Ice.Util.createOutputStream(communicator); Stack<string[]> l = new Stack<string[]>(arrS); Test.StringSStackHelper.write(@out, l); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Stack<string[]> l2 = Test.StringSStackHelper.read(@in); test(Compare(l2, l)); @out.destroy(); @in.destroy(); } { #if COMPACT SortedList<string, string> dict = new SortedList<string, string>(); #else SortedDictionary<string, string> dict = new SortedDictionary<string, string>(); #endif dict.Add("key1", "value1"); dict.Add("key2", "value2"); @out = Ice.Util.createOutputStream(communicator); Test.SortedStringStringDHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); IDictionary<string, string> dict2 = Test.SortedStringStringDHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } { Test.StringIntDCollection dict = new Test.StringIntDCollection(); dict.Add("key1", 1); dict.Add("key2", 2); @out = Ice.Util.createOutputStream(communicator); Test.StringIntDCollectionHelper.write(@out, dict); byte[] data = @out.finished(); @in = Ice.Util.createInputStream(communicator, data); Test.StringIntDCollection dict2 = Test.StringIntDCollectionHelper.read(@in); test(Ice.CollectionComparer.Equals(dict2, dict)); } Console.WriteLine("ok"); return 0; }