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