Xamarin testsuite

1 files changed, 358 insertions, 341 deletions

diff --git a/csharp/test/Ice/optional/TestAMDI.cs b/csharp/test/Ice/optional/TestAMDI.cs
index 7a54196790c..ca1ab12c9c7 100644
--- a/csharp/test/Ice/optional/TestAMDI.cs
+++ b/csharp/test/Ice/optional/TestAMDI.cs
@@ -9,351 +9,368 @@
 
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Test;
 
-public class InitialI : Test.InitialDisp_
+namespace Ice
 {
-    public override Task shutdownAsync(Ice.Current current)
+    namespace optional
     {
-        current.adapter.getCommunicator().shutdown();
-        return null;
-    }
-
-    public override Task<Ice.Value>
-    pingPongAsync(Ice.Value obj, Ice.Current current)
-    {
-        return Task.FromResult<Ice.Value>(obj);
-    }
-
-    public override Task
-    opOptionalExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c)
-    {
-        throw new OptionalException(false, a, b, o);
-    }
-
-    public override Task
-    opDerivedExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c)
-    {
-        throw new DerivedException(false, a, b, o, b, o);
-    }
-
-    public override Task
-    opRequiredExceptionAsync(Ice.Optional<int> a, Ice.Optional<string> b, Ice.Optional<OneOptional> o, Ice.Current c)
-    {
-        var e = new RequiredException();
-        e.a = a;
-        e.b = b;
-        e.o = o;
-        if(b.HasValue)
-        {
-            e.ss = b.Value;
-        }
-        if(o.HasValue)
+        namespace AMD
         {
-            e.o2 = o.Value;
+            public class InitialI : Test.InitialDisp_
+            {
+                public override Task shutdownAsync(Ice.Current current)
+                {
+                    current.adapter.getCommunicator().shutdown();
+                    return null;
+                }
+
+                public override Task<Ice.Value>
+                pingPongAsync(Ice.Value obj, Ice.Current current)
+                {
+                    return Task.FromResult<Ice.Value>(obj);
+                }
+
+                public override Task
+                opOptionalExceptionAsync(Ice.Optional<int> a,
+                                         Ice.Optional<string> b,
+                                         Ice.Optional<Test.OneOptional> o,
+                                         Ice.Current c)
+                {
+                    throw new Test.OptionalException(false, a, b, o);
+                }
+
+                public override Task
+                opDerivedExceptionAsync(Ice.Optional<int> a,
+                                        Ice.Optional<string> b,
+                                        Ice.Optional<Test.OneOptional> o,
+                                        Ice.Current c)
+                {
+                    throw new Test.DerivedException(false, a, b, o, b, o);
+                }
+
+                public override Task
+                opRequiredExceptionAsync(Ice.Optional<int> a,
+                                         Ice.Optional<string> b,
+                                         Ice.Optional<Test.OneOptional> o,
+                                         Ice.Current c)
+                {
+                    var e = new Test.RequiredException();
+                    e.a = a;
+                    e.b = b;
+                    e.o = o;
+                    if(b.HasValue)
+                    {
+                        e.ss = b.Value;
+                    }
+                    if(o.HasValue)
+                    {
+                        e.o2 = o.Value;
+                    }
+                    throw e;
+                }
+
+                public override Task<Test.Initial_OpByteResult>
+                opByteAsync(Ice.Optional<byte> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpByteResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpBoolResult>
+                opBoolAsync(Ice.Optional<bool> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpBoolResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpShortResult>
+                opShortAsync(Ice.Optional<short> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpShortResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpIntResult>
+                opIntAsync(Ice.Optional<int> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpIntResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpLongResult>
+                opLongAsync(Ice.Optional<long> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpLongResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpFloatResult>
+                opFloatAsync(Ice.Optional<float> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpFloatResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpDoubleResult>
+                opDoubleAsync(Ice.Optional<double> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpDoubleResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpStringResult>
+                opStringAsync(Ice.Optional<string> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpStringResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpMyEnumResult>
+                opMyEnumAsync(Ice.Optional<Test.MyEnum> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpMyEnumResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpSmallStructResult>
+                opSmallStructAsync(Ice.Optional<Test.SmallStruct> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpSmallStructResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpFixedStructResult>
+                opFixedStructAsync(Ice.Optional<Test.FixedStruct> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpFixedStructResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpVarStructResult>
+                opVarStructAsync(Ice.Optional<Test.VarStruct> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpVarStructResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpOneOptionalResult>
+                opOneOptionalAsync(Ice.Optional<Test.OneOptional> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpOneOptionalResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpOneOptionalProxyResult>
+                opOneOptionalProxyAsync(Ice.Optional<Ice.ObjectPrx> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpOneOptionalProxyResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpByteSeqResult>
+                opByteSeqAsync(Ice.Optional<byte[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpByteSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpBoolSeqResult>
+                opBoolSeqAsync(Ice.Optional<bool[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpBoolSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpShortSeqResult>
+                opShortSeqAsync(Ice.Optional<short[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpShortSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpIntSeqResult>
+                opIntSeqAsync(Ice.Optional<int[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpIntSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpLongSeqResult>
+                opLongSeqAsync(Ice.Optional<long[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpLongSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpFloatSeqResult>
+                opFloatSeqAsync(Ice.Optional<float[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpFloatSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpDoubleSeqResult>
+                opDoubleSeqAsync(Ice.Optional<double[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpDoubleSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpStringSeqResult>
+                opStringSeqAsync(Ice.Optional<string[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpStringSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpSmallStructSeqResult>
+                opSmallStructSeqAsync(Ice.Optional<Test.SmallStruct[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpSmallStructSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpSmallStructListResult>
+                opSmallStructListAsync(Ice.Optional<List<Test.SmallStruct>> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpSmallStructListResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpFixedStructSeqResult>
+                opFixedStructSeqAsync(Ice.Optional<Test.FixedStruct[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpFixedStructSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpFixedStructListResult>
+                opFixedStructListAsync(Ice.Optional<LinkedList<Test.FixedStruct>> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpFixedStructListResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpVarStructSeqResult>
+                opVarStructSeqAsync(Ice.Optional<Test.VarStruct[]> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpVarStructSeqResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpSerializableResult>
+                opSerializableAsync(Ice.Optional<Ice.optional.Test.SerializableClass> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpSerializableResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpIntIntDictResult>
+                opIntIntDictAsync(Ice.Optional<Dictionary<int, int>> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpIntIntDictResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpStringIntDictResult>
+                opStringIntDictAsync(Ice.Optional<Dictionary<string, int>> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpStringIntDictResult(p1, p1));
+                }
+
+                public override Task<Test.Initial_OpIntOneOptionalDictResult>
+                opIntOneOptionalDictAsync(Ice.Optional<Dictionary<int, Test.OneOptional>> p1, Ice.Current current)
+                {
+                    return Task.FromResult(new Test.Initial_OpIntOneOptionalDictResult(p1, p1));
+                }
+
+                public override Task
+                opClassAndUnknownOptionalAsync(Test.A p, Ice.Current current)
+                {
+                    return null;
+                }
+
+                public override Task
+                sendOptionalClassAsync(bool req, Ice.Optional<Test.OneOptional> o, Ice.Current current)
+                {
+                    return null;
+                }
+
+                public override Task<Ice.Optional<Test.OneOptional>>
+                returnOptionalClassAsync(bool req, Ice.Current current)
+                {
+                    return Task.FromResult(new Ice.Optional<Test.OneOptional>(new Test.OneOptional(53)));
+                }
+
+                public override Task<Test.G>
+                opGAsync(Test.G g, Ice.Current current)
+                {
+                    return Task.FromResult(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)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMStruct2MarshaledResult(p1, p1, current);
+                }
+
+                public async override Task<Test.Initial_OpMSeq1MarshaledResult>
+                opMSeq1Async(Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMSeq1MarshaledResult(new string[0], current);
+                }
+
+                public async override Task<Test.Initial_OpMSeq2MarshaledResult>
+                opMSeq2Async(Ice.Optional<string[]> p1, Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMSeq2MarshaledResult(p1, p1, current);
+                }
+
+                public async override Task<Test.Initial_OpMDict1MarshaledResult>
+                opMDict1Async(Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMDict1MarshaledResult(new Dictionary<string, int>(), current);
+                }
+
+                public async override Task<Test.Initial_OpMDict2MarshaledResult>
+                opMDict2Async(Ice.Optional<Dictionary<string, int>> p1, Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMDict2MarshaledResult(p1, p1, current);
+                }
+
+                public async override Task<Test.Initial_OpMG1MarshaledResult>
+                opMG1Async(Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMG1MarshaledResult(new Test.G(), current);
+                }
+
+                public async override Task<Test.Initial_OpMG2MarshaledResult>
+                opMG2Async(Ice.Optional<Test.G> p1, Ice.Current current)
+                {
+                    await Task.Delay(0);
+                    return new Test.Initial_OpMG2MarshaledResult(p1, p1, current);
+                }
+
+                public override Task<bool>
+                supportsRequiredParamsAsync(Ice.Current current)
+                {
+                    return Task.FromResult<bool>(false);
+                }
+
+                public override Task<bool>
+                supportsJavaSerializableAsync(Ice.Current current)
+                {
+                    return Task.FromResult<bool>(false);
+                }
+
+                public override Task<bool>
+                supportsCsharpSerializableAsync(Ice.Current current)
+                {
+                    return Task.FromResult<bool>(true);
+                }
+
+                public override Task<bool>
+                supportsCppStringViewAsync(Ice.Current current)
+                {
+                    return Task.FromResult<bool>(false);
+                }
+
+                public override Task<bool>
+                supportsNullOptionalAsync(Ice.Current current)
+                {
+                    return Task.FromResult<bool>(true);
+                }
+            }
         }
-        throw e;
-    }
-
-    public override Task<Initial_OpByteResult>
-    opByteAsync(Ice.Optional<byte> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpByteResult>(new Initial_OpByteResult(p1, p1));
-    }
-
-    public override Task<Initial_OpBoolResult>
-    opBoolAsync(Ice.Optional<bool> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpBoolResult>(new Initial_OpBoolResult(p1, p1));
-    }
-
-    public override Task<Initial_OpShortResult>
-    opShortAsync(Ice.Optional<short> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpShortResult>(new Initial_OpShortResult(p1, p1));
-    }
-
-    public override Task<Initial_OpIntResult>
-    opIntAsync(Ice.Optional<int> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpIntResult>(new Initial_OpIntResult(p1, p1));
-    }
-
-    public override Task<Initial_OpLongResult>
-    opLongAsync(Ice.Optional<long> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpLongResult>(new Initial_OpLongResult(p1, p1));
-    }
-
-    public override Task<Initial_OpFloatResult>
-    opFloatAsync(Ice.Optional<float> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpFloatResult>(new Initial_OpFloatResult(p1, p1));
-    }
-
-    public override Task<Initial_OpDoubleResult>
-    opDoubleAsync(Ice.Optional<double> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpDoubleResult>(new Initial_OpDoubleResult(p1, p1));
-    }
-
-    public override Task<Initial_OpStringResult>
-    opStringAsync(Ice.Optional<string> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpStringResult>(new Initial_OpStringResult(p1, p1));
-    }
-
-    public override Task<Initial_OpMyEnumResult>
-    opMyEnumAsync(Ice.Optional<MyEnum> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpMyEnumResult>(new Initial_OpMyEnumResult(p1, p1));
-    }
-
-    public override Task<Initial_OpSmallStructResult>
-    opSmallStructAsync(Ice.Optional<SmallStruct> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpSmallStructResult>(new Initial_OpSmallStructResult(p1, p1));
-    }
-
-    public override Task<Initial_OpFixedStructResult>
-    opFixedStructAsync(Ice.Optional<FixedStruct> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpFixedStructResult>(new Initial_OpFixedStructResult(p1, p1));
-    }
-
-    public override Task<Initial_OpVarStructResult>
-    opVarStructAsync(Ice.Optional<VarStruct> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpVarStructResult>(new Initial_OpVarStructResult(p1, p1));
-    }
-
-    public override Task<Initial_OpOneOptionalResult>
-    opOneOptionalAsync(Ice.Optional<OneOptional> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpOneOptionalResult>(new Initial_OpOneOptionalResult(p1, p1));
-    }
-
-    public override Task<Initial_OpOneOptionalProxyResult>
-    opOneOptionalProxyAsync(Ice.Optional<Ice.ObjectPrx> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpOneOptionalProxyResult>(new Initial_OpOneOptionalProxyResult(p1, p1));
-    }
-
-    public override Task<Initial_OpByteSeqResult>
-    opByteSeqAsync(Ice.Optional<byte[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpByteSeqResult>(new Initial_OpByteSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpBoolSeqResult>
-    opBoolSeqAsync(Ice.Optional<bool[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpBoolSeqResult>(new Initial_OpBoolSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpShortSeqResult>
-    opShortSeqAsync(Ice.Optional<short[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpShortSeqResult>(new Initial_OpShortSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpIntSeqResult>
-    opIntSeqAsync(Ice.Optional<int[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpIntSeqResult>(new Initial_OpIntSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpLongSeqResult>
-    opLongSeqAsync(Ice.Optional<long[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpLongSeqResult>(new Initial_OpLongSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpFloatSeqResult>
-    opFloatSeqAsync(Ice.Optional<float[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpFloatSeqResult>(new Initial_OpFloatSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpDoubleSeqResult>
-    opDoubleSeqAsync(Ice.Optional<double[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpDoubleSeqResult>(new Initial_OpDoubleSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpStringSeqResult>
-    opStringSeqAsync(Ice.Optional<string[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpStringSeqResult>(new Initial_OpStringSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpSmallStructSeqResult>
-    opSmallStructSeqAsync(Ice.Optional<SmallStruct[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpSmallStructSeqResult>(new Initial_OpSmallStructSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpSmallStructListResult>
-    opSmallStructListAsync(Ice.Optional<List<SmallStruct>> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpSmallStructListResult>(new Initial_OpSmallStructListResult(p1, p1));
-    }
-
-    public override Task<Initial_OpFixedStructSeqResult>
-    opFixedStructSeqAsync(Ice.Optional<FixedStruct[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpFixedStructSeqResult>(new Initial_OpFixedStructSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpFixedStructListResult>
-    opFixedStructListAsync(Ice.Optional<LinkedList<FixedStruct>> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpFixedStructListResult>(new Initial_OpFixedStructListResult(p1, p1));
-    }
-
-    public override Task<Initial_OpVarStructSeqResult>
-    opVarStructSeqAsync(Ice.Optional<VarStruct[]> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpVarStructSeqResult>(new Initial_OpVarStructSeqResult(p1, p1));
-    }
-
-    public override Task<Initial_OpSerializableResult>
-    opSerializableAsync(Ice.Optional<SerializableClass> p1, Ice.Current current)
-    {
-        return Task.FromResult<Initial_OpSerializableResult>(new Initial_OpSerializableResult(p1, p1));
-    }
-
-    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)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMStruct2MarshaledResult(p1, p1, current);
-    }
-
-    public async override Task<Test.Initial_OpMSeq1MarshaledResult>
-    opMSeq1Async(Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMSeq1MarshaledResult(new string[0], current);
-    }
-
-    public async override Task<Test.Initial_OpMSeq2MarshaledResult>
-    opMSeq2Async(Ice.Optional<string[]> p1, Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMSeq2MarshaledResult(p1, p1, current);
-    }
-
-    public async override Task<Test.Initial_OpMDict1MarshaledResult>
-    opMDict1Async(Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMDict1MarshaledResult(new Dictionary<string, int>(), current);
-    }
-
-    public async override Task<Test.Initial_OpMDict2MarshaledResult>
-    opMDict2Async(Ice.Optional<Dictionary<string, int>> p1, Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMDict2MarshaledResult(p1, p1, current);
-    }
-
-    public async override Task<Test.Initial_OpMG1MarshaledResult>
-    opMG1Async(Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMG1MarshaledResult(new Test.G(), current);
-    }
-
-    public async override Task<Test.Initial_OpMG2MarshaledResult>
-    opMG2Async(Ice.Optional<Test.G> p1, Ice.Current current)
-    {
-        await Task.Delay(0);
-        return new Test.Initial_OpMG2MarshaledResult(p1, p1, current);
-    }
-
-    public override Task<bool>
-    supportsRequiredParamsAsync(Ice.Current current)
-    {
-        return Task.FromResult<bool>(false);
-    }
-
-    public override Task<bool>
-    supportsJavaSerializableAsync(Ice.Current current)
-    {
-        return Task.FromResult<bool>(false);
-    }
-
-    public override Task<bool>
-    supportsCsharpSerializableAsync(Ice.Current current)
-    {
-        return Task.FromResult<bool>(true);
-    }
-
-    public override Task<bool>
-    supportsCppStringViewAsync(Ice.Current current)
-    {
-        return Task.FromResult<bool>(false);
-    }
-
-    public override Task<bool>
-    supportsNullOptionalAsync(Ice.Current current)
-    {
-        return Task.FromResult<bool>(true);
     }
 }