diff options
Diffstat (limited to 'csharp/test/Ice/optional/TestAMDI.cs')
| -rw-r--r-- | csharp/test/Ice/optional/TestAMDI.cs | 337 |
1 files changed, 201 insertions, 136 deletions
diff --git a/csharp/test/Ice/optional/TestAMDI.cs b/csharp/test/Ice/optional/TestAMDI.cs index fd5a9edc935..3826a2464e5 100644 --- a/csharp/test/Ice/optional/TestAMDI.cs +++ b/csharp/test/Ice/optional/TestAMDI.cs @@ -7,41 +7,40 @@ // // ********************************************************************** -using System; using System.Collections.Generic; +using System.Threading.Tasks; +using Test; -public class InitialI : Test.Initial +public class InitialI : Test.InitialDisp_ { - public override void shutdown_async(Test.AMD_Initial_shutdown cb, Ice.Current current) + public override Task shutdownAsync(Ice.Current current) { current.adapter.getCommunicator().shutdown(); - cb.ice_response(); + return null; } - public override void pingPong_async(Test.AMD_Initial_pingPong cb, Ice.Object obj, Ice.Current current) + public override Task<Ice.Value> + pingPongAsync(Ice.Value obj, Ice.Current current) { - cb.ice_response(obj); + return Task.FromResult<Ice.Value>(obj); } - public override void opOptionalException_async(Test.AMD_Initial_opOptionalException cb, Ice.Optional<int> a, - Ice.Optional<string> b, Ice.Optional<Test.OneOptional> o, - Ice.Current current) + public override Task + opOptionalExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c) { - cb.ice_exception(new Test.OptionalException(false, a, b, o)); + throw new OptionalException(false, a, b, o); } - public override void opDerivedException_async(Test.AMD_Initial_opDerivedException cb, Ice.Optional<int> a, - Ice.Optional<string> b, Ice.Optional<Test.OneOptional> o, - Ice.Current current) + public override Task + opDerivedExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c) { - cb.ice_exception(new Test.DerivedException(false, a, b, o, b, o)); + throw new DerivedException(false, a, b, o, b, o); } - public override void opRequiredException_async(Test.AMD_Initial_opRequiredException cb, Ice.Optional<int> a, - Ice.Optional<string> b, Ice.Optional<Test.OneOptional> o, - Ice.Current current) + public override Task + opRequiredExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c) { - Test.RequiredException e = new Test.RequiredException(); + var e = new RequiredException(); e.a = a; e.b = b; e.o = o; @@ -53,242 +52,308 @@ public class InitialI : Test.Initial { e.o2 = o.Value; } - cb.ice_exception(e); + throw e; } - public override void opByte_async(Test.AMD_Initial_opByte cb, Ice.Optional<byte> p1, Ice.Current current) + public override Task<Initial_OpByteResult> + opByteAsync(Ice.Optional<byte> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpByteResult>(new Initial_OpByteResult(p1, p1)); } - public override void opBool_async(Test.AMD_Initial_opBool cb, Ice.Optional<bool> p1, Ice.Current current) + public override Task<Initial_OpBoolResult> + opBoolAsync(Ice.Optional<bool> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpBoolResult>(new Initial_OpBoolResult(p1, p1)); } - public override void opShort_async(Test.AMD_Initial_opShort cb, Ice.Optional<short> p1, Ice.Current current) + public override Task<Initial_OpShortResult> + opShortAsync(Ice.Optional<short> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpShortResult>(new Initial_OpShortResult(p1, p1)); } - public override void opInt_async(Test.AMD_Initial_opInt cb, Ice.Optional<int> p1, Ice.Current current) + public override Task<Initial_OpIntResult> + opIntAsync(Ice.Optional<int> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpIntResult>(new Initial_OpIntResult(p1, p1)); } - public override void opLong_async(Test.AMD_Initial_opLong cb, Ice.Optional<long> p1, Ice.Current current) + public override Task<Initial_OpLongResult> + opLongAsync(Ice.Optional<long> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpLongResult>(new Initial_OpLongResult(p1, p1)); } - public override void opFloat_async(Test.AMD_Initial_opFloat cb, Ice.Optional<float> p1, Ice.Current current) + public override Task<Initial_OpFloatResult> + opFloatAsync(Ice.Optional<float> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpFloatResult>(new Initial_OpFloatResult(p1, p1)); } - public override void opDouble_async(Test.AMD_Initial_opDouble cb, Ice.Optional<double> p1, Ice.Current current) + public override Task<Initial_OpDoubleResult> + opDoubleAsync(Ice.Optional<double> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpDoubleResult>(new Initial_OpDoubleResult(p1, p1)); } - public override void opString_async(Test.AMD_Initial_opString cb, Ice.Optional<string> p1, Ice.Current current) + public override Task<Initial_OpStringResult> + opStringAsync(Ice.Optional<string> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpStringResult>(new Initial_OpStringResult(p1, p1)); } - public override void opMyEnum_async(Test.AMD_Initial_opMyEnum cb, Ice.Optional<Test.MyEnum> p1, Ice.Current current) + public override Task<Initial_OpMyEnumResult> + opMyEnumAsync(Ice.Optional<MyEnum> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpMyEnumResult>(new Initial_OpMyEnumResult(p1, p1)); } - public override void opSmallStruct_async(Test.AMD_Initial_opSmallStruct cb, Ice.Optional<Test.SmallStruct> p1, - Ice.Current current) + public override Task<Initial_OpSmallStructResult> + opSmallStructAsync(Ice.Optional<SmallStruct> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpSmallStructResult>(new Initial_OpSmallStructResult(p1, p1)); } - public override void opFixedStruct_async(Test.AMD_Initial_opFixedStruct cb, Ice.Optional<Test.FixedStruct> p1, - Ice.Current current) + public override Task<Initial_OpFixedStructResult> + opFixedStructAsync(Ice.Optional<FixedStruct> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpFixedStructResult>(new Initial_OpFixedStructResult(p1, p1)); } - public override void opVarStruct_async(Test.AMD_Initial_opVarStruct cb, Ice.Optional<Test.VarStruct> p1, - Ice.Current current) + public override Task<Initial_OpVarStructResult> + opVarStructAsync(Ice.Optional<VarStruct> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpVarStructResult>(new Initial_OpVarStructResult(p1, p1)); } - public override void opOneOptional_async(Test.AMD_Initial_opOneOptional cb, Ice.Optional<Test.OneOptional> p1, - Ice.Current current) + public override Task<Initial_OpOneOptionalResult> + opOneOptionalAsync(Ice.Optional<OneOptional> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpOneOptionalResult>(new Initial_OpOneOptionalResult(p1, p1)); } - public override void opOneOptionalProxy_async(Test.AMD_Initial_opOneOptionalProxy cb, - Ice.Optional<Test.OneOptionalPrx> p1, - Ice.Current current) + public override Task<Initial_OpOneOptionalProxyResult> + opOneOptionalProxyAsync(Ice.Optional<Ice.ObjectPrx> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpOneOptionalProxyResult>(new Initial_OpOneOptionalProxyResult(p1, p1)); } - public override void opByteSeq_async(Test.AMD_Initial_opByteSeq cb, Ice.Optional<byte[]> p1, Ice.Current current) + public override Task<Initial_OpByteSeqResult> + opByteSeqAsync(Ice.Optional<byte[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpByteSeqResult>(new Initial_OpByteSeqResult(p1, p1)); } - public override void opBoolSeq_async(Test.AMD_Initial_opBoolSeq cb, Ice.Optional<bool[]> p1, Ice.Current current) + public override Task<Initial_OpBoolSeqResult> + opBoolSeqAsync(Ice.Optional<bool[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpBoolSeqResult>(new Initial_OpBoolSeqResult(p1, p1)); } - public override void opShortSeq_async(Test.AMD_Initial_opShortSeq cb, Ice.Optional<short[]> p1, Ice.Current current) + public override Task<Initial_OpShortSeqResult> + opShortSeqAsync(Ice.Optional<short[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpShortSeqResult>(new Initial_OpShortSeqResult(p1, p1)); } - public override void opIntSeq_async(Test.AMD_Initial_opIntSeq cb, Ice.Optional<int[]> p1, Ice.Current current) + public override Task<Initial_OpIntSeqResult> + opIntSeqAsync(Ice.Optional<int[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpIntSeqResult>(new Initial_OpIntSeqResult(p1, p1)); } - public override void opLongSeq_async(Test.AMD_Initial_opLongSeq cb, Ice.Optional<long[]> p1, Ice.Current current) + public override Task<Initial_OpLongSeqResult> + opLongSeqAsync(Ice.Optional<long[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpLongSeqResult>(new Initial_OpLongSeqResult(p1, p1)); } - public override void opFloatSeq_async(Test.AMD_Initial_opFloatSeq cb, Ice.Optional<float[]> p1, Ice.Current current) + public override Task<Initial_OpFloatSeqResult> + opFloatSeqAsync(Ice.Optional<float[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpFloatSeqResult>(new Initial_OpFloatSeqResult(p1, p1)); } - public override void opDoubleSeq_async(Test.AMD_Initial_opDoubleSeq cb, Ice.Optional<double[]> p1, - Ice.Current current) + public override Task<Initial_OpDoubleSeqResult> + opDoubleSeqAsync(Ice.Optional<double[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpDoubleSeqResult>(new Initial_OpDoubleSeqResult(p1, p1)); } - public override void opStringSeq_async(Test.AMD_Initial_opStringSeq cb, Ice.Optional<string[]> p1, - Ice.Current current) + public override Task<Initial_OpStringSeqResult> + opStringSeqAsync(Ice.Optional<string[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpStringSeqResult>(new Initial_OpStringSeqResult(p1, p1)); } - public override void opSmallStructSeq_async(Test.AMD_Initial_opSmallStructSeq cb, - Ice.Optional<Test.SmallStruct[]> p1, - Ice.Current current) + public override Task<Initial_OpSmallStructSeqResult> + opSmallStructSeqAsync(Ice.Optional<SmallStruct[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpSmallStructSeqResult>(new Initial_OpSmallStructSeqResult(p1, p1)); } - public override void opSmallStructList_async(Test.AMD_Initial_opSmallStructList cb, - Ice.Optional<List<Test.SmallStruct>> p1, - Ice.Current current) + public override Task<Initial_OpSmallStructListResult> + opSmallStructListAsync(Ice.Optional<List<SmallStruct>> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpSmallStructListResult>(new Initial_OpSmallStructListResult(p1, p1)); } - public override void opFixedStructSeq_async(Test.AMD_Initial_opFixedStructSeq cb, - Ice.Optional<Test.FixedStruct[]> p1, - Ice.Current current) + public override Task<Initial_OpFixedStructSeqResult> + opFixedStructSeqAsync(Ice.Optional<FixedStruct[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpFixedStructSeqResult>(new Initial_OpFixedStructSeqResult(p1, p1)); } - public override void opFixedStructList_async(Test.AMD_Initial_opFixedStructList cb, - Ice.Optional<LinkedList<Test.FixedStruct>> p1, - Ice.Current current) + public override Task<Initial_OpFixedStructListResult> + opFixedStructListAsync(Ice.Optional<LinkedList<FixedStruct>> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpFixedStructListResult>(new Initial_OpFixedStructListResult(p1, p1)); } - public override void opVarStructSeq_async(Test.AMD_Initial_opVarStructSeq cb, Ice.Optional<Test.VarStruct[]> p1, - Ice.Current current) + public override Task<Initial_OpVarStructSeqResult> + opVarStructSeqAsync(Ice.Optional<VarStruct[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpVarStructSeqResult>(new Initial_OpVarStructSeqResult(p1, p1)); } -#if COMPACT || SILVERLIGHT - public override void opSerializable_async(Test.AMD_Initial_opSerializable cb, - Ice.Optional<byte[]> p1, - Ice.Current current) + public override Task<Initial_OpSerializableResult> + opSerializableAsync(Ice.Optional<SerializableClass> p1, Ice.Current current) { - cb.ice_response(p1, p1); + return Task.FromResult<Initial_OpSerializableResult>(new Initial_OpSerializableResult(p1, p1)); } -#else - public override void opSerializable_async(Test.AMD_Initial_opSerializable cb, - Ice.Optional<Test.SerializableClass> p1, - Ice.Current current) + + public override Task<Initial_OpIntIntDictResult> + opIntIntDictAsync(Ice.Optional<Dictionary<int, int>> p1, Ice.Current current) + { + return Task.FromResult<Initial_OpIntIntDictResult>(new Initial_OpIntIntDictResult(p1, p1)); + } + + public override Task<Initial_OpStringIntDictResult> + opStringIntDictAsync(Ice.Optional<Dictionary<string, int>> p1, Ice.Current current) + { + return Task.FromResult<Initial_OpStringIntDictResult>(new Initial_OpStringIntDictResult(p1, p1)); + } + + public override Task<Initial_OpIntOneOptionalDictResult> + opIntOneOptionalDictAsync(Ice.Optional<Dictionary<int, OneOptional>> p1, Ice.Current current) + { + return Task.FromResult<Initial_OpIntOneOptionalDictResult>(new Initial_OpIntOneOptionalDictResult(p1, p1)); + } + + public override Task + opClassAndUnknownOptionalAsync(A p, Ice.Current current) + { + return null; + } + + public override Task + sendOptionalClassAsync(bool req, Ice.Optional<OneOptional> o, Ice.Current current) + { + return null; + } + + public override Task<Ice.Optional<OneOptional>> + returnOptionalClassAsync(bool req, Ice.Current current) + { + return Task.FromResult<Ice.Optional<OneOptional>>(new Ice.Optional<OneOptional>(new OneOptional(53))); + } + + public override Task<G> + opGAsync(G g, Ice.Current current) + { + return Task.FromResult<G>(g); + } + + public override Task + opVoidAsync(Ice.Current current) + { + return null; + } + + public async override Task<Test.Initial_OpMStruct1MarshaledResult> + opMStruct1Async(Ice.Current current) + { + await Task.Delay(0); + return new Test.Initial_OpMStruct1MarshaledResult(new Test.SmallStruct(), current); + } + + public async override Task<Test.Initial_OpMStruct2MarshaledResult> + opMStruct2Async(Ice.Optional<Test.SmallStruct> p1, Ice.Current current) { - cb.ice_response(p1, p1); + await Task.Delay(0); + return new Test.Initial_OpMStruct2MarshaledResult(p1, p1, current); } -#endif - public override void opIntIntDict_async(Test.AMD_Initial_opIntIntDict cb, Ice.Optional<Dictionary<int, int>> p1, - Ice.Current current) + public async override Task<Test.Initial_OpMSeq1MarshaledResult> + opMSeq1Async(Ice.Current current) { - cb.ice_response(p1, p1); + await Task.Delay(0); + return new Test.Initial_OpMSeq1MarshaledResult(new string[0], current); } - public override void opStringIntDict_async(Test.AMD_Initial_opStringIntDict cb, - Ice.Optional<Dictionary<string, int>> p1, - Ice.Current current) + public async override Task<Test.Initial_OpMSeq2MarshaledResult> + opMSeq2Async(Ice.Optional<string[]> p1, Ice.Current current) { - cb.ice_response(p1, p1); + await Task.Delay(0); + return new Test.Initial_OpMSeq2MarshaledResult(p1, p1, current); } - public override void opClassAndUnknownOptional_async(Test.AMD_Initial_opClassAndUnknownOptional cb, Test.A p, - Ice.Current current) + public async override Task<Test.Initial_OpMDict1MarshaledResult> + opMDict1Async(Ice.Current current) { - cb.ice_response(); + await Task.Delay(0); + return new Test.Initial_OpMDict1MarshaledResult(new Dictionary<string, int>(), current); } - public override void sendOptionalClass_async(Test.AMD_Initial_sendOptionalClass cb, bool req, - Ice.Optional<Test.OneOptional> o, Ice.Current current) + public async override Task<Test.Initial_OpMDict2MarshaledResult> + opMDict2Async(Ice.Optional<Dictionary<string, int>> p1, Ice.Current current) { - cb.ice_response(); + await Task.Delay(0); + return new Test.Initial_OpMDict2MarshaledResult(p1, p1, current); } - public override void returnOptionalClass_async(Test.AMD_Initial_returnOptionalClass cb, bool req, - Ice.Current current) + public async override Task<Test.Initial_OpMG1MarshaledResult> + opMG1Async(Ice.Current current) { - cb.ice_response(new Test.OneOptional(53)); + await Task.Delay(0); + return new Test.Initial_OpMG1MarshaledResult(new Test.G(), current); } - public override void opG_async(Test.AMD_Initial_opG cb, Test.G g, Ice.Current current) + public async override Task<Test.Initial_OpMG2MarshaledResult> + opMG2Async(Ice.Optional<Test.G> p1, Ice.Current current) { - cb.ice_response(g); + await Task.Delay(0); + return new Test.Initial_OpMG2MarshaledResult(p1, p1, current); } - public override void opVoid_async(Test.AMD_Initial_opVoid cb, Ice.Current current) + public override Task<bool> + supportsRequiredParamsAsync(Ice.Current current) { - cb.ice_response(); + return Task.FromResult<bool>(false); } - public override void supportsRequiredParams_async(Test.AMD_Initial_supportsRequiredParams cb, Ice.Current current) + public override Task<bool> + supportsJavaSerializableAsync(Ice.Current current) { - cb.ice_response(false); + return Task.FromResult<bool>(false); } - public override void supportsJavaSerializable_async(Test.AMD_Initial_supportsJavaSerializable cb, - Ice.Current current) + public override Task<bool> + supportsCsharpSerializableAsync(Ice.Current current) { - cb.ice_response(false); + return Task.FromResult<bool>(true); } - public override void supportsCsharpSerializable_async(Test.AMD_Initial_supportsCsharpSerializable cb, - Ice.Current current) + public override Task<bool> + supportsCppStringViewAsync(Ice.Current current) { -#if COMPACT || SILVERLIGHT - cb.ice_response(false); -#else - cb.ice_response(true); -#endif + return Task.FromResult<bool>(false); } - public override void supportsCppStringView_async(Test.AMD_Initial_supportsCppStringView cb, - Ice.Current current) + public override Task<bool> + supportsNullOptionalAsync(Ice.Current current) { - cb.ice_response(false); + return Task.FromResult<bool>(true); } } |