1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4 
5 using System.Diagnostics;
6 using System.Collections.Generic;
7 
8 namespace Ice
9 {
10     namespace seqMapping
11     {
12         public class TwowaysAMI
13         {
test(bool b)14             private static void test(bool b)
15             {
16                 if(!b)
17                 {
18                     throw new System.SystemException();
19                 }
20             }
21 
22             private class CallbackBase
23             {
CallbackBase()24                 internal CallbackBase()
25                 {
26                     _called = false;
27                 }
28 
check()29                 public virtual void check()
30                 {
31                     lock(this)
32                     {
33                         while(!_called)
34                         {
35                             System.Threading.Monitor.Wait(this);
36                         }
37 
38                         _called = false;
39                     }
40                 }
41 
called()42                 public virtual void called()
43                 {
44                     lock(this)
45                     {
46                         Debug.Assert(!_called);
47                         _called = true;
48                         System.Threading.Monitor.Pulse(this);
49                     }
50                 }
51 
52                 private bool _called;
53             }
54 
55             private class Callback
56             {
opAByteSI(Ice.AsyncResult result)57                 public void opAByteSI(Ice.AsyncResult result)
58                 {
59                     byte[] i =(byte[])result.AsyncState;
60                     byte[] o;
61                     byte[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAByteS(out o, result);
62                     test(Ice.CollectionComparer.Equals(i, o));
63                     test(Ice.CollectionComparer.Equals(i, r));
64                     callback.called();
65                 }
66 
opLByteSI(Ice.AsyncResult result)67                 public void opLByteSI(Ice.AsyncResult result)
68                 {
69                     List<byte> i =(List<byte>)result.AsyncState;
70                     List<byte> o;
71                     List<byte> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLByteS(out o, result);
72                     test(Ice.CollectionComparer.Equals(i, o));
73                     test(Ice.CollectionComparer.Equals(i, r));
74                     callback.called();
75                 }
76 
opKByteSI(Ice.AsyncResult result)77                 public void opKByteSI(Ice.AsyncResult result)
78                 {
79                     LinkedList<byte> i =(LinkedList<byte>)result.AsyncState;
80                     LinkedList<byte> o;
81                     LinkedList<byte> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKByteS(out o, result);
82                     test(Ice.CollectionComparer.Equals(i, o));
83                     test(Ice.CollectionComparer.Equals(i, r));
84                     callback.called();
85                 }
86 
opQByteSI(Ice.AsyncResult result)87                 public void opQByteSI(Ice.AsyncResult result)
88                 {
89                     Queue<byte> i =(Queue<byte>)result.AsyncState;
90                     Queue<byte> o;
91                     Queue<byte> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQByteS(out o, result);
92                     test(Ice.CollectionComparer.Equals(i, o));
93                     test(Ice.CollectionComparer.Equals(i, r));
94                     callback.called();
95                 }
96 
opSByteSI(Ice.AsyncResult result)97                 public void opSByteSI(Ice.AsyncResult result)
98                 {
99                     Stack<byte> i =(Stack<byte>)result.AsyncState;
100                     Stack<byte> o;
101                     Stack<byte> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSByteS(out o, result);
102                     test(Ice.CollectionComparer.Equals(i, o));
103                     test(Ice.CollectionComparer.Equals(i, r));
104                     callback.called();
105                 }
106 
opABoolSI(Ice.AsyncResult result)107                 public void opABoolSI(Ice.AsyncResult result)
108                 {
109                     bool[] i =(bool[])result.AsyncState;
110                     bool[] o;
111                     bool[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opABoolS(out o, result);
112                     test(Ice.CollectionComparer.Equals(i, o));
113                     test(Ice.CollectionComparer.Equals(i, r));
114                     callback.called();
115                 }
116 
opLBoolSI(Ice.AsyncResult result)117                 public void opLBoolSI(Ice.AsyncResult result)
118                 {
119                     List<bool> i =(List<bool>)result.AsyncState;
120                     List<bool> o;
121                     List<bool> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLBoolS(out o, result);
122                     test(Ice.CollectionComparer.Equals(i, o));
123                     test(Ice.CollectionComparer.Equals(i, r));
124                     callback.called();
125                 }
126 
opKBoolSI(Ice.AsyncResult result)127                 public void opKBoolSI(Ice.AsyncResult result)
128                 {
129                     LinkedList<bool> i =(LinkedList<bool>)result.AsyncState;
130                     LinkedList<bool> o;
131                     LinkedList<bool> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKBoolS(out o, result);
132                     test(Ice.CollectionComparer.Equals(i, o));
133                     test(Ice.CollectionComparer.Equals(i, r));
134                     callback.called();
135                 }
136 
opQBoolSI(Ice.AsyncResult result)137                 public void opQBoolSI(Ice.AsyncResult result)
138                 {
139                     Queue<bool> i =(Queue<bool>)result.AsyncState;
140                     Queue<bool> o;
141                     Queue<bool> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQBoolS(out o, result);
142                     test(Ice.CollectionComparer.Equals(i, o));
143                     test(Ice.CollectionComparer.Equals(i, r));
144                     callback.called();
145                 }
146 
opSBoolSI(Ice.AsyncResult result)147                 public void opSBoolSI(Ice.AsyncResult result)
148                 {
149                     Stack<bool> i =(Stack<bool>)result.AsyncState;
150                     Stack<bool> o;
151                     Stack<bool> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSBoolS(out o, result);
152                     test(Ice.CollectionComparer.Equals(i, o));
153                     test(Ice.CollectionComparer.Equals(i, r));
154                     callback.called();
155                 }
156 
opAShortSI(Ice.AsyncResult result)157                 public void opAShortSI(Ice.AsyncResult result)
158                 {
159                     short[] i =(short[])result.AsyncState;
160                     short[] o;
161                     short[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAShortS(out o, result);
162                     test(Ice.CollectionComparer.Equals(i, o));
163                     test(Ice.CollectionComparer.Equals(i, r));
164                     callback.called();
165                 }
166 
opLShortSI(Ice.AsyncResult result)167                 public void opLShortSI(Ice.AsyncResult result)
168                 {
169                     List<short> i =(List<short>)result.AsyncState;
170                     List<short> o;
171                     List<short> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLShortS(out o, result);
172                     test(Ice.CollectionComparer.Equals(i, o));
173                     test(Ice.CollectionComparer.Equals(i, r));
174                     callback.called();
175                 }
176 
opKShortSI(Ice.AsyncResult result)177                 public void opKShortSI(Ice.AsyncResult result)
178                 {
179                     LinkedList<short> i =(LinkedList<short>)result.AsyncState;
180                     LinkedList<short> o;
181                     LinkedList<short> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKShortS(out o, result);
182                     test(Ice.CollectionComparer.Equals(i, o));
183                     test(Ice.CollectionComparer.Equals(i, r));
184                     callback.called();
185                 }
186 
opQShortSI(Ice.AsyncResult result)187                 public void opQShortSI(Ice.AsyncResult result)
188                 {
189                     Queue<short> i =(Queue<short>)result.AsyncState;
190                     Queue<short> o;
191                     Queue<short> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQShortS(out o, result);
192                     test(Ice.CollectionComparer.Equals(i, o));
193                     test(Ice.CollectionComparer.Equals(i, r));
194                     callback.called();
195                 }
196 
opSShortSI(Ice.AsyncResult result)197                 public void opSShortSI(Ice.AsyncResult result)
198                 {
199                     Stack<short> i =(Stack<short>)result.AsyncState;
200                     Stack<short> o;
201                     Stack<short> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSShortS(out o, result);
202                     test(Ice.CollectionComparer.Equals(i, o));
203                     test(Ice.CollectionComparer.Equals(i, r));
204                     callback.called();
205                 }
206 
opAIntSI(Ice.AsyncResult result)207                 public void opAIntSI(Ice.AsyncResult result)
208                 {
209                     int[] i =(int[])result.AsyncState;
210                     int[] o;
211                     int[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAIntS(out o, result);
212                     test(Ice.CollectionComparer.Equals(i, o));
213                     test(Ice.CollectionComparer.Equals(i, r));
214                     callback.called();
215                 }
216 
opLIntSI(Ice.AsyncResult result)217                 public void opLIntSI(Ice.AsyncResult result)
218                 {
219                     List<int> i =(List<int>)result.AsyncState;
220                     List<int> o;
221                     List<int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLIntS(out o, result);
222                     test(Ice.CollectionComparer.Equals(i, o));
223                     test(Ice.CollectionComparer.Equals(i, r));
224                     callback.called();
225                 }
226 
opKIntSI(Ice.AsyncResult result)227                 public void opKIntSI(Ice.AsyncResult result)
228                 {
229                     LinkedList<int> i =(LinkedList<int>)result.AsyncState;
230                     LinkedList<int> o;
231                     LinkedList<int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKIntS(out o, result);
232                     test(Ice.CollectionComparer.Equals(i, o));
233                     test(Ice.CollectionComparer.Equals(i, r));
234                     callback.called();
235                 }
236 
opQIntSI(Ice.AsyncResult result)237                 public void opQIntSI(Ice.AsyncResult result)
238                 {
239                     Queue<int> i =(Queue<int>)result.AsyncState;
240                     Queue<int> o;
241                     Queue<int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQIntS(out o, result);
242                     test(Ice.CollectionComparer.Equals(i, o));
243                     test(Ice.CollectionComparer.Equals(i, r));
244                     callback.called();
245                 }
246 
opSIntSI(Ice.AsyncResult result)247                 public void opSIntSI(Ice.AsyncResult result)
248                 {
249                     Stack<int> i =(Stack<int>)result.AsyncState;
250                     Stack<int> o;
251                     Stack<int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSIntS(out o, result);
252                     test(Ice.CollectionComparer.Equals(i, o));
253                     test(Ice.CollectionComparer.Equals(i, r));
254                     callback.called();
255                 }
256 
opALongSI(Ice.AsyncResult result)257                 public void opALongSI(Ice.AsyncResult result)
258                 {
259                     long[] i =(long[])result.AsyncState;
260                     long[] o;
261                     long[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opALongS(out o, result);
262                     test(Ice.CollectionComparer.Equals(i, o));
263                     test(Ice.CollectionComparer.Equals(i, r));
264                     callback.called();
265                 }
266 
opLLongSI(Ice.AsyncResult result)267                 public void opLLongSI(Ice.AsyncResult result)
268                 {
269                     List<long> i =(List<long>)result.AsyncState;
270                     List<long> o;
271                     List<long> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLLongS(out o, result);
272                     test(Ice.CollectionComparer.Equals(i, o));
273                     test(Ice.CollectionComparer.Equals(i, r));
274                     callback.called();
275                 }
276 
opKLongSI(Ice.AsyncResult result)277                 public void opKLongSI(Ice.AsyncResult result)
278                 {
279                     LinkedList<long> i =(LinkedList<long>)result.AsyncState;
280                     LinkedList<long> o;
281                     LinkedList<long> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKLongS(out o, result);
282                     test(Ice.CollectionComparer.Equals(i, o));
283                     test(Ice.CollectionComparer.Equals(i, r));
284                     callback.called();
285                 }
286 
opQLongSI(Ice.AsyncResult result)287                 public void opQLongSI(Ice.AsyncResult result)
288                 {
289                     Queue<long> i =(Queue<long>)result.AsyncState;
290                     Queue<long> o;
291                     Queue<long> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQLongS(out o, result);
292                     test(Ice.CollectionComparer.Equals(i, o));
293                     test(Ice.CollectionComparer.Equals(i, r));
294                     callback.called();
295                 }
296 
opSLongSI(Ice.AsyncResult result)297                 public void opSLongSI(Ice.AsyncResult result)
298                 {
299                     Stack<long> i =(Stack<long>)result.AsyncState;
300                     Stack<long> o;
301                     Stack<long> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSLongS(out o, result);
302                     test(Ice.CollectionComparer.Equals(i, o));
303                     test(Ice.CollectionComparer.Equals(i, r));
304                     callback.called();
305                 }
306 
opAFloatSI(Ice.AsyncResult result)307                 public void opAFloatSI(Ice.AsyncResult result)
308                 {
309                     float[] i =(float[])result.AsyncState;
310                     float[] o;
311                     float[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAFloatS(out o, result);
312                     test(Ice.CollectionComparer.Equals(i, o));
313                     test(Ice.CollectionComparer.Equals(i, r));
314                     callback.called();
315                 }
316 
opLFloatSI(Ice.AsyncResult result)317                 public void opLFloatSI(Ice.AsyncResult result)
318                 {
319                     List<float> i =(List<float>)result.AsyncState;
320                     List<float> o;
321                     List<float> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLFloatS(out o, result);
322                     test(Ice.CollectionComparer.Equals(i, o));
323                     test(Ice.CollectionComparer.Equals(i, r));
324                     callback.called();
325                 }
326 
opKFloatSI(Ice.AsyncResult result)327                 public void opKFloatSI(Ice.AsyncResult result)
328                 {
329                     LinkedList<float> i =(LinkedList<float>)result.AsyncState;
330                     LinkedList<float> o;
331                     LinkedList<float> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKFloatS(out o, result);
332                     test(Ice.CollectionComparer.Equals(i, o));
333                     test(Ice.CollectionComparer.Equals(i, r));
334                     callback.called();
335                 }
336 
opQFloatSI(Ice.AsyncResult result)337                 public void opQFloatSI(Ice.AsyncResult result)
338                 {
339                     Queue<float> i =(Queue<float>)result.AsyncState;
340                     Queue<float> o;
341                     Queue<float> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQFloatS(out o, result);
342                     test(Ice.CollectionComparer.Equals(i, o));
343                     test(Ice.CollectionComparer.Equals(i, r));
344                     callback.called();
345                 }
346 
opSFloatSI(Ice.AsyncResult result)347                 public void opSFloatSI(Ice.AsyncResult result)
348                 {
349                     Stack<float> i =(Stack<float>)result.AsyncState;
350                     Stack<float> o;
351                     Stack<float> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSFloatS(out o, result);
352                     test(Ice.CollectionComparer.Equals(i, o));
353                     test(Ice.CollectionComparer.Equals(i, r));
354                     callback.called();
355                 }
356 
opADoubleSI(Ice.AsyncResult result)357                 public void opADoubleSI(Ice.AsyncResult result)
358                 {
359                     double[] i =(double[])result.AsyncState;
360                     double[] o;
361                     double[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opADoubleS(out o, result);
362                     test(Ice.CollectionComparer.Equals(i, o));
363                     test(Ice.CollectionComparer.Equals(i, r));
364                     callback.called();
365                 }
366 
opLDoubleSI(Ice.AsyncResult result)367                 public void opLDoubleSI(Ice.AsyncResult result)
368                 {
369                     List<double> i =(List<double>)result.AsyncState;
370                     List<double> o;
371                     List<double> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLDoubleS(out o, result);
372                     test(Ice.CollectionComparer.Equals(i, o));
373                     test(Ice.CollectionComparer.Equals(i, r));
374                     callback.called();
375                 }
376 
opKDoubleSI(Ice.AsyncResult result)377                 public void opKDoubleSI(Ice.AsyncResult result)
378                 {
379                     LinkedList<double> i =(LinkedList<double>)result.AsyncState;
380                     LinkedList<double> o;
381                     LinkedList<double> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKDoubleS(out o, result);
382                     test(Ice.CollectionComparer.Equals(i, o));
383                     test(Ice.CollectionComparer.Equals(i, r));
384                     callback.called();
385                 }
386 
opQDoubleSI(Ice.AsyncResult result)387                 public void opQDoubleSI(Ice.AsyncResult result)
388                 {
389                     Queue<double> i =(Queue<double>)result.AsyncState;
390                     Queue<double> o;
391                     Queue<double> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQDoubleS(out o, result);
392                     test(Ice.CollectionComparer.Equals(i, o));
393                     test(Ice.CollectionComparer.Equals(i, r));
394                     callback.called();
395                 }
396 
opSDoubleSI(Ice.AsyncResult result)397                 public void opSDoubleSI(Ice.AsyncResult result)
398                 {
399                     Stack<double> i =(Stack<double>)result.AsyncState;
400                     Stack<double> o;
401                     Stack<double> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSDoubleS(out o, result);
402                     test(Ice.CollectionComparer.Equals(i, o));
403                     test(Ice.CollectionComparer.Equals(i, r));
404                     callback.called();
405                 }
406 
opAStringSI(Ice.AsyncResult result)407                 public void opAStringSI(Ice.AsyncResult result)
408                 {
409                     string[] i =(string[])result.AsyncState;
410                     string[] o;
411                     string[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAStringS(out o, result);
412                     test(Ice.CollectionComparer.Equals(i, o));
413                     test(Ice.CollectionComparer.Equals(i, r));
414                     callback.called();
415                 }
416 
opLStringSI(Ice.AsyncResult result)417                 public void opLStringSI(Ice.AsyncResult result)
418                 {
419                     List<string> i =(List<string>)result.AsyncState;
420                     List<string> o;
421                     List<string> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLStringS(out o, result);
422                     test(Ice.CollectionComparer.Equals(i, o));
423                     test(Ice.CollectionComparer.Equals(i, r));
424                     callback.called();
425                 }
426 
opKStringSI(Ice.AsyncResult result)427                 public void opKStringSI(Ice.AsyncResult result)
428                 {
429                     LinkedList<string> i =(LinkedList<string>)result.AsyncState;
430                     LinkedList<string> o;
431                     LinkedList<string> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKStringS(out o, result);
432                     test(Ice.CollectionComparer.Equals(i, o));
433                     test(Ice.CollectionComparer.Equals(i, r));
434                     callback.called();
435                 }
436 
opQStringSI(Ice.AsyncResult result)437                 public void opQStringSI(Ice.AsyncResult result)
438                 {
439                     Queue<string> i =(Queue<string>)result.AsyncState;
440                     Queue<string> o;
441                     Queue<string> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQStringS(out o, result);
442                     test(Ice.CollectionComparer.Equals(i, o));
443                     test(Ice.CollectionComparer.Equals(i, r));
444                     callback.called();
445                 }
446 
opSStringSI(Ice.AsyncResult result)447                 public void opSStringSI(Ice.AsyncResult result)
448                 {
449                     Stack<string> i =(Stack<string>)result.AsyncState;
450                     Stack<string> o;
451                     Stack<string> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSStringS(out o, result);
452                     test(Ice.CollectionComparer.Equals(i, o));
453                     test(Ice.CollectionComparer.Equals(i, r));
454                     callback.called();
455                 }
456 
opAObjectSI(Ice.AsyncResult result)457                 public void opAObjectSI(Ice.AsyncResult result)
458                 {
459                     Ice.Value[] i =(Ice.Value[])result.AsyncState;
460                     Ice.Value[] o;
461                     Ice.Value[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAObjectS(out o, result);
462                     System.Collections.IEnumerator eo = o.GetEnumerator();
463                     System.Collections.IEnumerator er = r.GetEnumerator();
464                     foreach(Test.CV obj in i)
465                     {
466                         eo.MoveNext();
467                         er.MoveNext();
468                         test(obj.i ==((Test.CV)eo.Current).i);
469                         test(obj.i ==((Test.CV)er.Current).i);
470                     }
471                     callback.called();
472                 }
473 
opLObjectSI(Ice.AsyncResult result)474                 public void opLObjectSI(Ice.AsyncResult result)
475                 {
476                     List<Ice.Value> i =(List<Ice.Value>)result.AsyncState;
477                     List<Ice.Value> o;
478                     List<Ice.Value> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLObjectS(out o, result);
479                     IEnumerator<Ice.Value> eo = o.GetEnumerator();
480                     IEnumerator<Ice.Value> er = r.GetEnumerator();
481                     foreach(Test.CV obj in i)
482                     {
483                         eo.MoveNext();
484                         er.MoveNext();
485                         test(obj.i ==((Test.CV)eo.Current).i);
486                         test(obj.i ==((Test.CV)er.Current).i);
487                     }
488                     callback.called();
489                 }
490 
opAObjectPrxSI(Ice.AsyncResult result)491                 public void opAObjectPrxSI(Ice.AsyncResult result)
492                 {
493                     Ice.ObjectPrx[] i =(Ice.ObjectPrx[])result.AsyncState;
494                     Ice.ObjectPrx[] o;
495                     Ice.ObjectPrx[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAObjectPrxS(out o, result);
496                     test(Ice.CollectionComparer.Equals(i, o));
497                     test(Ice.CollectionComparer.Equals(i, r));
498                     callback.called();
499                 }
500 
opLObjectPrxSI(Ice.AsyncResult result)501                 public void opLObjectPrxSI(Ice.AsyncResult result)
502                 {
503                     List<Ice.ObjectPrx> i =(List<Ice.ObjectPrx>)result.AsyncState;
504                     List<Ice.ObjectPrx> o;
505                     List<Ice.ObjectPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLObjectPrxS(out o, result);
506                     test(Ice.CollectionComparer.Equals(i, o));
507                     test(Ice.CollectionComparer.Equals(i, r));
508                     callback.called();
509                 }
510 
opKObjectPrxSI(Ice.AsyncResult result)511                 public void opKObjectPrxSI(Ice.AsyncResult result)
512                 {
513                     LinkedList<Ice.ObjectPrx> i =(LinkedList<Ice.ObjectPrx>)result.AsyncState;
514                     LinkedList<Ice.ObjectPrx> o;
515                     LinkedList<Ice.ObjectPrx> r =
516                         Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKObjectPrxS(out o, result);
517                     test(Ice.CollectionComparer.Equals(i, o));
518                     test(Ice.CollectionComparer.Equals(i, r));
519                     callback.called();
520                 }
521 
opQObjectPrxSI(Ice.AsyncResult result)522                 public void opQObjectPrxSI(Ice.AsyncResult result)
523                 {
524                     Queue<Ice.ObjectPrx> i =(Queue<Ice.ObjectPrx>)result.AsyncState;
525                     Queue<Ice.ObjectPrx> o;
526                     Queue<Ice.ObjectPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQObjectPrxS(out o, result);
527                     test(Ice.CollectionComparer.Equals(i, o));
528                     test(Ice.CollectionComparer.Equals(i, r));
529                     callback.called();
530                 }
531 
opSObjectPrxSI(Ice.AsyncResult result)532                 public void opSObjectPrxSI(Ice.AsyncResult result)
533                 {
534                     Stack<Ice.ObjectPrx> i =(Stack<Ice.ObjectPrx>)result.AsyncState;
535                     Stack<Ice.ObjectPrx> o;
536                     Stack<Ice.ObjectPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSObjectPrxS(out o, result);
537                     test(Ice.CollectionComparer.Equals(i, o));
538                     test(Ice.CollectionComparer.Equals(i, r));
539                     callback.called();
540                 }
541 
opAStructSI(Ice.AsyncResult result)542                 public void opAStructSI(Ice.AsyncResult result)
543                 {
544                     Test.S[] i =(Test.S[])result.AsyncState;
545                     Test.S[] o;
546                     Test.S[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAStructS(out o, result);
547                     test(Ice.CollectionComparer.Equals(i, o));
548                     test(Ice.CollectionComparer.Equals(i, r));
549                     callback.called();
550                 }
551 
opLStructSI(Ice.AsyncResult result)552                 public void opLStructSI(Ice.AsyncResult result)
553                 {
554                     List<Test.S> i =(List<Test.S>)result.AsyncState;
555                     List<Test.S> o;
556                     List<Test.S> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLStructS(out o, result);
557                     test(Ice.CollectionComparer.Equals(i, o));
558                     test(Ice.CollectionComparer.Equals(i, r));
559                     callback.called();
560                 }
561 
opKStructSI(Ice.AsyncResult result)562                 public void opKStructSI(Ice.AsyncResult result)
563                 {
564                     LinkedList<Test.S> i =(LinkedList<Test.S>)result.AsyncState;
565                     LinkedList<Test.S> o;
566                     LinkedList<Test.S> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKStructS(out o, result);
567                     test(Ice.CollectionComparer.Equals(i, o));
568                     test(Ice.CollectionComparer.Equals(i, r));
569                     callback.called();
570                 }
571 
opQStructSI(Ice.AsyncResult result)572                 public void opQStructSI(Ice.AsyncResult result)
573                 {
574                     Queue<Test.S> i =(Queue<Test.S>)result.AsyncState;
575                     Queue<Test.S> o;
576                     Queue<Test.S> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQStructS(out o, result);
577                     test(Ice.CollectionComparer.Equals(i, o));
578                     test(Ice.CollectionComparer.Equals(i, r));
579                     callback.called();
580                 }
581 
opSStructSI(Ice.AsyncResult result)582                 public void opSStructSI(Ice.AsyncResult result)
583                 {
584                     Stack<Test.S> i =(Stack<Test.S>)result.AsyncState;
585                     Stack<Test.S> o;
586                     Stack<Test.S> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSStructS(out o, result);
587                     test(Ice.CollectionComparer.Equals(i, o));
588                     test(Ice.CollectionComparer.Equals(i, r));
589                     callback.called();
590                 }
591 
opAStructSDI(Ice.AsyncResult result)592                 public void opAStructSDI(Ice.AsyncResult result)
593                 {
594                     Test.SD[] i =(Test.SD[])result.AsyncState;
595                     Test.SD[] o;
596                     Test.SD[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAStructSD(out o, result);
597                     test(Ice.CollectionComparer.Equals(i, o));
598                     test(Ice.CollectionComparer.Equals(i, r));
599                     callback.called();
600                 }
601 
opLStructSDI(Ice.AsyncResult result)602                 public void opLStructSDI(Ice.AsyncResult result)
603                 {
604                     List<Test.SD> i =(List<Test.SD>)result.AsyncState;
605                     List<Test.SD> o;
606                     List<Test.SD> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLStructSD(out o, result);
607                     test(Ice.CollectionComparer.Equals(i, o));
608                     test(Ice.CollectionComparer.Equals(i, r));
609                     callback.called();
610                 }
611 
opKStructSDI(Ice.AsyncResult result)612                 public void opKStructSDI(Ice.AsyncResult result)
613                 {
614                     LinkedList<Test.SD> i =(LinkedList<Test.SD>)result.AsyncState;
615                     LinkedList<Test.SD> o;
616                     LinkedList<Test.SD> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKStructSD(out o, result);
617                     test(Ice.CollectionComparer.Equals(i, o));
618                     test(Ice.CollectionComparer.Equals(i, r));
619                     callback.called();
620                 }
621 
opQStructSDI(Ice.AsyncResult result)622                 public void opQStructSDI(Ice.AsyncResult result)
623                 {
624                     Queue<Test.SD> i =(Queue<Test.SD>)result.AsyncState;
625                     Queue<Test.SD> o;
626                     Queue<Test.SD> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQStructSD(out o, result);
627                     test(Ice.CollectionComparer.Equals(i, o));
628                     test(Ice.CollectionComparer.Equals(i, r));
629                     callback.called();
630                 }
631 
opSStructSDI(Ice.AsyncResult result)632                 public void opSStructSDI(Ice.AsyncResult result)
633                 {
634                     Stack<Test.SD> i =(Stack<Test.SD>)result.AsyncState;
635                     Stack<Test.SD> o;
636                     Stack<Test.SD> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSStructSD(out o, result);
637                     test(Ice.CollectionComparer.Equals(i, o));
638                     test(Ice.CollectionComparer.Equals(i, r));
639                     callback.called();
640                 }
641 
opACVSI(Ice.AsyncResult result)642                 public void opACVSI(Ice.AsyncResult result)
643                 {
644                     Test.CV[] i =(Test.CV[])result.AsyncState;
645                     Test.CV[] o;
646                     Test.CV[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opACVS(out o, result);
647                     System.Collections.IEnumerator eo = o.GetEnumerator();
648                     System.Collections.IEnumerator er = r.GetEnumerator();
649                     foreach(Test.CV obj in i)
650                     {
651                         eo.MoveNext();
652                         er.MoveNext();
653                         test(obj.i ==((Test.CV)eo.Current).i);
654                         test(obj.i ==((Test.CV)er.Current).i);
655                     }
656                     callback.called();
657                 }
658 
opLCVSI(Ice.AsyncResult result)659                 public void opLCVSI(Ice.AsyncResult result)
660                 {
661                     List<Test.CV> i =(List<Test.CV>)result.AsyncState;
662                     List<Test.CV> o;
663                     List<Test.CV> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLCVS(out o, result);
664                     IEnumerator<Test.CV> eo = o.GetEnumerator();
665                     IEnumerator<Test.CV> er = r.GetEnumerator();
666                     foreach(Test.CV obj in i)
667                     {
668                         eo.MoveNext();
669                         er.MoveNext();
670                         test(obj.i == eo.Current.i);
671                         test(obj.i == er.Current.i);
672                     }
673                     callback.called();
674                 }
675 
opIPrxSI(Ice.AsyncResult result)676                 public void opIPrxSI(Ice.AsyncResult result)
677                 {
678                     Test.IPrx[] i =(Test.IPrx[])result.AsyncState;
679                     Test.IPrx[] o;
680                     Test.IPrx[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAIPrxS(out o, result);
681                     test(Ice.CollectionComparer.Equals(i, o));
682                     test(Ice.CollectionComparer.Equals(i, r));
683                     callback.called();
684                 }
685 
opLIPrxSI(Ice.AsyncResult result)686                 public void opLIPrxSI(Ice.AsyncResult result)
687                 {
688                     List<Test.IPrx> i =(List<Test.IPrx>)result.AsyncState;
689                     List<Test.IPrx> o;
690                     List<Test.IPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLIPrxS(out o, result);
691                     test(Ice.CollectionComparer.Equals(i, o));
692                     test(Ice.CollectionComparer.Equals(i, r));
693                     callback.called();
694                 }
695 
opKIPrxSI(Ice.AsyncResult result)696                 public void opKIPrxSI(Ice.AsyncResult result)
697                 {
698                     LinkedList<Test.IPrx> i =(LinkedList<Test.IPrx>)result.AsyncState;
699                     LinkedList<Test.IPrx> o;
700                     LinkedList<Test.IPrx> r =
701                         Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKIPrxS(out o, result);
702                     test(Ice.CollectionComparer.Equals(i, o));
703                     test(Ice.CollectionComparer.Equals(i, r));
704                     callback.called();
705                 }
706 
opQIPrxSI(Ice.AsyncResult result)707                 public void opQIPrxSI(Ice.AsyncResult result)
708                 {
709                     Queue<Test.IPrx> i =(Queue<Test.IPrx>)result.AsyncState;
710                     Queue<Test.IPrx> o;
711                     Queue<Test.IPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQIPrxS(out o, result);
712                     test(Ice.CollectionComparer.Equals(i, o));
713                     test(Ice.CollectionComparer.Equals(i, r));
714                     callback.called();
715                 }
716 
opSIPrxSI(Ice.AsyncResult result)717                 public void opSIPrxSI(Ice.AsyncResult result)
718                 {
719                     Stack<Test.IPrx> i =(Stack<Test.IPrx>)result.AsyncState;
720                     Stack<Test.IPrx> o;
721                     Stack<Test.IPrx> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSIPrxS(out o, result);
722                     test(Ice.CollectionComparer.Equals(i, o));
723                     test(Ice.CollectionComparer.Equals(i, r));
724                     callback.called();
725                 }
726 
opACRSI(Ice.AsyncResult result)727                 public void opACRSI(Ice.AsyncResult result)
728                 {
729                     Test.CR[] i =(Test.CR[])result.AsyncState;
730                     Test.CR[] o;
731                     Test.CR[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opACRS(out o, result);
732                     System.Collections.IEnumerator eo = o.GetEnumerator();
733                     System.Collections.IEnumerator er = r.GetEnumerator();
734                     foreach(Test.CR obj in i)
735                     {
736                         eo.MoveNext();
737                         er.MoveNext();
738                         test(obj.v.i ==((Test.CR)eo.Current).v.i);
739                         test(obj.v.i ==((Test.CR)er.Current).v.i);
740                     }
741                     callback.called();
742                 }
743 
opLCRSI(Ice.AsyncResult result)744                 public void opLCRSI(Ice.AsyncResult result)
745                 {
746                     List<Test.CR> i =(List<Test.CR>)result.AsyncState;
747                     List<Test.CR> o;
748                     List<Test.CR> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLCRS(out o, result);
749                     IEnumerator<Test.CR> eo = o.GetEnumerator();
750                     IEnumerator<Test.CR> er = r.GetEnumerator();
751                     foreach(Test.CR obj in i)
752                     {
753                         eo.MoveNext();
754                         er.MoveNext();
755                         test(obj.v.i == eo.Current.v.i);
756                         test(obj.v.i == er.Current.v.i);
757                     }
758                     callback.called();
759                 }
760 
opAEnSI(Ice.AsyncResult result)761                 public void opAEnSI(Ice.AsyncResult result)
762                 {
763                     Test.En[] i =(Test.En[])result.AsyncState;
764                     Test.En[] o;
765                     Test.En[] r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAEnS(out o, result);
766                     test(Ice.CollectionComparer.Equals(i, o));
767                     test(Ice.CollectionComparer.Equals(i, r));
768                     callback.called();
769                 }
770 
opLEnSI(Ice.AsyncResult result)771                 public void opLEnSI(Ice.AsyncResult result)
772                 {
773                     List<Test.En> i =(List<Test.En>)result.AsyncState;
774                     List<Test.En> o;
775                     List<Test.En> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLEnS(out o, result);
776                     test(Ice.CollectionComparer.Equals(i, o));
777                     test(Ice.CollectionComparer.Equals(i, r));
778                     callback.called();
779                 }
780 
opKEnSI(Ice.AsyncResult result)781                 public void opKEnSI(Ice.AsyncResult result)
782                 {
783                     LinkedList<Test.En> i =(LinkedList<Test.En>)result.AsyncState;
784                     LinkedList<Test.En> o;
785                     LinkedList<Test.En> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKEnS(out o, result);
786                     test(Ice.CollectionComparer.Equals(i, o));
787                     test(Ice.CollectionComparer.Equals(i, r));
788                     callback.called();
789                 }
790 
opQEnSI(Ice.AsyncResult result)791                 public void opQEnSI(Ice.AsyncResult result)
792                 {
793                     Queue<Test.En> i =(Queue<Test.En>)result.AsyncState;
794                     Queue<Test.En> o;
795                     Queue<Test.En> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQEnS(out o, result);
796                     test(Ice.CollectionComparer.Equals(i, o));
797                     test(Ice.CollectionComparer.Equals(i, r));
798                     callback.called();
799                 }
800 
opSEnSI(Ice.AsyncResult result)801                 public void opSEnSI(Ice.AsyncResult result)
802                 {
803                     Stack<Test.En> i =(Stack<Test.En>)result.AsyncState;
804                     Stack<Test.En> o;
805                     Stack<Test.En> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSEnS(out o, result);
806                     test(Ice.CollectionComparer.Equals(i, o));
807                     test(Ice.CollectionComparer.Equals(i, r));
808                     callback.called();
809                 }
810 
opCustomIntSI(Ice.AsyncResult result)811                 public void opCustomIntSI(Ice.AsyncResult result)
812                 {
813                     Custom<int> i =(Custom<int>)result.AsyncState;
814                     Custom<int> o;
815                     Custom<int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opCustomIntS(out o, result);
816                     test(Ice.CollectionComparer.Equals(i, o));
817                     test(Ice.CollectionComparer.Equals(i, r));
818                     callback.called();
819                 }
820 
opCustomCVSI(Ice.AsyncResult result)821                 public void opCustomCVSI(Ice.AsyncResult result)
822                 {
823                     Custom<Test.CV> i =(Custom<Test.CV>)result.AsyncState;
824                     Custom<Test.CV> o;
825                     Custom<Test.CV> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opCustomCVS(out o, result);
826                     IEnumerator<Test.CV> eo = o.GetEnumerator();
827                     IEnumerator<Test.CV> er = r.GetEnumerator();
828                     foreach(Test.CV obj in i)
829                     {
830                         eo.MoveNext();
831                         er.MoveNext();
832                         if(obj == null)
833                         {
834                             test(eo.Current == null);
835                             test(er.Current == null);
836                         }
837                         else
838                         {
839                             test(obj.i == eo.Current.i);
840                             test(obj.i == er.Current.i);
841                         }
842                     }
843                     callback.called();
844                 }
845 
opCustomIntSSI(Ice.AsyncResult result)846                 public void opCustomIntSSI(Ice.AsyncResult result)
847                 {
848                     Custom<Custom<int>> i =(Custom<Custom<int>>)result.AsyncState;
849                     Custom<Custom<int>> o;
850                     Custom<Custom<int>> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opCustomIntSS(out o, result);
851                     test(Ice.CollectionComparer.Equals(i, o));
852                     test(Ice.CollectionComparer.Equals(i, r));
853                     callback.called();
854                 }
855 
opCustomCVSSI(Ice.AsyncResult result)856                 public void opCustomCVSSI(Ice.AsyncResult result)
857                 {
858                     Custom<Custom<Test.CV>> i =(Custom<Custom<Test.CV>>)result.AsyncState;
859                     Custom<Custom<Test.CV>> o;
860                     Custom<Custom<Test.CV>> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opCustomCVSS(out o, result);
861                     IEnumerator<Custom<Test.CV>> eo = o.GetEnumerator();
862                     IEnumerator<Custom<Test.CV>> er = r.GetEnumerator();
863                     foreach(Custom<Test.CV> s in i)
864                     {
865                         eo.MoveNext();
866                         er.MoveNext();
867                         IEnumerator<Test.CV> io = eo.Current.GetEnumerator();
868                         IEnumerator<Test.CV> ir = er.Current.GetEnumerator();
869                         foreach(Test.CV obj in s)
870                         {
871                             io.MoveNext();
872                             ir.MoveNext();
873                             if(obj == null)
874                             {
875                                 test(io.Current == null);
876                                 test(ir.Current == null);
877                             }
878                             else
879                             {
880                                 test(obj.i == io.Current.i);
881                                 test(obj.i == ir.Current.i);
882                             }
883                         }
884                     }
885                     callback.called();
886                 }
887 
opSerialSmallCSharpNullI(Ice.AsyncResult result)888                 public void opSerialSmallCSharpNullI(Ice.AsyncResult result)
889                 {
890                     try
891                     {
892                         Serialize.Small o;
893                         Serialize.Small r =
894                             Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSerialSmallCSharp(out o, result);
895                         test(o == null);
896                         test(r == null);
897                         callback.called();
898                     }
899                     catch(Ice.OperationNotExistException)
900                     {
901                         // OK, talking to non-C# server.
902                     }
903                 }
904 
opSerialSmallCSharpI(Ice.AsyncResult result)905                 public void opSerialSmallCSharpI(Ice.AsyncResult result)
906                 {
907                     try
908                     {
909                         Serialize.Small o;
910                         Serialize.Small r =
911                             Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSerialSmallCSharp(out o, result);
912                         test(o.i == 99);
913                         test(r.i == 99);
914                         callback.called();
915                     }
916                     catch(Ice.OperationNotExistException)
917                     {
918                         // OK, talking to non-C# server.
919                     }
920                 }
921 
opSerialLargeCSharpI(Ice.AsyncResult result)922                 public void opSerialLargeCSharpI(Ice.AsyncResult result)
923                 {
924                     try
925                     {
926                         Serialize.Large o;
927                         Serialize.Large r =
928                             Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSerialLargeCSharp(out o, result);
929                         test(o.d1 == 1.0);
930                         test(o.d2 == 2.0);
931                         test(o.d3 == 3.0);
932                         test(o.d4 == 4.0);
933                         test(o.d5 == 5.0);
934                         test(o.d6 == 6.0);
935                         test(o.d7 == 7.0);
936                         test(o.d8 == 8.0);
937                         test(o.d9 == 9.0);
938                         test(o.d10 == 10.0);
939                         test(r.d1 == 1.0);
940                         test(r.d2 == 2.0);
941                         test(r.d3 == 3.0);
942                         test(r.d4 == 4.0);
943                         test(r.d5 == 5.0);
944                         test(r.d6 == 6.0);
945                         test(r.d7 == 7.0);
946                         test(r.d8 == 8.0);
947                         test(r.d9 == 9.0);
948                         test(r.d10 == 10.0);
949                         callback.called();
950                     }
951                     catch(Ice.OperationNotExistException)
952                     {
953                         // OK, talking to non-C# server.
954                     }
955                 }
956 
opSerialStructCSharpI(Ice.AsyncResult result)957                 public void opSerialStructCSharpI(Ice.AsyncResult result)
958                 {
959                     try
960                     {
961                         Serialize.Struct o;
962                         Serialize.Struct r =
963                             Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSerialStructCSharp(out o, result);
964                         test(o.o == null);
965                         test(o.o2 != null);
966                         test(((Serialize.Struct)(o.o2)).o == null);
967                         test(((Serialize.Struct)(o.o2)).o2 == o.o2);
968                         test(o.s == null);
969                         test(o.s2.Equals("Hello"));
970                         test(r.o == null);
971                         test(r.o2 != null);
972                         test(((Serialize.Struct)(r.o2)).o == null);
973                         test(((Serialize.Struct)(r.o2)).o2 == r.o2);
974                         test(r.s == null);
975                         test(r.s2.Equals("Hello"));
976                         callback.called();
977                     }
978                     catch(Ice.OperationNotExistException)
979                     {
980                         // OK, talking to non-C# server.
981                     }
982                 }
983 
check()984                 public virtual void check()
985                 {
986                     callback.check();
987                 }
988 
989                 private CallbackBase callback = new CallbackBase();
990             }
991 
992             static int _length = 100;
993 
twowaysAMI(Ice.Communicator communicator, Test.MyClassPrx p)994             internal static void twowaysAMI(Ice.Communicator communicator, Test.MyClassPrx p)
995             {
996                 {
997                     byte[] i = new byte[_length];
998                     for(int c = 0; c < _length; ++c)
999                     {
1000                         i[c] =(byte)c;
1001                     }
1002 
1003                     Callback cb = new Callback();
1004                     p.begin_opAByteS(i, null, cb.opAByteSI, i);
1005                     cb.check();
1006                 }
1007 
1008                 {
1009                     List<byte> i = new List<byte>();
1010                     for(int c = 0; c < _length; ++c)
1011                     {
1012                         i.Add((byte)c);
1013                     }
1014 
1015                     Callback cb = new Callback();
1016                     p.begin_opLByteS(i, null, cb.opLByteSI, i);
1017                     cb.check();
1018                 }
1019 
1020                 {
1021                     LinkedList<byte> i = new LinkedList<byte>();
1022                     for(int c = 0; c < _length; ++c)
1023                     {
1024                         i.AddLast((byte)c);
1025                     }
1026 
1027                     Callback cb = new Callback();
1028                     p.begin_opKByteS(i, null, cb.opKByteSI, i);
1029                     cb.check();
1030                 }
1031 
1032                 {
1033                     Queue<byte> i = new Queue<byte>();
1034                     for(int c = 0; c < _length; ++c)
1035                     {
1036                         i.Enqueue((byte)c);
1037                     }
1038 
1039                     Callback cb = new Callback();
1040                     p.begin_opQByteS(i, null, cb.opQByteSI, i);
1041                     cb.check();
1042                 }
1043 
1044                 {
1045                     Stack<byte> i = new Stack<byte>();
1046                     for(int c = 0; c < _length; ++c)
1047                     {
1048                         i.Push((byte)c);
1049                     }
1050 
1051                     Callback cb = new Callback();
1052                     p.begin_opSByteS(i, null, cb.opSByteSI, i);
1053                     cb.check();
1054                 }
1055 
1056                 {
1057                     bool[] i = new bool[_length];
1058                     for(int c = 0; c < _length; ++c)
1059                     {
1060                         i[c] = c % 1 == 1;
1061                     }
1062 
1063                     Callback cb = new Callback();
1064                     p.begin_opABoolS(i, null, cb.opABoolSI, i);
1065                     cb.check();
1066                 }
1067 
1068                 {
1069                     List<bool> i = new List<bool>();
1070                     for(int c = 0; c < _length; ++c)
1071                     {
1072                         i.Add(c % 1 == 1);
1073                     }
1074 
1075                     Callback cb = new Callback();
1076                     p.begin_opLBoolS(i, null, cb.opLBoolSI, i);
1077                     cb.check();
1078                 }
1079 
1080                 {
1081                     LinkedList<bool> i = new LinkedList<bool>();
1082                     for(int c = 0; c < _length; ++c)
1083                     {
1084                         i.AddLast(c % 1 == 1);
1085                     }
1086 
1087                     Callback cb = new Callback();
1088                     p.begin_opKBoolS(i, null, cb.opKBoolSI, i);
1089                     cb.check();
1090                 }
1091 
1092                 {
1093                     Queue<bool> i = new Queue<bool>();
1094                     for(int c = 0; c < _length; ++c)
1095                     {
1096                         i.Enqueue(c % 1 == 1);
1097                     }
1098 
1099                     Callback cb = new Callback();
1100                     p.begin_opQBoolS(i, null, cb.opQBoolSI, i);
1101                     cb.check();
1102                 }
1103 
1104                 {
1105                     Stack<bool> i = new Stack<bool>();
1106                     for(int c = 0; c < _length; ++c)
1107                     {
1108                         i.Push(c % 1 == 1);
1109                     }
1110 
1111                     Callback cb = new Callback();
1112                     p.begin_opSBoolS(i, null, cb.opSBoolSI, i);
1113                     cb.check();
1114                 }
1115 
1116                 {
1117                     short[] i = new short[_length];
1118                     for(int c = 0; c < _length; ++c)
1119                     {
1120                         i[c] =(short)c;
1121                     }
1122 
1123                     Callback cb = new Callback();
1124                     p.begin_opAShortS(i, null, cb.opAShortSI, i);
1125                     cb.check();
1126                 }
1127 
1128                 {
1129                     List<short> i = new List<short>();
1130                     for(int c = 0; c < _length; ++c)
1131                     {
1132                         i.Add((short)c);
1133                     }
1134 
1135                     Callback cb = new Callback();
1136                     p.begin_opLShortS(i, null, cb.opLShortSI, i);
1137                     cb.check();
1138                 }
1139 
1140                 {
1141                     LinkedList<short> i = new LinkedList<short>();
1142                     for(int c = 0; c < _length; ++c)
1143                     {
1144                         i.AddLast((short)c);
1145                     }
1146 
1147                     Callback cb = new Callback();
1148                     p.begin_opKShortS(i, null, cb.opKShortSI, i);
1149                     cb.check();
1150                 }
1151 
1152                 {
1153                     Queue<short> i = new Queue<short>();
1154                     for(int c = 0; c < _length; ++c)
1155                     {
1156                         i.Enqueue((short)c);
1157                     }
1158 
1159                     Callback cb = new Callback();
1160                     p.begin_opQShortS(i, null, cb.opQShortSI, i);
1161                     cb.check();
1162                 }
1163 
1164                 {
1165                     Stack<short> i = new Stack<short>();
1166                     for(int c = 0; c < _length; ++c)
1167                     {
1168                         i.Push((short)c);
1169                     }
1170 
1171                     Callback cb = new Callback();
1172                     p.begin_opSShortS(i, null, cb.opSShortSI, i);
1173                     cb.check();
1174                 }
1175 
1176                 {
1177                     int[] i = new int[_length];
1178                     for(int c = 0; c < _length; ++c)
1179                     {
1180                         i[c] =(int)c;
1181                     }
1182 
1183                     Callback cb = new Callback();
1184                     p.begin_opAIntS(i, null, cb.opAIntSI, i);
1185                     cb.check();
1186                 }
1187 
1188                 {
1189                     List<int> i = new List<int>();
1190                     for(int c = 0; c < _length; ++c)
1191                     {
1192                         i.Add((int)c);
1193                     }
1194 
1195                     Callback cb = new Callback();
1196                     p.begin_opLIntS(i, null, cb.opLIntSI, i);
1197                     cb.check();
1198                 }
1199 
1200                 {
1201                     LinkedList<int> i = new LinkedList<int>();
1202                     for(int c = 0; c < _length; ++c)
1203                     {
1204                         i.AddLast((int)c);
1205                     }
1206 
1207                     Callback cb = new Callback();
1208                     p.begin_opKIntS(i, null, cb.opKIntSI, i);
1209                     cb.check();
1210                 }
1211 
1212                 {
1213                     Queue<int> i = new Queue<int>();
1214                     for(int c = 0; c < _length; ++c)
1215                     {
1216                         i.Enqueue((int)c);
1217                     }
1218 
1219                     Callback cb = new Callback();
1220                     p.begin_opQIntS(i, null, cb.opQIntSI, i);
1221                     cb.check();
1222                 }
1223 
1224                 {
1225                     Stack<int> i = new Stack<int>();
1226                     for(int c = 0; c < _length; ++c)
1227                     {
1228                         i.Push((int)c);
1229                     }
1230 
1231                     Callback cb = new Callback();
1232                     p.begin_opSIntS(i, null, cb.opSIntSI, i);
1233                     cb.check();
1234                 }
1235 
1236                 {
1237                     long[] i = new long[_length];
1238                     for(int c = 0; c < _length; ++c)
1239                     {
1240                         i[c] =(long)c;
1241                     }
1242 
1243                     Callback cb = new Callback();
1244                     p.begin_opALongS(i, null, cb.opALongSI, i);
1245                     cb.check();
1246                 }
1247 
1248                 {
1249                     List<long> i = new List<long>();
1250                     for(int c = 0; c < _length; ++c)
1251                     {
1252                         i.Add((long)c);
1253                     }
1254 
1255                     Callback cb = new Callback();
1256                     p.begin_opLLongS(i, null, cb.opLLongSI, i);
1257                     cb.check();
1258                 }
1259 
1260                 {
1261                     LinkedList<long> i = new LinkedList<long>();
1262                     for(int c = 0; c < _length; ++c)
1263                     {
1264                         i.AddLast((long)c);
1265                     }
1266 
1267                     Callback cb = new Callback();
1268                     p.begin_opKLongS(i, null, cb.opKLongSI, i);
1269                     cb.check();
1270                 }
1271 
1272                 {
1273                     Queue<long> i = new Queue<long>();
1274                     for(int c = 0; c < _length; ++c)
1275                     {
1276                         i.Enqueue((long)c);
1277                     }
1278 
1279                     Callback cb = new Callback();
1280                     p.begin_opQLongS(i, null, cb.opQLongSI, i);
1281                     cb.check();
1282                 }
1283 
1284                 {
1285                     Stack<long> i = new Stack<long>();
1286                     for(int c = 0; c < _length; ++c)
1287                     {
1288                         i.Push((long)c);
1289                     }
1290 
1291                     Callback cb = new Callback();
1292                     p.begin_opSLongS(i, null, cb.opSLongSI, i);
1293                     cb.check();
1294                 }
1295 
1296                 {
1297                     float[] i = new float[_length];
1298                     for(int c = 0; c < _length; ++c)
1299                     {
1300                         i[c] =(float)c;
1301                     }
1302 
1303                     Callback cb = new Callback();
1304                     p.begin_opAFloatS(i, null, cb.opAFloatSI, i);
1305                     cb.check();
1306                 }
1307 
1308                 {
1309                     List<float> i = new List<float>();
1310                     for(int c = 0; c < _length; ++c)
1311                     {
1312                         i.Add((float)c);
1313                     }
1314 
1315                     Callback cb = new Callback();
1316                     p.begin_opLFloatS(i, null, cb.opLFloatSI, i);
1317                     cb.check();
1318                 }
1319 
1320                 {
1321                     LinkedList<float> i = new LinkedList<float>();
1322                     for(int c = 0; c < _length; ++c)
1323                     {
1324                         i.AddLast((float)c);
1325                     }
1326 
1327                     Callback cb = new Callback();
1328                     p.begin_opKFloatS(i, null, cb.opKFloatSI, i);
1329                     cb.check();
1330                 }
1331 
1332                 {
1333                     Queue<float> i = new Queue<float>();
1334                     for(int c = 0; c < _length; ++c)
1335                     {
1336                         i.Enqueue((float)c);
1337                     }
1338 
1339                     Callback cb = new Callback();
1340                     p.begin_opQFloatS(i, null, cb.opQFloatSI, i);
1341                     cb.check();
1342                 }
1343 
1344                 {
1345                     Stack<float> i = new Stack<float>();
1346                     for(int c = 0; c < _length; ++c)
1347                     {
1348                         i.Push((float)c);
1349                     }
1350 
1351                     Callback cb = new Callback();
1352                     p.begin_opSFloatS(i, null, cb.opSFloatSI, i);
1353                     cb.check();
1354                 }
1355 
1356                 {
1357                     double[] i = new double[_length];
1358                     for(int c = 0; c < _length; ++c)
1359                     {
1360                         i[c] =(double)c;
1361                     }
1362 
1363                     Callback cb = new Callback();
1364                     p.begin_opADoubleS(i, null, cb.opADoubleSI, i);
1365                     cb.check();
1366                 }
1367 
1368                 {
1369                     List<double> i = new List<double>();
1370                     for(int c = 0; c < _length; ++c)
1371                     {
1372                         i.Add((double)c);
1373                     }
1374 
1375                     Callback cb = new Callback();
1376                     p.begin_opLDoubleS(i, null, cb.opLDoubleSI, i);
1377                     cb.check();
1378                 }
1379 
1380                 {
1381                     LinkedList<double> i = new LinkedList<double>();
1382                     for(int c = 0; c < _length; ++c)
1383                     {
1384                         i.AddLast((double)c);
1385                     }
1386 
1387                     Callback cb = new Callback();
1388                     p.begin_opKDoubleS(i, null, cb.opKDoubleSI, i);
1389                     cb.check();
1390                 }
1391 
1392                 {
1393                     Queue<double> i = new Queue<double>();
1394                     for(int c = 0; c < _length; ++c)
1395                     {
1396                         i.Enqueue((double)c);
1397                     }
1398 
1399                     Callback cb = new Callback();
1400                     p.begin_opQDoubleS(i, null, cb.opQDoubleSI, i);
1401                     cb.check();
1402                 }
1403 
1404                 {
1405                     Stack<double> i = new Stack<double>();
1406                     for(int c = 0; c < _length; ++c)
1407                     {
1408                         i.Push((double)c);
1409                     }
1410 
1411                     Callback cb = new Callback();
1412                     p.begin_opSDoubleS(i, null, cb.opSDoubleSI, i);
1413                     cb.check();
1414                 }
1415 
1416                 {
1417                     string[] i = new string[_length];
1418                     for(int c = 0; c < _length; ++c)
1419                     {
1420                         i[c] = c.ToString();
1421                     }
1422 
1423                     Callback cb = new Callback();
1424                     p.begin_opAStringS(i, null, cb.opAStringSI, i);
1425                     cb.check();
1426                 }
1427 
1428                 {
1429                     List<string> i = new List<string>();
1430                     for(int c = 0; c < _length; ++c)
1431                     {
1432                         i.Add(c.ToString());
1433                     }
1434 
1435                     Callback cb = new Callback();
1436                     p.begin_opLStringS(i, null, cb.opLStringSI, i);
1437                     cb.check();
1438                 }
1439 
1440                 {
1441                     LinkedList<string> i = new LinkedList<string>();
1442                     for(int c = 0; c < _length; ++c)
1443                     {
1444                         i.AddLast(c.ToString());
1445                     }
1446 
1447                     Callback cb = new Callback();
1448                     p.begin_opKStringS(i, null, cb.opKStringSI, i);
1449                     cb.check();
1450                 }
1451 
1452                 {
1453                     Queue<string> i = new Queue<string>();
1454                     for(int c = 0; c < _length; ++c)
1455                     {
1456                         i.Enqueue(c.ToString());
1457                     }
1458 
1459                     Callback cb = new Callback();
1460                     p.begin_opQStringS(i, null, cb.opQStringSI, i);
1461                     cb.check();
1462                 }
1463 
1464                 {
1465                     Stack<string> i = new Stack<string>();
1466                     for(int c = 0; c < _length; ++c)
1467                     {
1468                         i.Push(c.ToString());
1469                     }
1470 
1471                     Callback cb = new Callback();
1472                     p.begin_opSStringS(i, null, cb.opSStringSI, i);
1473                     cb.check();
1474                 }
1475 
1476                 {
1477                     Ice.Value[] i = new Ice.Value[_length];
1478                     for(int c = 0; c < _length; ++c)
1479                     {
1480                         i[c] = new Test.CV(c);
1481                     }
1482 
1483                     Callback cb = new Callback();
1484                     p.begin_opAObjectS(i, null, cb.opAObjectSI, i);
1485                     cb.check();
1486                 }
1487 
1488                 {
1489                     List<Ice.Value> i = new List<Ice.Value>();
1490                     for(int c = 0; c < _length; ++c)
1491                     {
1492                         i.Add(new Test.CV(c));
1493                     }
1494 
1495                     Callback cb = new Callback();
1496                     p.begin_opLObjectS(i, null, cb.opLObjectSI, i);
1497                     cb.check();
1498                 }
1499 
1500                 {
1501                     Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length];
1502                     for(int c = 0; c < _length; ++c)
1503                     {
1504                         i[c] = communicator.stringToProxy(c.ToString());
1505                     }
1506 
1507                     Callback cb = new Callback();
1508                     p.begin_opAObjectPrxS(i, null, cb.opAObjectPrxSI, i);
1509                     cb.check();
1510                 }
1511 
1512                 {
1513                     List<Ice.ObjectPrx> i = new List<Ice.ObjectPrx>();
1514                     for(int c = 0; c < _length; ++c)
1515                     {
1516                         i.Add(communicator.stringToProxy(c.ToString()));
1517                     }
1518 
1519                     Callback cb = new Callback();
1520                     p.begin_opLObjectPrxS(i, null, cb.opLObjectPrxSI, i);
1521                     cb.check();
1522                 }
1523 
1524                 {
1525                     LinkedList<Ice.ObjectPrx> i = new LinkedList<Ice.ObjectPrx>();
1526                     for(int c = 0; c < _length; ++c)
1527                     {
1528                         i.AddLast(communicator.stringToProxy(c.ToString()));
1529                     }
1530 
1531                     Callback cb = new Callback();
1532                     p.begin_opKObjectPrxS(i, null, cb.opKObjectPrxSI, i);
1533                     cb.check();
1534                 }
1535 
1536                 {
1537                     Queue<Ice.ObjectPrx> i = new Queue<Ice.ObjectPrx>();
1538                     for(int c = 0; c < _length; ++c)
1539                     {
1540                         i.Enqueue(communicator.stringToProxy(c.ToString()));
1541                     }
1542 
1543                     Callback cb = new Callback();
1544                     p.begin_opQObjectPrxS(i, null, cb.opQObjectPrxSI, i);
1545                     cb.check();
1546                 }
1547 
1548                 {
1549                     Stack<Ice.ObjectPrx> i = new Stack<Ice.ObjectPrx>();
1550                     for(int c = 0; c < _length; ++c)
1551                     {
1552                         i.Push(communicator.stringToProxy(c.ToString()));
1553                     }
1554 
1555                     Callback cb = new Callback();
1556                     p.begin_opSObjectPrxS(i, null, cb.opSObjectPrxSI, i);
1557                     cb.check();
1558                 }
1559 
1560                 {
1561                     var i = new Test.S[_length];
1562                     for(int c = 0; c < _length; ++c)
1563                     {
1564                         i[c].i = c;
1565                     }
1566 
1567                     Callback cb = new Callback();
1568                     p.begin_opAStructS(i, null, cb.opAStructSI, i);
1569                     cb.check();
1570                 }
1571 
1572                 {
1573                     var i = new List<Test.S>();
1574                     for(int c = 0; c < _length; ++c)
1575                     {
1576                         i.Add(new Test.S(c));
1577                     }
1578 
1579                     Callback cb = new Callback();
1580                     p.begin_opLStructS(i, null, cb.opLStructSI, i);
1581                     cb.check();
1582                 }
1583 
1584                 {
1585                     var i = new LinkedList<Test.S>();
1586                     for(int c = 0; c < _length; ++c)
1587                     {
1588                         i.AddLast(new Test.S(c));
1589                     }
1590 
1591                     Callback cb = new Callback();
1592                     p.begin_opKStructS(i, null, cb.opKStructSI, i);
1593                     cb.check();
1594                 }
1595 
1596                 {
1597                     var i = new Queue<Test.S>();
1598                     for(int c = 0; c < _length; ++c)
1599                     {
1600                         i.Enqueue(new Test.S(c));
1601                     }
1602 
1603                     Callback cb = new Callback();
1604                     p.begin_opQStructS(i, null, cb.opQStructSI, i);
1605                     cb.check();
1606                 }
1607 
1608                 {
1609                     var i = new Stack<Test.S>();
1610                     for(int c = 0; c < _length; ++c)
1611                     {
1612                         i.Push(new Test.S(c));
1613                     }
1614 
1615                     Callback cb = new Callback();
1616                     p.begin_opSStructS(i, null, cb.opSStructSI, i);
1617                     cb.check();
1618                 }
1619 
1620                 {
1621                     var i = new Test.CV[_length];
1622                     for(int c = 0; c < _length; ++c)
1623                     {
1624                         i[c] = new Test.CV(c);
1625                     }
1626 
1627                     Callback cb = new Callback();
1628                     p.begin_opACVS(i, null, cb.opACVSI, i);
1629                     cb.check();
1630                 }
1631 
1632                 {
1633                     var i = new List<Test.CV>();
1634                     for(int c = 0; c < _length; ++c)
1635                     {
1636                         i.Add(new Test.CV(c));
1637                     }
1638 
1639                     Callback cb = new Callback();
1640                     p.begin_opLCVS(i, null, cb.opLCVSI, i);
1641                     cb.check();
1642                 }
1643 
1644                 {
1645                     Test.IPrx[] i = new Test.IPrx[_length];
1646                     for(int c = 0; c < _length; ++c)
1647                     {
1648                         i[c] = Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()));
1649                     }
1650 
1651                     Callback cb = new Callback();
1652                     p.begin_opAIPrxS(i, null, cb.opIPrxSI, i);
1653                     cb.check();
1654                 }
1655 
1656                 {
1657                     List<Test.IPrx> i = new List<Test.IPrx>();
1658                     for(int c = 0; c < _length; ++c)
1659                     {
1660                         i.Add(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
1661                     }
1662 
1663                     Callback cb = new Callback();
1664                     p.begin_opLIPrxS(i, null, cb.opLIPrxSI, i);
1665                     cb.check();
1666                 }
1667 
1668                 {
1669                     LinkedList<Test.IPrx> i = new LinkedList<Test.IPrx>();
1670                     for(int c = 0; c < _length; ++c)
1671                     {
1672                         i.AddLast(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
1673                     }
1674 
1675                     Callback cb = new Callback();
1676                     p.begin_opKIPrxS(i, null, cb.opKIPrxSI, i);
1677                     cb.check();
1678                 }
1679 
1680                 {
1681                     Queue<Test.IPrx> i = new Queue<Test.IPrx>();
1682                     for(int c = 0; c < _length; ++c)
1683                     {
1684                         i.Enqueue(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
1685                     }
1686 
1687                     Callback cb = new Callback();
1688                     p.begin_opQIPrxS(i, null, cb.opQIPrxSI, i);
1689                     cb.check();
1690                 }
1691 
1692                 {
1693                     Stack<Test.IPrx> i = new Stack<Test.IPrx>();
1694                     for(int c = 0; c < _length; ++c)
1695                     {
1696                         i.Push(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
1697                     }
1698 
1699                     Callback cb = new Callback();
1700                     p.begin_opSIPrxS(i, null, cb.opSIPrxSI, i);
1701                     cb.check();
1702                 }
1703 
1704                 {
1705                     var i = new Test.CR[_length];
1706                     for(int c = 0; c < _length; ++c)
1707                     {
1708                         i[c] = new Test.CR(new Test.CV(c));
1709                     }
1710 
1711                     Callback cb = new Callback();
1712                     p.begin_opACRS(i, null, cb.opACRSI, i);
1713                     cb.check();
1714                 }
1715 
1716                 {
1717                     var i = new List<Test.CR>();
1718                     for(int c = 0; c < _length; ++c)
1719                     {
1720                         i.Add(new Test.CR(new Test.CV(c)));
1721                     }
1722 
1723                     Callback cb = new Callback();
1724                     p.begin_opLCRS(i, null, cb.opLCRSI, i);
1725                     cb.check();
1726                 }
1727 
1728                 {
1729                     var i = new Test.En[_length];
1730                     for(int c = 0; c < _length; ++c)
1731                     {
1732                         i[c] =(Test.En)(c % 3);
1733                     }
1734 
1735                     Callback cb = new Callback();
1736                     p.begin_opAEnS(i, null, cb.opAEnSI, i);
1737                     cb.check();
1738                 }
1739 
1740                 {
1741                     var i = new List<Test.En>();
1742                     for(int c = 0; c < _length; ++c)
1743                     {
1744                         i.Add((Test.En)(c % 3));
1745                     }
1746 
1747                     Callback cb = new Callback();
1748                     p.begin_opLEnS(i, null, cb.opLEnSI, i);
1749                     cb.check();
1750                 }
1751 
1752                 {
1753                     var i = new LinkedList<Test.En>();
1754                     for(int c = 0; c < _length; ++c)
1755                     {
1756                         i.AddLast((Test.En)(c % 3));
1757                     }
1758 
1759                     Callback cb = new Callback();
1760                     p.begin_opKEnS(i, null, cb.opKEnSI, i);
1761                     cb.check();
1762                 }
1763 
1764                 {
1765                     var i = new Queue<Test.En>();
1766                     for(int c = 0; c < _length; ++c)
1767                     {
1768                         i.Enqueue((Test.En)(c % 3));
1769                     }
1770 
1771                     Callback cb = new Callback();
1772                     p.begin_opQEnS(i, null, cb.opQEnSI, i);
1773                     cb.check();
1774                 }
1775 
1776                 {
1777                     var i = new Stack<Test.En>();
1778                     for(int c = 0; c < _length; ++c)
1779                     {
1780                         i.Push((Test.En)(c % 3));
1781                     }
1782 
1783                     Callback cb = new Callback();
1784                     p.begin_opSEnS(i, null, cb.opSEnSI, i);
1785                     cb.check();
1786                 }
1787 
1788                 {
1789                     Custom<int> i = new Custom<int>();
1790                     for(int c = 0; c < _length; ++c)
1791                     {
1792                         i.Add(c);
1793                     }
1794 
1795                     Callback cb = new Callback();
1796                     p.begin_opCustomIntS(i, null, cb.opCustomIntSI, i);
1797                     cb.check();
1798                 }
1799 
1800                 {
1801                     var i = new Custom<Test.CV>();
1802                     for(int c = 0; c < _length; ++c)
1803                     {
1804                         i.Add(new Test.CV(c));
1805                     }
1806 
1807                     Callback cb = new Callback();
1808                     p.begin_opCustomCVS(i, null, cb.opCustomCVSI, i);
1809                     cb.check();
1810                 }
1811 
1812                 {
1813                     Custom<Custom<int>> i = new Custom<Custom<int>>();
1814                     for(int c = 0; c < _length; ++c)
1815                     {
1816                         Custom<int> inner = new Custom<int>();
1817                         for(int j = 0; j < c; ++j)
1818                         {
1819                             inner.Add(j);
1820                         }
1821                         i.Add(inner);
1822                     }
1823 
1824                     Callback cb = new Callback();
1825                     p.begin_opCustomIntSS(i, null, cb.opCustomIntSSI, i);
1826                     cb.check();
1827                 }
1828 
1829                 {
1830                     var i = new Custom<Custom<Test.CV>>();
1831                     for(int c = 0; c < _length; ++c)
1832                     {
1833                         var inner = new Custom<Test.CV>();
1834                         for(int j = 0; j < c; ++j)
1835                         {
1836                             inner.Add(new Test.CV(j));
1837                         }
1838                         i.Add(inner);
1839                     }
1840 
1841                     Callback cb = new Callback();
1842                     p.begin_opCustomCVSS(i, null, cb.opCustomCVSSI, i);
1843                     cb.check();
1844                 }
1845 
1846                 {
1847                     Serialize.Small i = null;
1848 
1849                     Callback cb = new Callback();
1850                     p.begin_opSerialSmallCSharp(i, null, cb.opSerialSmallCSharpNullI, i);
1851                     cb.check();
1852                 }
1853 
1854                 {
1855                     Serialize.Small i = new Serialize.Small();
1856                     i.i = 99;
1857 
1858                     Callback cb = new Callback();
1859                     p.begin_opSerialSmallCSharp(i, null, cb.opSerialSmallCSharpI, i);
1860                     cb.check();
1861                 }
1862 
1863                 {
1864                     Serialize.Large i = new Serialize.Large();
1865                     i.d1 = 1.0;
1866                     i.d2 = 2.0;
1867                     i.d3 = 3.0;
1868                     i.d4 = 4.0;
1869                     i.d5 = 5.0;
1870                     i.d6 = 6.0;
1871                     i.d7 = 7.0;
1872                     i.d8 = 8.0;
1873                     i.d9 = 9.0;
1874                     i.d10 = 10.0;
1875 
1876                     Callback cb = new Callback();
1877                     p.begin_opSerialLargeCSharp(i, null, cb.opSerialLargeCSharpI, i);
1878                     cb.check();
1879                 }
1880 
1881                 {
1882                     Serialize.Struct i = new Serialize.Struct();
1883                     i.o = null;
1884                     i.o2 = i;
1885                     i.s = null;
1886                     i.s2 = "Hello";
1887 
1888                     Callback cb = new Callback();
1889                     p.begin_opSerialStructCSharp(i, null, cb.opSerialStructCSharpI, i);
1890                     cb.check();
1891                 }
1892             }
1893         }
1894     }
1895 }
1896