java/test/Ice/slicing/exceptions/AllTests.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package test.Ice.slicing.exceptions;
  11
  12 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_baseAsBase;
  13 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownDerivedAsBase;
  14 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownDerivedAsKnownDerived;
  15 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownIntermediateAsBase;
  16 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownIntermediateAsKnownIntermediate;
  17 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownMostDerivedAsBase;
  18 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownMostDerivedAsKnownIntermediate;
  19 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_knownMostDerivedAsKnownMostDerived;
  20 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_unknownDerivedAsBase;
  21 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_unknownIntermediateAsBase;
  22 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_unknownMostDerived1AsBase;
  23 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_unknownMostDerived1AsKnownIntermediate;
  24 import test.Ice.slicing.exceptions.Test.Callback_TestIntf_unknownMostDerived2AsBase;
  25 import test.Ice.slicing.exceptions.Test.Base;
  26 import test.Ice.slicing.exceptions.Test.KnownDerived;
  27 import test.Ice.slicing.exceptions.Test.KnownIntermediate;
  28 import test.Ice.slicing.exceptions.Test.KnownMostDerived;
  29 import test.Ice.slicing.exceptions.Test.TestIntfPrx;
  30 import test.Ice.slicing.exceptions.Test.TestIntfPrxHelper;
  31
  32 public class AllTests
  33 {
  34     private static void
  35     test(boolean b)
  36     {
  37         if(!b)
  38         {
  39             throw new RuntimeException();
  40         }
  41     }
  42
  43     private static class Callback
  44     {
  45         Callback()
  46         {
  47             _called = false;
  48         }
  49
  50         public synchronized void
  51         check()
  52         {
  53             while(!_called)
  54             {
  55                 try
  56                 {
  57                     wait();
  58                 }
  59                 catch(InterruptedException ex)
  60                 {
  61                 }
  62             }
  63
  64             _called = false;
  65         }
  66
  67         public synchronized void
  68         called()
  69         {
  70             assert(!_called);
  71             _called = true;
  72             notify();
  73         }
  74
  75         private boolean _called;
  76     }
  77
  78     private static class Callback_TestIntf_baseAsBaseI extends Callback_TestIntf_baseAsBase
  79     {
  80         public void
  81         response()
  82         {
  83             test(false);
  84         }
  85
  86         public void
  87         exception(Ice.LocalException exc)
  88         {
  89             test(false);
  90         }
  91
  92         public void
  93         exception(Ice.UserException exc)
  94         {
  95             try
  96             {
  97                 throw exc;
  98             }
  99             catch(Base b)
 100             {
 101                 test(b.b.equals("Base.b"));
 102                 test(b.ice_name().equals("Test::Base"));
 103             }
 104             catch(Exception ex)
 105             {
 106                 test(false);
 107             }
 108             callback.called();
 109         }
 110
 111         public void
 112         check()
 113         {
 114             callback.check();
 115         }
 116
 117         private Callback callback = new Callback();
 118     }
 119
 120     private static class Callback_TestIntf_unknownDerivedAsBaseI extends Callback_TestIntf_unknownDerivedAsBase
 121     {
 122         public void
 123         response()
 124         {
 125             test(false);
 126         }
 127
 128         public void
 129         exception(Ice.LocalException exc)
 130         {
 131             test(false);
 132         }
 133
 134         public void
 135         exception(Ice.UserException exc)
 136         {
 137             try
 138             {
 139                 throw exc;
 140             }
 141             catch(Base b)
 142             {
 143                 test(b.b.equals("UnknownDerived.b"));
 144                 test(b.ice_name().equals("Test::Base"));
 145             }
 146             catch(Exception ex)
 147             {
 148                 test(false);
 149             }
 150             callback.called();
 151         }
 152
 153         public void
 154         check()
 155         {
 156             callback.check();
 157         }
 158
 159         private Callback callback = new Callback();
 160     }
 161
 162     private static class Callback_TestIntf_knownDerivedAsBaseI extends Callback_TestIntf_knownDerivedAsBase
 163     {
 164         public void
 165         response()
 166         {
 167             test(false);
 168         }
 169
 170         public void
 171         exception(Ice.LocalException exc)
 172         {
 173             test(false);
 174         }
 175
 176         public void
 177         exception(Ice.UserException exc)
 178         {
 179             try
 180             {
 181                 throw exc;
 182             }
 183             catch(KnownDerived k)
 184             {
 185                 test(k.b.equals("KnownDerived.b"));
 186                 test(k.kd.equals("KnownDerived.kd"));
 187                 test(k.ice_name().equals("Test::KnownDerived"));
 188             }
 189             catch(Exception ex)
 190             {
 191                 test(false);
 192             }
 193             callback.called();
 194         }
 195
 196         public void
 197         check()
 198         {
 199             callback.check();
 200         }
 201
 202         private Callback callback = new Callback();
 203     }
 204
 205     private static class Callback_TestIntf_knownDerivedAsKnownDerivedI
 206         extends Callback_TestIntf_knownDerivedAsKnownDerived
 207     {
 208         public void
 209         response()
 210         {
 211             test(false);
 212         }
 213
 214         public void
 215         exception(Ice.LocalException exc)
 216         {
 217             test(false);
 218         }
 219
 220         public void
 221         exception(Ice.UserException exc)
 222         {
 223             try
 224             {
 225                 throw exc;
 226             }
 227             catch(KnownDerived k)
 228             {
 229                 test(k.b.equals("KnownDerived.b"));
 230                 test(k.kd.equals("KnownDerived.kd"));
 231                 test(k.ice_name().equals("Test::KnownDerived"));
 232             }
 233             catch(Exception ex)
 234             {
 235                 test(false);
 236             }
 237             callback.called();
 238         }
 239
 240         public void
 241         check()
 242         {
 243             callback.check();
 244         }
 245
 246         private Callback callback = new Callback();
 247     }
 248
 249     private static class Callback_TestIntf_unknownIntermediateAsBaseI
 250         extends Callback_TestIntf_unknownIntermediateAsBase
 251     {
 252         public void
 253         response()
 254         {
 255             test(false);
 256         }
 257
 258         public void
 259         exception(Ice.LocalException exc)
 260         {
 261             test(false);
 262         }
 263
 264         public void
 265         exception(Ice.UserException exc)
 266         {
 267             try
 268             {
 269                 throw exc;
 270             }
 271             catch(Base b)
 272             {
 273                 test(b.b.equals("UnknownIntermediate.b"));
 274                 test(b.ice_name().equals("Test::Base"));
 275             }
 276             catch(Exception ex)
 277             {
 278                 test(false);
 279             }
 280             callback.called();
 281         }
 282
 283         public void
 284         check()
 285         {
 286             callback.check();
 287         }
 288
 289         private Callback callback = new Callback();
 290     }
 291
 292     private static class Callback_TestIntf_knownIntermediateAsBaseI extends Callback_TestIntf_knownIntermediateAsBase
 293     {
 294         public void
 295         response()
 296         {
 297             test(false);
 298         }
 299
 300         public void
 301         exception(Ice.LocalException exc)
 302         {
 303             test(false);
 304         }
 305
 306         public void
 307         exception(Ice.UserException exc)
 308         {
 309             try
 310             {
 311                 throw exc;
 312             }
 313             catch(KnownIntermediate ki)
 314             {
 315                 test(ki.b.equals("KnownIntermediate.b"));
 316                 test(ki.ki.equals("KnownIntermediate.ki"));
 317                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 318             }
 319             catch(Exception ex)
 320             {
 321                 test(false);
 322             }
 323             callback.called();
 324         }
 325
 326         public void
 327         check()
 328         {
 329             callback.check();
 330         }
 331
 332         private Callback callback = new Callback();
 333     }
 334
 335     private static class Callback_TestIntf_knownMostDerivedAsBaseI extends Callback_TestIntf_knownMostDerivedAsBase
 336     {
 337         public void
 338         response()
 339         {
 340             test(false);
 341         }
 342
 343         public void
 344         exception(Ice.LocalException exc)
 345         {
 346             test(false);
 347         }
 348
 349         public void
 350         exception(Ice.UserException exc)
 351         {
 352             try
 353             {
 354                 throw exc;
 355             }
 356             catch(KnownMostDerived kmd)
 357             {
 358                 test(kmd.b.equals("KnownMostDerived.b"));
 359                 test(kmd.ki.equals("KnownMostDerived.ki"));
 360                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 361                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 362             }
 363             catch(Exception ex)
 364             {
 365                 test(false);
 366             }
 367             callback.called();
 368         }
 369
 370         public void
 371         check()
 372         {
 373             callback.check();
 374         }
 375
 376         private Callback callback = new Callback();
 377     }
 378
 379     private static class Callback_TestIntf_knownIntermediateAsKnownIntermediateI
 380         extends Callback_TestIntf_knownIntermediateAsKnownIntermediate
 381     {
 382         public void
 383         response()
 384         {
 385             test(false);
 386         }
 387
 388         public void
 389         exception(Ice.LocalException exc)
 390         {
 391             test(false);
 392         }
 393
 394         public void
 395         exception(Ice.UserException exc)
 396         {
 397             try
 398             {
 399                 throw exc;
 400             }
 401             catch(KnownIntermediate ki)
 402             {
 403                 test(ki.b.equals("KnownIntermediate.b"));
 404                 test(ki.ki.equals("KnownIntermediate.ki"));
 405                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 406             }
 407             catch(Exception ex)
 408             {
 409                 test(false);
 410             }
 411             callback.called();
 412         }
 413
 414         public void
 415         check()
 416         {
 417             callback.check();
 418         }
 419
 420         private Callback callback = new Callback();
 421     }
 422
 423     private static class Callback_TestIntf_knownMostDerivedAsKnownIntermediateI
 424         extends Callback_TestIntf_knownMostDerivedAsKnownIntermediate
 425     {
 426         public void
 427         response()
 428         {
 429             test(false);
 430         }
 431
 432         public void
 433         exception(Ice.LocalException exc)
 434         {
 435             test(false);
 436         }
 437
 438         public void
 439         exception(Ice.UserException exc)
 440         {
 441             try
 442             {
 443                 throw exc;
 444             }
 445             catch(KnownMostDerived kmd)
 446             {
 447                 test(kmd.b.equals("KnownMostDerived.b"));
 448                 test(kmd.ki.equals("KnownMostDerived.ki"));
 449                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 450                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 451             }
 452             catch(Exception ex)
 453             {
 454                 test(false);
 455             }
 456             callback.called();
 457         }
 458
 459         public void
 460         check()
 461         {
 462             callback.check();
 463         }
 464
 465         private Callback callback = new Callback();
 466     }
 467
 468     private static class Callback_TestIntf_knownMostDerivedAsKnownMostDerivedI
 469         extends Callback_TestIntf_knownMostDerivedAsKnownMostDerived
 470     {
 471         public void
 472         response()
 473         {
 474             test(false);
 475         }
 476
 477         public void
 478         exception(Ice.LocalException exc)
 479         {
 480             test(false);
 481         }
 482
 483         public void
 484         exception(Ice.UserException exc)
 485         {
 486             try
 487             {
 488                 throw exc;
 489             }
 490             catch(KnownMostDerived kmd)
 491             {
 492                 test(kmd.b.equals("KnownMostDerived.b"));
 493                 test(kmd.ki.equals("KnownMostDerived.ki"));
 494                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 495                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 496             }
 497             catch(Exception ex)
 498             {
 499                 test(false);
 500             }
 501             callback.called();
 502         }
 503
 504         public void
 505         check()
 506         {
 507             callback.check();
 508         }
 509
 510         private Callback callback = new Callback();
 511     }
 512
 513     private static class Callback_TestIntf_unknownMostDerived1AsBaseI
 514         extends Callback_TestIntf_unknownMostDerived1AsBase
 515     {
 516         public void
 517         response()
 518         {
 519             test(false);
 520         }
 521
 522         public void
 523         exception(Ice.LocalException exc)
 524         {
 525             test(false);
 526         }
 527
 528         public void
 529         exception(Ice.UserException exc)
 530         {
 531             try
 532             {
 533                 throw exc;
 534             }
 535             catch(KnownIntermediate ki)
 536             {
 537                 test(ki.b.equals("UnknownMostDerived1.b"));
 538                 test(ki.ki.equals("UnknownMostDerived1.ki"));
 539                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 540             }
 541             catch(Exception ex)
 542             {
 543                 test(false);
 544             }
 545             callback.called();
 546         }
 547
 548         public void
 549         check()
 550         {
 551             callback.check();
 552         }
 553
 554         private Callback callback = new Callback();
 555     }
 556
 557     private static class Callback_TestIntf_unknownMostDerived1AsKnownIntermediateI
 558         extends Callback_TestIntf_unknownMostDerived1AsKnownIntermediate
 559     {
 560         public void
 561         response()
 562         {
 563             test(false);
 564         }
 565
 566         public void
 567         exception(Ice.LocalException exc)
 568         {
 569             test(false);
 570         }
 571
 572         public void
 573         exception(Ice.UserException exc)
 574         {
 575             try
 576             {
 577                 throw exc;
 578             }
 579             catch(KnownIntermediate ki)
 580             {
 581                 test(ki.b.equals("UnknownMostDerived1.b"));
 582                 test(ki.ki.equals("UnknownMostDerived1.ki"));
 583                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 584             }
 585             catch(Exception ex)
 586             {
 587                 test(false);
 588             }
 589             callback.called();
 590         }
 591
 592         public void
 593         check()
 594         {
 595             callback.check();
 596         }
 597
 598         private Callback callback = new Callback();
 599     }
 600
 601     private static class Callback_TestIntf_unknownMostDerived2AsBaseI
 602         extends Callback_TestIntf_unknownMostDerived2AsBase
 603     {
 604         public void
 605         response()
 606         {
 607             test(false);
 608         }
 609
 610         public void
 611         exception(Ice.LocalException exc)
 612         {
 613             test(false);
 614         }
 615
 616         public void
 617         exception(Ice.UserException exc)
 618         {
 619             try
 620             {
 621                 throw exc;
 622             }
 623             catch(Base b)
 624             {
 625                 test(b.b.equals("UnknownMostDerived2.b"));
 626                 test(b.ice_name().equals("Test::Base"));
 627             }
 628             catch(Exception ex)
 629             {
 630                 test(false);
 631             }
 632             callback.called();
 633         }
 634
 635         public void
 636         check()
 637         {
 638             callback.check();
 639         }
 640
 641         private Callback callback = new Callback();
 642     }
 643
 644     public static TestIntfPrx
 645     allTests(Ice.Communicator communicator, boolean collocated, java.io.PrintWriter out)
 646     {
 647                 out.print("testing stringToProxy... ");
 648         out.flush();
 649         String ref = "Test:default -p 12010 -t 10000";
 650         Ice.ObjectPrx base = communicator.stringToProxy(ref);
 651         test(base != null);
 652         out.println("ok");
 653
 654         out.print("testing checked cast... ");
 655         out.flush();
 656         TestIntfPrx test = TestIntfPrxHelper.checkedCast(base);
 657         test(test != null);
 658         test(test.equals(base));
 659         out.println("ok");
 660
 661         out.print("base... ");
 662         out.flush();
 663         {
 664             try
 665             {
 666                 test.baseAsBase();
 667                 test(false);
 668             }
 669             catch(Base b)
 670             {
 671                 test(b.b.equals("Base.b"));
 672                 test(b.ice_name().equals("Test::Base"));
 673             }
 674             catch(Exception ex)
 675             {
 676                 test(false);
 677             }
 678         }
 679         out.println("ok");
 680
 681         out.print("base (AMI)... ");
 682         out.flush();
 683         {
 684             Callback_TestIntf_baseAsBaseI cb = new Callback_TestIntf_baseAsBaseI();
 685             test.begin_baseAsBase(cb);
 686             cb.check();
 687         }
 688         out.println("ok");
 689
 690         out.print("slicing of unknown derived... ");
 691         out.flush();
 692         {
 693             try
 694             {
 695                 test.unknownDerivedAsBase();
 696                 test(false);
 697             }
 698             catch(Base b)
 699             {
 700                 test(b.b.equals("UnknownDerived.b"));
 701                 test(b.ice_name().equals("Test::Base"));
 702             }
 703             catch(Exception ex)
 704             {
 705                 test(false);
 706             }
 707         }
 708         out.println("ok");
 709
 710         out.print("slicing of unknown derived (AMI)... ");
 711         out.flush();
 712         {
 713             Callback_TestIntf_unknownDerivedAsBaseI cb = new Callback_TestIntf_unknownDerivedAsBaseI();
 714             test.begin_unknownDerivedAsBase(cb);
 715             cb.check();
 716         }
 717         out.println("ok");
 718
 719         out.print("non-slicing of known derived as base... ");
 720         out.flush();
 721         {
 722             try
 723             {
 724                 test.knownDerivedAsBase();
 725                 test(false);
 726             }
 727             catch(KnownDerived k)
 728             {
 729                 test(k.b.equals("KnownDerived.b"));
 730                 test(k.kd.equals("KnownDerived.kd"));
 731                 test(k.ice_name().equals("Test::KnownDerived"));
 732             }
 733             catch(Exception ex)
 734             {
 735                 test(false);
 736             }
 737         }
 738         out.println("ok");
 739
 740         out.print("non-slicing of known derived as base (AMI)... ");
 741         out.flush();
 742         {
 743             Callback_TestIntf_knownDerivedAsBaseI cb = new Callback_TestIntf_knownDerivedAsBaseI();
 744             test.begin_knownDerivedAsBase(cb);
 745             cb.check();
 746         }
 747         out.println("ok");
 748
 749         out.print("non-slicing of known derived as derived... ");
 750         out.flush();
 751         {
 752             try
 753             {
 754                 test.knownDerivedAsKnownDerived();
 755                 test(false);
 756             }
 757             catch(KnownDerived k)
 758             {
 759                 test(k.b.equals("KnownDerived.b"));
 760                 test(k.kd.equals("KnownDerived.kd"));
 761                 test(k.ice_name().equals("Test::KnownDerived"));
 762             }
 763             catch(Exception ex)
 764             {
 765                 test(false);
 766             }
 767         }
 768         out.println("ok");
 769
 770         out.print("non-slicing of known derived as derived (AMI)... ");
 771         out.flush();
 772         {
 773             Callback_TestIntf_knownDerivedAsKnownDerivedI cb = new Callback_TestIntf_knownDerivedAsKnownDerivedI();
 774             test.begin_knownDerivedAsKnownDerived(cb);
 775             cb.check();
 776         }
 777         out.println("ok");
 778
 779         out.print("slicing of unknown intermediate as base... ");
 780         out.flush();
 781         {
 782             try
 783             {
 784                 test.unknownIntermediateAsBase();
 785                 test(false);
 786             }
 787             catch(Base b)
 788             {
 789                 test(b.b.equals("UnknownIntermediate.b"));
 790                 test(b.ice_name().equals("Test::Base"));
 791             }
 792             catch(Exception ex)
 793             {
 794                 test(false);
 795             }
 796         }
 797         out.println("ok");
 798
 799         out.print("slicing of unknown intermediate as base (AMI)... ");
 800         out.flush();
 801         {
 802             Callback_TestIntf_unknownIntermediateAsBaseI cb = new Callback_TestIntf_unknownIntermediateAsBaseI();
 803             test.begin_unknownIntermediateAsBase(cb);
 804             cb.check();
 805         }
 806         out.println("ok");
 807
 808         out.print("slicing of known intermediate as base... ");
 809         out.flush();
 810         {
 811             try
 812             {
 813                 test.knownIntermediateAsBase();
 814                 test(false);
 815             }
 816             catch(KnownIntermediate ki)
 817             {
 818                 test(ki.b.equals("KnownIntermediate.b"));
 819                 test(ki.ki.equals("KnownIntermediate.ki"));
 820                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 821             }
 822             catch(Exception ex)
 823             {
 824                 test(false);
 825             }
 826         }
 827         out.println("ok");
 828
 829         out.print("slicing of known intermediate as base (AMI)... ");
 830         out.flush();
 831         {
 832             Callback_TestIntf_knownIntermediateAsBaseI cb = new Callback_TestIntf_knownIntermediateAsBaseI();
 833             test.begin_knownIntermediateAsBase(cb);
 834             cb.check();
 835         }
 836         out.println("ok");
 837
 838         out.print("slicing of known most derived as base... ");
 839         out.flush();
 840         {
 841             try
 842             {
 843                 test.knownMostDerivedAsBase();
 844                 test(false);
 845             }
 846             catch(KnownMostDerived kmd)
 847             {
 848                 test(kmd.b.equals("KnownMostDerived.b"));
 849                 test(kmd.ki.equals("KnownMostDerived.ki"));
 850                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 851                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 852             }
 853             catch(Exception ex)
 854             {
 855                 test(false);
 856             }
 857         }
 858         out.println("ok");
 859
 860         out.print("slicing of known most derived as base (AMI)... ");
 861         out.flush();
 862         {
 863             Callback_TestIntf_knownMostDerivedAsBaseI cb = new Callback_TestIntf_knownMostDerivedAsBaseI();
 864             test.begin_knownMostDerivedAsBase(cb);
 865             cb.check();
 866         }
 867         out.println("ok");
 868
 869         out.print("non-slicing of known intermediate as intermediate... ");
 870         out.flush();
 871         {
 872             try
 873             {
 874                 test.knownIntermediateAsKnownIntermediate();
 875                 test(false);
 876             }
 877             catch(KnownIntermediate ki)
 878             {
 879                 test(ki.b.equals("KnownIntermediate.b"));
 880                 test(ki.ki.equals("KnownIntermediate.ki"));
 881                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 882             }
 883             catch(Exception ex)
 884             {
 885                 test(false);
 886             }
 887         }
 888         out.println("ok");
 889
 890         out.print("non-slicing of known intermediate as intermediate (AMI)... ");
 891         out.flush();
 892         {
 893             Callback_TestIntf_knownIntermediateAsKnownIntermediateI cb =
 894                 new Callback_TestIntf_knownIntermediateAsKnownIntermediateI();
 895             test.begin_knownIntermediateAsKnownIntermediate(cb);
 896             cb.check();
 897         }
 898         out.println("ok");
 899
 900         out.print("non-slicing of known most derived as intermediate... ");
 901         out.flush();
 902         {
 903             try
 904             {
 905                 test.knownMostDerivedAsKnownIntermediate();
 906                 test(false);
 907             }
 908             catch(KnownMostDerived kmd)
 909             {
 910                 test(kmd.b.equals("KnownMostDerived.b"));
 911                 test(kmd.ki.equals("KnownMostDerived.ki"));
 912                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 913                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 914             }
 915             catch(Exception ex)
 916             {
 917                 test(false);
 918             }
 919         }
 920         out.println("ok");
 921
 922         out.print("non-slicing of known most derived as intermediate (AMI)... ");
 923         out.flush();
 924         {
 925             Callback_TestIntf_knownMostDerivedAsKnownIntermediateI cb =
 926                 new Callback_TestIntf_knownMostDerivedAsKnownIntermediateI();
 927             test.begin_knownMostDerivedAsKnownIntermediate(cb);
 928             cb.check();
 929         }
 930         out.println("ok");
 931
 932         out.print("non-slicing of known most derived as most derived... ");
 933         out.flush();
 934         {
 935             try
 936             {
 937                 test.knownMostDerivedAsKnownMostDerived();
 938                 test(false);
 939             }
 940             catch(KnownMostDerived kmd)
 941             {
 942                 test(kmd.b.equals("KnownMostDerived.b"));
 943                 test(kmd.ki.equals("KnownMostDerived.ki"));
 944                 test(kmd.kmd.equals("KnownMostDerived.kmd"));
 945                 test(kmd.ice_name().equals("Test::KnownMostDerived"));
 946             }
 947             catch(Exception ex)
 948             {
 949                 test(false);
 950             }
 951         }
 952         out.println("ok");
 953
 954         out.print("non-slicing of known most derived as most derived (AMI)... ");
 955         out.flush();
 956         {
 957             Callback_TestIntf_knownMostDerivedAsKnownMostDerivedI cb =
 958                 new Callback_TestIntf_knownMostDerivedAsKnownMostDerivedI();
 959             test.begin_knownMostDerivedAsKnownMostDerived(cb);
 960             cb.check();
 961         }
 962         out.println("ok");
 963
 964         out.print("slicing of unknown most derived, known intermediate as base... ");
 965         out.flush();
 966         {
 967             try
 968             {
 969                 test.unknownMostDerived1AsBase();
 970                 test(false);
 971             }
 972             catch(KnownIntermediate ki)
 973             {
 974                 test(ki.b.equals("UnknownMostDerived1.b"));
 975                 test(ki.ki.equals("UnknownMostDerived1.ki"));
 976                 test(ki.ice_name().equals("Test::KnownIntermediate"));
 977             }
 978             catch(Exception ex)
 979             {
 980                 test(false);
 981             }
 982         }
 983         out.println("ok");
 984
 985         out.print("slicing of unknown most derived, known intermediate as base (AMI)... ");
 986         out.flush();
 987         {
 988             Callback_TestIntf_unknownMostDerived1AsBaseI cb = new Callback_TestIntf_unknownMostDerived1AsBaseI();
 989             test.begin_unknownMostDerived1AsBase(cb);
 990             cb.check();
 991         }
 992         out.println("ok");
 993
 994         out.print("slicing of unknown most derived, known intermediate as intermediate... ");
 995         out.flush();
 996         {
 997             try
 998             {
 999                 test.unknownMostDerived1AsKnownIntermediate();
1000                 test(false);
1001             }
1002             catch(KnownIntermediate ki)
1003             {
1004                 test(ki.b.equals("UnknownMostDerived1.b"));
1005                 test(ki.ki.equals("UnknownMostDerived1.ki"));
1006                 test(ki.ice_name().equals("Test::KnownIntermediate"));
1007             }
1008             catch(Exception ex)
1009             {
1010                 test(false);
1011             }
1012         }
1013         out.println("ok");
1014
1015         out.print("slicing of unknown most derived, known intermediate as intermediate (AMI)... ");
1016         out.flush();
1017         {
1018             Callback_TestIntf_unknownMostDerived1AsKnownIntermediateI cb =
1019                 new Callback_TestIntf_unknownMostDerived1AsKnownIntermediateI();
1020             test.begin_unknownMostDerived1AsKnownIntermediate(cb);
1021             cb.check();
1022         }
1023         out.println("ok");
1024
1025         out.print("slicing of unknown most derived, unknown intermediate thrown as base... ");
1026         out.flush();
1027         {
1028             try
1029             {
1030                 test.unknownMostDerived2AsBase();
1031                 test(false);
1032             }
1033             catch(Base b)
1034             {
1035                 test(b.b.equals("UnknownMostDerived2.b"));
1036                 test(b.ice_name().equals("Test::Base"));
1037             }
1038             catch(Exception ex)
1039             {
1040                 test(false);
1041             }
1042         }
1043         out.println("ok");
1044
1045         out.print("slicing of unknown most derived, unknown intermediate thrown as base (AMI)... ");
1046         out.flush();
1047         {
1048             Callback_TestIntf_unknownMostDerived2AsBaseI cb = new Callback_TestIntf_unknownMostDerived2AsBaseI();
1049             test.begin_unknownMostDerived2AsBase(cb);
1050             cb.check();
1051         }
1052         out.println("ok");
1053
1054         return test;
1055     }
1056 }