TAO/orbsvcs/tests/InterfaceRepo/IFR_Test/Admin_Client.cpp

   1 // -*- C++ -*-
   2 #include "Admin_Client.h"
   3
   4 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
   5 #include "tao/CDR.h"
   6
   7 #include "ace/Get_Opt.h"
   8 #include "ace/SString.h"
   9
  10 Admin_Client::Admin_Client ()
  11   : debug_ (0),
  12     all_tests_ (1),
  13     which_test_ (0),
  14     iterations_ (1)
  15 {
  16   // Initialize the array of pointers to member functions.
  17   this->test_array_[0] = &Admin_Client::array_test;
  18   this->test_array_[1] = &Admin_Client::enum_test;
  19   this->test_array_[2] = &Admin_Client::alias_test;
  20   this->test_array_[3] = &Admin_Client::native_test;
  21   this->test_array_[4] = &Admin_Client::struct_test;
  22   this->test_array_[5] = &Admin_Client::union_test;
  23   this->test_array_[6] = &Admin_Client::exception_test;
  24   this->test_array_[7] = &Admin_Client::constant_test;
  25   this->test_array_[8] = &Admin_Client::interface_test;
  26   this->test_array_[9] = &Admin_Client::move_test;
  27   this->test_array_[10] = &Admin_Client::module_test;
  28 }
  29
  30 Admin_Client::~Admin_Client ()
  31 {
  32 }
  33
  34 // An array of test names, so we can step through them when
  35 // trying to find a match for a test selected on the command line.
  36 const char *Admin_Client::test_names_[] =
  37 {
  38   "array",
  39   "enum",
  40   "alias",
  41   "native",
  42   "struct",
  43   "union",
  44   "exception",
  45   "constant",
  46   "interface",
  47   "move",
  48   "module"
  49 };
  50
  51 int
  52 Admin_Client::init (int argc, ACE_TCHAR *argv[])
  53 {
  54   try
  55     {
  56       this->orb_ = CORBA::ORB_init (argc, argv);
  57
  58       int retval = this->parse_args (argc, argv);
  59
  60       if (retval != 0)
  61         return retval;
  62
  63       CORBA::Object_var object =
  64         this->orb_->resolve_initial_references ("InterfaceRepository");
  65
  66       if (CORBA::is_nil (object.in ()))
  67         {
  68           ACE_ERROR_RETURN ((
  69               LM_ERROR,
  70               "Null objref from resolve_initial_references\n"
  71             ), -1);
  72         }
  73
  74       this->repo_ =
  75         CORBA::Repository::_narrow (object.in ());
  76
  77       if (CORBA::is_nil (this->repo_.in ()))
  78         {
  79           ACE_ERROR_RETURN ((LM_ERROR,
  80                              "CORBA::Repository::_narrow failed\n"),
  81                             -1);
  82         }
  83     }
  84   catch (const CORBA::Exception& ex)
  85     {
  86       ex._tao_print_exception ("Admin_Client::init");
  87       return -1;
  88     }
  89
  90   return 0;
  91 }
  92
  93 int
  94 Admin_Client::run ()
  95 {
  96   try
  97     {
  98       if (this->all_tests_ == 1)
  99         {
 100           for (CORBA::ULong i = 0; i < NUMBER_OF_TESTS; ++i)
 101             {
 102               // Each test is run twice to make sure everything
 103               // gets destroyed properly. If not, we get a
 104               // CORBA::BAD_PARAM exception the second time.
 105               for (CORBA::ULong j = 0; j < this->iterations_; ++j)
 106                 {
 107                   (this->*test_array_[i])();
 108                 }
 109             }
 110         }
 111       else
 112         {
 113           for (CORBA::ULong j = 0; j < this->iterations_; ++j)
 114             {
 115               (this->*test_array_[this->which_test_])();
 116             }
 117         }
 118     }
 119   catch (const CORBA::Exception& ex)
 120     {
 121       ex._tao_print_exception ("Admin_Client::run");
 122       return -1;
 123     }
 124
 125   return 0;
 126 }
 127
 128 int
 129 Admin_Client::parse_args (int argc, ACE_TCHAR *argv[])
 130 {
 131   ACE_Get_Opt opts (argc, argv, ACE_TEXT("di:t:"));
 132   int c;
 133   int result = 0;
 134   CORBA::ULong i = 0;
 135   ACE_TCHAR *name = 0;
 136
 137   while ((c = opts ()) != -1)
 138     switch (c)
 139       {
 140       case 'd':   // debug flag
 141         this->debug_ = 1;
 142         break;
 143       case 'i':   // iterations
 144         result = ACE_OS::atoi (opts.opt_arg ());
 145         if (result > 0)
 146           this->iterations_ = result;
 147         break;
 148       case 't':   // test selection
 149         this->all_tests_ = 0;
 150         name = opts.opt_arg ();
 151
 152         for (i = 0; i < NUMBER_OF_TESTS; ++i)
 153           {
 154             if (ACE_OS::strcmp (ACE_TEXT_ALWAYS_CHAR (name), this->test_names_[i]) == 0)
 155               {
 156                 this->which_test_ = i;
 157                 break;
 158               }
 159           }
 160
 161         break;
 162       case '?':
 163       default:
 164         ACE_ERROR_RETURN ((LM_ERROR,
 165                            "usage: %s"
 166                            " [-d]"
 167                            " [-i iterations]"
 168                            " [-t test name]"
 169                            "\n",
 170                            argv [0]),
 171                           -1);
 172       }
 173
 174   return 0;
 175 }
 176
 177 void
 178 Admin_Client::array_test ()
 179 {
 180   if (this->debug_)
 181     {
 182       ACE_DEBUG ((
 183           LM_DEBUG,
 184           ACE_TEXT ("\n============== ARRAY TEST ==============\n\n")
 185         ));
 186     }
 187
 188   CORBA::IDLType_var atype =
 189     this->repo_->create_string (7);
 190
 191   CORBA::ArrayDef_var avar =
 192     this->repo_->create_array (5,
 193                                atype.in ());
 194
 195   CORBA::ULong bound = avar->length ();
 196
 197   if (this->debug_)
 198     {
 199       ACE_DEBUG ((LM_DEBUG,
 200                   ACE_TEXT ("ArrayDef::length: %d\n"),
 201                   bound));
 202     }
 203
 204   ACE_TEST_ASSERT (bound == 5);
 205
 206   CORBA::TypeCode_var tc = avar->type ();
 207
 208   CORBA::TCKind kind = tc->kind ();
 209
 210   if (this->debug_)
 211     {
 212       ACE_DEBUG ((LM_DEBUG,
 213                   ACE_TEXT ("ArrayDef::type::kind: %d\n"),
 214                   kind));
 215     }
 216
 217   ACE_TEST_ASSERT (kind == CORBA::tk_array);
 218
 219   tc = avar->element_type ();
 220   kind = tc->kind ();
 221
 222   if (this->debug_)
 223     {
 224       ACE_DEBUG ((LM_DEBUG,
 225                   ACE_TEXT ("ArrayDef::element_type::kind: %d\n"),
 226                   kind));
 227     }
 228
 229   ACE_TEST_ASSERT (kind == CORBA::tk_string);
 230
 231   CORBA::IDLType_var tdef =
 232     avar->element_type_def ();
 233   CORBA::DefinitionKind dk = tdef->def_kind ();
 234
 235   if (this->debug_)
 236     {
 237       ACE_DEBUG ((
 238           LM_DEBUG,
 239           ACE_TEXT ("ArrayDef::element_type_def::def_kind: %d\n"),
 240           dk
 241         ));
 242     }
 243
 244   ACE_TEST_ASSERT (dk == CORBA::dk_String);
 245
 246   CORBA::StringDef_var pvar =
 247     CORBA::StringDef::_narrow (tdef.in ());
 248   bound = pvar->bound ();
 249
 250   if (this->debug_)
 251     {
 252       ACE_DEBUG ((LM_DEBUG,
 253                   ACE_TEXT ("StringDef::bound: %d\n"),
 254                   bound));
 255     }
 256
 257   ACE_TEST_ASSERT (bound == 7);
 258
 259   CORBA::PrimitiveDef_var pdef =
 260     this->repo_->get_primitive (CORBA::pk_short);
 261   avar->element_type_def (pdef.in ());
 262
 263   if (this->debug_)
 264     {
 265       ACE_DEBUG ((LM_DEBUG,
 266                   ACE_TEXT ("ArrayDef::element_type_def (set)\n")));
 267     }
 268
 269   tc = avar->type ();
 270   kind = tc->kind ();
 271
 272   if (this->debug_)
 273     {
 274       ACE_DEBUG ((LM_DEBUG,
 275                   ACE_TEXT ("ArrayDef::type::kind: %d\n"),
 276                   kind));
 277     }
 278
 279   ACE_TEST_ASSERT (kind == CORBA::tk_array);
 280
 281   tdef = avar->element_type_def ();
 282   dk = tdef->def_kind ();
 283
 284   if (this->debug_)
 285     {
 286       ACE_DEBUG ((LM_DEBUG,
 287                   ACE_TEXT ("ArrayDef::element_type_def::def_kind: %d\n"),
 288                   dk));
 289     }
 290
 291   ACE_TEST_ASSERT (dk == CORBA::dk_Primitive);
 292
 293   CORBA::PrimitiveDef_var zvar =
 294     CORBA::PrimitiveDef::_narrow (tdef.in ());
 295   CORBA::PrimitiveKind pkind = zvar->kind ();
 296
 297   if (this->debug_)
 298     {
 299       ACE_DEBUG ((LM_DEBUG,
 300                   ACE_TEXT ("PrimitiveDef::kind: %d\n"),
 301                   pkind));
 302     }
 303
 304   ACE_TEST_ASSERT (pkind == CORBA::pk_short);
 305
 306   avar->destroy ();
 307 }
 308
 309 void
 310 Admin_Client::enum_test ()
 311 {
 312   if (this->debug_)
 313     {
 314       ACE_DEBUG ((
 315           LM_DEBUG,
 316           ACE_TEXT ("\n============== ENUM TEST ==============\n\n")
 317         ));
 318     }
 319
 320   CORBA::EnumMemberSeq members (4);
 321   members.length (3);
 322
 323   members[0] = CORBA::string_dup ("ZERO");
 324   members[1] = CORBA::string_dup ("ONE");
 325   members[2] = CORBA::string_dup ("TWO");
 326
 327   CORBA::EnumDef_var evar =
 328     this->repo_->create_enum ("IDL:my_enum:1.0",
 329                               "my_enum",
 330                               "1.0",
 331                               members);
 332
 333   CORBA::String_var str = evar->id ();
 334
 335   if (this->debug_)
 336     {
 337       ACE_DEBUG ((LM_DEBUG,
 338                   ACE_TEXT ("EnumDef::id: %C\n"),
 339                   str.in ()));
 340     }
 341
 342   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_enum:1.0") == 0);
 343
 344   str = evar->name ();
 345
 346   if (this->debug_)
 347     {
 348       ACE_DEBUG ((LM_DEBUG,
 349                   ACE_TEXT ("EnumDef::name: %C\n"),
 350                   str.in ()));
 351     }
 352
 353   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_enum") == 0);
 354
 355   str = evar->absolute_name ();
 356
 357   if (this->debug_)
 358     {
 359       ACE_DEBUG ((LM_DEBUG,
 360                   ACE_TEXT ("EnumDef::absolute_name: %C\n"),
 361                   str.in ()));
 362     }
 363
 364   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_enum") == 0);
 365
 366   str = evar->version ();
 367
 368   if (this->debug_)
 369     {
 370       ACE_DEBUG ((LM_DEBUG,
 371                   ACE_TEXT ("EnumDef::version: %C\n"),
 372                   str.in ()));
 373     }
 374
 375   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "1.0") == 0);
 376
 377   CORBA::DefinitionKind dkind =
 378     evar->def_kind ();
 379
 380   if (this->debug_)
 381     {
 382       ACE_DEBUG ((LM_DEBUG,
 383                   ACE_TEXT ("EnumDef::def_kind: %d\n\n"),
 384                   dkind));
 385     }
 386
 387   ACE_TEST_ASSERT (dkind == CORBA::dk_Enum);
 388
 389   CORBA::Contained::Description_var desc =
 390     evar->describe ();
 391
 392   dkind = desc->kind;
 393
 394   if (this->debug_)
 395     {
 396       ACE_DEBUG ((LM_DEBUG,
 397                   ACE_TEXT ("EnumDef::describe::kind: %d\n"),
 398                   dkind));
 399     }
 400
 401   ACE_TEST_ASSERT (dkind == CORBA::dk_Enum);
 402
 403   const CORBA::TypeDescription *td = 0;
 404   desc->value >>= td;
 405
 406   if (this->debug_)
 407     {
 408       ACE_DEBUG ((LM_DEBUG,
 409                   ACE_TEXT ("EnumDef::describe::value::name: %C\n"),
 410                   td->name.in ()));
 411     }
 412
 413   ACE_TEST_ASSERT (ACE_OS::strcmp (td->name, "my_enum") == 0);
 414
 415   if (this->debug_)
 416     {
 417       ACE_DEBUG ((LM_DEBUG,
 418                   ACE_TEXT ("EnumDef::describe::value::id: %C\n"),
 419                   td->id.in ()));
 420     }
 421
 422   ACE_TEST_ASSERT (ACE_OS::strcmp (td->id, "IDL:my_enum:1.0") == 0);
 423
 424   if (this->debug_)
 425     {
 426       ACE_DEBUG ((LM_DEBUG,
 427                   ACE_TEXT ("EnumDef::describe::value::defined_in: %C\n"),
 428                   td->defined_in.in ()));
 429     }
 430
 431   ACE_TEST_ASSERT (ACE_OS::strcmp (td->defined_in, "") == 0);
 432
 433   if (this->debug_)
 434     {
 435       ACE_DEBUG ((LM_DEBUG,
 436                   ACE_TEXT ("EnumDef::describe::value::version: %C\n"),
 437                   td->version.in ()));
 438     }
 439
 440   ACE_TEST_ASSERT (ACE_OS::strcmp (td->version, "1.0") == 0);
 441
 442   CORBA::TCKind kind = td->type->kind ();
 443
 444   if (this->debug_)
 445     {
 446       ACE_DEBUG ((LM_DEBUG,
 447                   ACE_TEXT ("EnumDef::describe::value::type::kind: %d\n"),
 448                   kind));
 449     }
 450
 451   ACE_TEST_ASSERT (kind == CORBA::tk_enum);
 452
 453   str = td->type->id ();
 454
 455   if (this->debug_)
 456     {
 457       ACE_DEBUG ((LM_DEBUG,
 458                   ACE_TEXT ("EnumDef::describe::value::type::id: %C\n"),
 459                   str.in ()));
 460     }
 461
 462   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_enum:1.0") == 0);
 463
 464   str = td->type->name ();
 465
 466   if (this->debug_)
 467     {
 468       ACE_DEBUG ((LM_DEBUG,
 469                   ACE_TEXT ("EnumDef::describe::value::type::name: %C\n"),
 470                   str.in ()));
 471     }
 472
 473   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_enum") == 0);
 474
 475   CORBA::ULong count =
 476     td->type->member_count ();
 477
 478   if (this->debug_)
 479     {
 480       ACE_DEBUG ((
 481           LM_DEBUG,
 482           ACE_TEXT ("EnumDef::describe::value::type::member_count: %d\n\n"),
 483           count
 484         ));
 485     }
 486
 487   ACE_TEST_ASSERT (count == 3);
 488
 489   CORBA::ULong i = 0;
 490
 491   for (i = 0; i < count; ++i)
 492     {
 493       str = td->type->member_name (i);
 494
 495       if (this->debug_)
 496         {
 497           ACE_DEBUG ((LM_DEBUG,
 498                       ACE_TEXT ("EnumDef::describe::value::type::")
 499                       ACE_TEXT ("member_name[%d]: %C\n"),
 500                       i,
 501                       str.in ()));
 502         }
 503
 504       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), members[i]) == 0);
 505     }
 506
 507
 508   members.length (4);
 509   members[0] = CORBA::string_dup ("NOTHINGNESS");
 510   members[1] = CORBA::string_dup ("UNITY");
 511   members[2] = CORBA::string_dup ("DUALITY");
 512   members[3] = CORBA::string_dup ("TRINITY");
 513
 514   evar->members (members);
 515
 516   if (this->debug_)
 517     {
 518       ACE_DEBUG ((LM_DEBUG,
 519                   ACE_TEXT ("\nEnumDef::members (set)\n\n")));
 520     }
 521
 522   CORBA::EnumMemberSeq_var fellows =
 523     evar->members ();
 524
 525   count = fellows->length ();
 526   const char *tmp = 0;
 527
 528   for (i = 0; i < count; ++i)
 529     {
 530       tmp = fellows[i];
 531
 532       if (this->debug_)
 533         {
 534           ACE_DEBUG ((LM_DEBUG,
 535                       ACE_TEXT ("EnumDef::")
 536                       ACE_TEXT ("members[%d]: %C\n"),
 537                       i,
 538                       tmp));
 539         }
 540
 541       ACE_TEST_ASSERT (ACE_OS::strcmp (fellows[i], members[i]) == 0);
 542     }
 543
 544   evar->name ("another_enum");
 545   str = evar->name ();
 546
 547   if (this->debug_)
 548     {
 549       ACE_DEBUG ((LM_DEBUG,
 550                   ACE_TEXT ("\nEnumDef::name (set)\n")));
 551     }
 552
 553   if (this->debug_)
 554     {
 555       ACE_DEBUG ((LM_DEBUG,
 556                   ACE_TEXT ("EnumDef::name: %C\n"),
 557                   str.in ()));
 558     }
 559
 560   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "another_enum") == 0);
 561
 562   str = evar->absolute_name ();
 563
 564   if (this->debug_)
 565     {
 566       ACE_DEBUG ((LM_DEBUG,
 567                   ACE_TEXT ("EnumDef::absolute_name: %C\n"),
 568                   str.in ()));
 569     }
 570
 571   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::another_enum") == 0);
 572
 573   evar->destroy ();
 574 }
 575
 576 void
 577 Admin_Client::alias_test ()
 578 {
 579   if (this->debug_)
 580     {
 581       ACE_DEBUG ((
 582           LM_DEBUG,
 583           ACE_TEXT ("\n============== ALIAS TEST ==============\n\n")
 584         ));
 585     }
 586
 587   // This test also tests WstringDef and SequenceDef.
 588
 589   CORBA::IDLType_var sq_elem =
 590     this->repo_->create_wstring (7);
 591
 592   CORBA::SequenceDef_var sq_var =
 593     this->repo_->create_sequence (5,
 594                                   sq_elem.in ());
 595
 596   CORBA::AliasDef_var a_var =
 597     this->repo_->create_alias ("IDL:my_alias:1.0",
 598                                "my_alias",
 599                                "1.0",
 600                                sq_var.in ());
 601
 602   CORBA::String_var str = a_var->id ();
 603
 604   if (this->debug_)
 605     {
 606       ACE_DEBUG ((LM_DEBUG,
 607                   ACE_TEXT ("AliasDef::id: %C\n"),
 608                   str.in ()));
 609     }
 610
 611   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_alias:1.0") == 0);
 612
 613   str = a_var->name ();
 614
 615   if (this->debug_)
 616     {
 617       ACE_DEBUG ((LM_DEBUG,
 618                   ACE_TEXT ("AliasDef::name: %C\n"),
 619                   str.in ()));
 620     }
 621
 622   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_alias") == 0);
 623
 624   str = a_var->absolute_name ();
 625
 626   if (this->debug_)
 627     {
 628       ACE_DEBUG ((LM_DEBUG,
 629                   ACE_TEXT ("AliasDef::absolute_name: %C\n"),
 630                   str.in ()));
 631     }
 632
 633   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_alias") == 0);
 634
 635   str = a_var->version ();
 636
 637   if (this->debug_)
 638     {
 639       ACE_DEBUG ((LM_DEBUG,
 640                   ACE_TEXT ("AliasDef::version: %C\n"),
 641                   str.in ()));
 642     }
 643
 644   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "1.0") == 0);
 645
 646   if (this->debug_)
 647     {
 648       ACE_DEBUG ((LM_DEBUG,
 649                   ACE_TEXT ("AliasDef::version (set)\n")));
 650     }
 651
 652   a_var->version ("1.1");
 653
 654   str = a_var->version ();
 655
 656   if (this->debug_)
 657     {
 658       ACE_DEBUG ((LM_DEBUG,
 659                   ACE_TEXT ("AliasDef::version: %C\n"),
 660                   str.in ()));
 661     }
 662
 663   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "1.1") == 0);
 664
 665   CORBA::TypeCode_var tc = a_var->type ();
 666
 667   str = tc->name ();
 668
 669   if (this->debug_)
 670     {
 671       ACE_DEBUG ((LM_DEBUG,
 672                   ACE_TEXT ("\nAliasDef::type::name: %C\n"),
 673                   str.in ()));
 674     }
 675
 676   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_alias") == 0);
 677
 678   CORBA::TCKind kind = tc->kind ();
 679
 680   if (this->debug_)
 681     {
 682       ACE_DEBUG ((LM_DEBUG,
 683                   ACE_TEXT ("AliasDef::type::kind: %d\n"),
 684                   kind));
 685     }
 686
 687   ACE_TEST_ASSERT (kind == CORBA::tk_alias);
 688
 689   CORBA::TypeCode_var ct =
 690     tc->content_type ();
 691
 692   kind = ct->kind ();
 693
 694   if (this->debug_)
 695     {
 696       ACE_DEBUG ((LM_DEBUG,
 697                   ACE_TEXT ("AliasDef::type::content_type::kind: %d\n"),
 698                   kind));
 699     }
 700
 701   ACE_TEST_ASSERT (kind == CORBA::tk_sequence);
 702
 703   CORBA::ULong length = ct->length ();
 704
 705   if (this->debug_)
 706     {
 707       ACE_DEBUG ((LM_DEBUG,
 708                   ACE_TEXT ("AliasDef::type::content_type::length: %d\n"),
 709                   length));
 710     }
 711
 712   ACE_TEST_ASSERT (length == 5);
 713
 714   CORBA::TypeCode_var ct2 =
 715     ct->content_type ();
 716
 717   kind = ct2->kind ();
 718
 719   if (this->debug_)
 720     {
 721       ACE_DEBUG ((LM_DEBUG,
 722                   ACE_TEXT ("AliasDef::type::content_type::")
 723                   ACE_TEXT ("content_type::kind: %d\n"),
 724                   kind));
 725     }
 726
 727   ACE_TEST_ASSERT (kind == CORBA::tk_wstring);
 728
 729   length = ct2->length ();
 730
 731   if (this->debug_)
 732     {
 733       ACE_DEBUG ((LM_DEBUG,
 734                   ACE_TEXT ("AliasDef::type::content_type::")
 735                   ACE_TEXT ("content_type::length: %d\n"),
 736                   length));
 737     }
 738
 739   ACE_TEST_ASSERT (length == 7);
 740
 741   CORBA::Contained::Description_var desc =
 742     a_var->describe ();
 743
 744   const CORBA::TypeDescription *td = 0;
 745   desc->value >>= td;
 746
 747   if (this->debug_)
 748     {
 749       ACE_DEBUG ((LM_DEBUG,
 750                   ACE_TEXT ("\nAliasDef::describe::value::name: %C\n"),
 751                   td->name.in ()));
 752     }
 753
 754   ACE_TEST_ASSERT (ACE_OS::strcmp (td->name, "my_alias") == 0);
 755
 756   if (this->debug_)
 757     {
 758       ACE_DEBUG ((LM_DEBUG,
 759                   ACE_TEXT ("AliasDef::describe::value::version: %C\n"),
 760                   td->version.in ()));
 761     }
 762
 763   ACE_TEST_ASSERT (ACE_OS::strcmp (td->version, "1.1") == 0);
 764
 765   kind = td->type->kind ();
 766
 767   if (this->debug_)
 768     {
 769       ACE_DEBUG ((LM_DEBUG,
 770                   ACE_TEXT ("AliasDef::describe::value::type::kind: %d\n"),
 771                   kind));
 772     }
 773
 774   ACE_TEST_ASSERT (kind == CORBA::tk_alias);
 775
 776   str = td->type->id ();
 777
 778   if (this->debug_)
 779     {
 780       ACE_DEBUG ((LM_DEBUG,
 781                   ACE_TEXT ("AliasDef::describe::value::type::id: %C\n"),
 782                   str.in ()));
 783     }
 784
 785   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_alias:1.0") == 0);
 786
 787   str = td->type->name ();
 788
 789   if (this->debug_)
 790     {
 791       ACE_DEBUG ((LM_DEBUG,
 792                   ACE_TEXT ("AliasDef::describe::value::type::name: %C\n"),
 793                   str.in ()));
 794     }
 795
 796   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_alias") == 0);
 797
 798   CORBA::IDLType_var i_var =
 799     a_var->original_type_def ();
 800
 801   CORBA::SequenceDef_var seq_var =
 802     CORBA::SequenceDef::_narrow (i_var.in ());
 803
 804   length = seq_var->bound ();
 805
 806   if (this->debug_)
 807     {
 808       ACE_DEBUG ((LM_DEBUG,
 809                   ACE_TEXT ("AliasDef::original_type_def::bound: %d\n"),
 810                   length));
 811     }
 812
 813   ACE_TEST_ASSERT (length == 5);
 814
 815   a_var->destroy ();
 816 }
 817
 818 void
 819 Admin_Client::native_test ()
 820 {
 821   if (this->debug_)
 822     {
 823       ACE_DEBUG ((
 824           LM_DEBUG,
 825           ACE_TEXT ("\n============== NATIVE TEST ==============\n\n")
 826         ));
 827     }
 828
 829   CORBA::NativeDef_var nvar =
 830     this->repo_->create_native ("IDL:my_native:1.0",
 831                                 "my_native",
 832                                 "1.0");
 833
 834   CORBA::String_var str = nvar->id ();
 835
 836   if (this->debug_)
 837     {
 838       ACE_DEBUG ((LM_DEBUG,
 839                   ACE_TEXT ("NativeDef::id: %C\n"),
 840                   str.in ()));
 841     }
 842
 843   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_native:1.0") == 0);
 844
 845   str = nvar->name ();
 846
 847   if (this->debug_)
 848     {
 849       ACE_DEBUG ((LM_DEBUG,
 850                   ACE_TEXT ("NativeDef::name: %C\n"),
 851                   str.in ()));
 852     }
 853
 854   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "my_native") == 0);
 855
 856   str = nvar->version ();
 857
 858   if (this->debug_)
 859     {
 860       ACE_DEBUG ((LM_DEBUG,
 861                   ACE_TEXT ("NativeDef::version: %C\n"),
 862                   str.in ()));
 863     }
 864
 865   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "1.0") == 0);
 866
 867   str = nvar->absolute_name ();
 868
 869   if (this->debug_)
 870     {
 871       ACE_DEBUG ((LM_DEBUG,
 872                   ACE_TEXT ("NativeDef::absolute_name: %C\n"),
 873                   str.in ()));
 874     }
 875
 876   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_native") == 0);
 877
 878   CORBA::DefinitionKind kind =
 879     nvar->def_kind ();
 880
 881   if (this->debug_)
 882     {
 883       ACE_DEBUG ((LM_DEBUG,
 884                   ACE_TEXT ("NativeDef::def_kind: %d\n"),
 885                   kind));
 886     }
 887
 888   ACE_TEST_ASSERT (kind == CORBA::dk_Native);
 889
 890   nvar->destroy ();
 891 }
 892
 893 void
 894 Admin_Client::struct_test ()
 895 {
 896   if (this->debug_)
 897     {
 898       ACE_DEBUG ((
 899           LM_DEBUG,
 900           ACE_TEXT ("\n============== STRUCT TEST ==============\n\n")
 901         ));
 902     }
 903
 904   CORBA::StructMemberSeq members (3);
 905   members.length (3);
 906
 907   members[0].name = CORBA::string_dup ("ub_string");
 908   members[0].type_def = this->repo_->get_primitive (CORBA::pk_string);
 909   members[0].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
 910
 911   members[1].name = CORBA::string_dup ("bd_string");
 912   members[1].type_def = this->repo_->create_string (5);
 913   members[1].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
 914
 915   CORBA::EnumMemberSeq e_members (2);
 916   e_members.length (2);
 917
 918   e_members[0] = CORBA::string_dup ("ZERO");
 919   e_members[1] = CORBA::string_dup ("ONE");
 920
 921   members[2].name = CORBA::string_dup ("my_struct_enum");
 922
 923   CORBA::EnumDef_var e_var =
 924     this->repo_->create_enum ("IDL:my_enum:1.0",
 925                               "my_enum",
 926                               "1.0",
 927                               e_members);
 928   members[2].type_def = CORBA::EnumDef::_duplicate (e_var.in ());
 929   members[2].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
 930
 931   CORBA::StructDef_var svar =
 932     this->repo_->create_struct ("IDL:my_struct:1.0",
 933                                 "my_struct",
 934                                 "1.0",
 935                                 members);
 936
 937   // This also tests the members() function.
 938   CORBA::TypeCode_var tc = svar->type ();
 939
 940   CORBA::ULong length = tc->member_count ();
 941
 942   if (this->debug_)
 943     {
 944       ACE_DEBUG ((LM_DEBUG,
 945                   ACE_TEXT ("StructDef::type::length: %d\n"),
 946                   length));
 947     }
 948
 949   ACE_TEST_ASSERT (length == 3);
 950
 951   CORBA::String_var str;
 952   CORBA::ULong i = 0;
 953
 954   for (i = 0; i < length; ++i)
 955     {
 956       str = tc->member_name (i);
 957
 958       if (this->debug_)
 959         {
 960           ACE_DEBUG ((LM_DEBUG,
 961                       ACE_TEXT ("StructDef::type::member_name[%d]: %C\n"),
 962                       i,
 963                       str.in ()));
 964         }
 965
 966       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), members[i].name) == 0);
 967     }
 968
 969   CORBA::Contained::Description_var desc =
 970     svar->describe ();
 971
 972   const CORBA::TypeDescription *td = 0;
 973   desc->value >>= td;
 974
 975   if (this->debug_)
 976     {
 977       ACE_DEBUG ((LM_DEBUG,
 978                   ACE_TEXT ("\nStructDef::describe::value::name: %C\n"),
 979                   td->name.in ()));
 980     }
 981
 982   ACE_TEST_ASSERT (ACE_OS::strcmp (td->name, "my_struct") == 0);
 983
 984   if (this->debug_)
 985     {
 986       ACE_DEBUG ((LM_DEBUG,
 987                   ACE_TEXT ("StructDef::describe::value::id: %C\n"),
 988                   td->id.in ()));
 989     }
 990
 991   ACE_TEST_ASSERT (ACE_OS::strcmp (td->id, "IDL:my_struct:1.0") == 0);
 992
 993   if (this->debug_)
 994     {
 995       ACE_DEBUG ((LM_DEBUG,
 996                   ACE_TEXT ("StructDef::describe::value::version: %C\n"),
 997                   td->version.in ()));
 998     }
 999
1000   ACE_TEST_ASSERT (ACE_OS::strcmp (td->version, "1.0") == 0);
1001
1002   members.length (2);
1003   members[0].name = CORBA::string_dup ("long_mem");
1004   members[0].type_def = this->repo_->get_primitive (CORBA::pk_long);
1005   members[0].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1006
1007   members[1].name = CORBA::string_dup ("array_mem");
1008   members[1].type_def =
1009     this->repo_->create_array (5,
1010                                members[0].type_def.in ());
1011   members[1].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1012
1013   svar->members (members);
1014
1015   if (this->debug_)
1016     {
1017       ACE_DEBUG ((LM_DEBUG,
1018                   ACE_TEXT ("\nStructDef::members (set)\n\n")));
1019     }
1020
1021   CORBA::EnumMemberSeq def_members (2);
1022   def_members.length (2);
1023
1024   def_members[0] = CORBA::string_dup ("FIRST");
1025   def_members[1] = CORBA::string_dup ("SECOND");
1026
1027   CORBA::EnumDef_var e_def_var = svar->create_enum ("IDL:my_def_enum:1.0",
1028                                                     "my_enum",
1029                                                     "1.0",
1030                                                     def_members);
1031
1032   CORBA::StructMemberSeq_var out_members =
1033     svar->members ();
1034
1035   length = out_members->length ();
1036   int cmp_result = 0;
1037
1038   for (i = 0; i < length; ++i)
1039     {
1040       if (this->debug_)
1041         {
1042           ACE_DEBUG ((LM_DEBUG,
1043                       ACE_TEXT ("StructDef::members[%d]::name: %C\n"),
1044                       i,
1045                       out_members[i].name.in ()));
1046         }
1047
1048       if (i == length - 1)
1049         {
1050           cmp_result =
1051             ACE_OS::strcmp (out_members[i].name, "my_enum");
1052           ACE_TEST_ASSERT (cmp_result == 0);
1053         }
1054       else
1055         {
1056           cmp_result =
1057             ACE_OS::strcmp (out_members[i].name, members[i].name);
1058           ACE_TEST_ASSERT (cmp_result == 0);
1059         }
1060     }
1061
1062   CORBA::Contained_var fox = this->repo_->lookup ("::my_struct::my_enum");
1063
1064   str = fox->absolute_name ();
1065
1066   if (this->debug_)
1067     {
1068       ACE_DEBUG ((LM_DEBUG,
1069                   ACE_TEXT ("Repository::lookup::absolute_name: %C\n"),
1070                   str.in ()));
1071     }
1072
1073   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_struct::my_enum") == 0);
1074
1075   fox = svar->lookup ("my_enum");
1076
1077   str = fox->absolute_name ();
1078
1079   if (this->debug_)
1080     {
1081       ACE_DEBUG ((LM_DEBUG,
1082                   ACE_TEXT ("StructDef::lookup::absolute_name: %C\n"),
1083                   str.in ()));
1084     }
1085
1086   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_struct::my_enum") == 0);
1087
1088   CORBA::Container_var outer = fox->defined_in ();
1089   CORBA::Contained_var schizo =
1090     CORBA::Contained::_narrow (outer.in ());
1091
1092   str = schizo->absolute_name ();
1093
1094   if (this->debug_)
1095     {
1096       ACE_DEBUG ((LM_DEBUG,
1097                   ACE_TEXT ("StructDef::lookup::defined_in::")
1098                   ACE_TEXT ("absolute_name: %C\n"),
1099                   str.in ()));
1100     }
1101
1102   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_struct") == 0);
1103
1104   CORBA::ContainedSeq_var contents =
1105     this->repo_->contents (CORBA::dk_all,
1106                            0);
1107
1108   length = contents->length ();
1109
1110   if (this->debug_)
1111     {
1112       ACE_DEBUG ((LM_DEBUG,
1113                   ACE_TEXT ("\nRepository::contents::length: %d\n"),
1114                   length));
1115     }
1116
1117   ACE_TEST_ASSERT (length == 2);
1118
1119   contents = svar->contents (CORBA::dk_all,
1120                              0);
1121
1122   length = contents->length ();
1123
1124   if (this->debug_)
1125     {
1126       ACE_DEBUG ((LM_DEBUG,
1127                   ACE_TEXT ("StructDef::contents::length: %d\n"),
1128                   length));
1129     }
1130
1131   ACE_TEST_ASSERT (length == 1);
1132
1133   for (i = 0; i < length; ++i)
1134     {
1135       str = contents[i]->absolute_name ();
1136
1137       if (this->debug_)
1138         {
1139           ACE_DEBUG ((
1140               LM_DEBUG,
1141               ACE_TEXT ("StructDef::contents[%d]::absolute_name: %C\n"),
1142               i,
1143               str.in ()
1144             ));
1145         }
1146
1147       if (i == 0)
1148         {
1149           ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_struct::my_enum") == 0);
1150         }
1151       else
1152         {
1153           // No more found in lookup.
1154         }
1155     }
1156
1157   contents = this->repo_->lookup_name ("my_enum",
1158                                        -1,
1159                                        CORBA::dk_all,
1160                                        0);
1161
1162   length = contents->length ();
1163
1164   if (this->debug_)
1165     {
1166       ACE_DEBUG ((LM_DEBUG,
1167                   ACE_TEXT ("\nRepository::lookup_name::length: %d\n"),
1168                   length));
1169     }
1170
1171   ACE_TEST_ASSERT (length == 2);
1172
1173   for (i = 0; i < length; ++i)
1174     {
1175       str = contents[i]->absolute_name ();
1176
1177       if (this->debug_)
1178         {
1179           ACE_DEBUG ((
1180               LM_DEBUG,
1181               ACE_TEXT ("Repository::lookup_name[%d]::absolute_name: %C\n"),
1182               i,
1183               str.in ()
1184             ));
1185         }
1186
1187       // Can't use ACE_TEST_ASSERT here because we don't know the order
1188       // of the results of the search.
1189     }
1190
1191   CORBA::Container::DescriptionSeq_var cont_desc =
1192     this->repo_->describe_contents (CORBA::dk_all,
1193                                     0,
1194                                     -1);
1195
1196   length = cont_desc->length ();
1197
1198   if (this->debug_)
1199     {
1200       ACE_DEBUG ((LM_DEBUG,
1201                   ACE_TEXT ("\nRepository::describe_contents::length: %d\n"),
1202                   length));
1203     }
1204
1205   ACE_TEST_ASSERT (length == 2);
1206
1207   for (i = 0; i < length; ++i)
1208     {
1209       const CORBA::TypeDescription *td = 0;
1210       cont_desc[i].value >>= td;
1211
1212       str = td->type->id ();
1213
1214       if (this->debug_)
1215         {
1216           ACE_DEBUG ((
1217               LM_DEBUG,
1218               ACE_TEXT ("Repository::describe_contents[%d]::id: %C\n"),
1219               i,
1220               str.in ()
1221             ));
1222         }
1223
1224       if (i == 0)
1225         {
1226           ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_enum:1.0") == 0);
1227         }
1228       else if (i == 1)
1229         {
1230           ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:my_struct:1.0") == 0);
1231         }
1232     }
1233
1234   svar->name ("your_struct");
1235
1236   if (this->debug_)
1237     {
1238       ACE_DEBUG ((LM_DEBUG,
1239                   ACE_TEXT ("\nStructDef::name (set)\n")));
1240     }
1241
1242   contents = svar->contents (CORBA::dk_all,
1243                              0);
1244
1245   length = contents->length ();
1246
1247   if (this->debug_)
1248     {
1249       ACE_DEBUG ((LM_DEBUG,
1250                   ACE_TEXT ("StructDef::contents::length: %d\n"),
1251                   length));
1252     }
1253
1254   ACE_TEST_ASSERT (length == 1);
1255
1256   const char *tmp = "::your_struct";
1257
1258   for (i = 0; i < length; ++i)
1259     {
1260       str = contents[i]->absolute_name ();
1261
1262       if (this->debug_)
1263         {
1264           ACE_DEBUG ((
1265               LM_DEBUG,
1266               ACE_TEXT ("StructDef::contents[%d]::absolute_name: %C\n"),
1267               i,
1268               str.in ()
1269             ));
1270         }
1271
1272       // Whatever the scoped name now is, it must begin
1273       // with "::your_struct".
1274       cmp_result =
1275         ACE_OS::strncmp (str.in (), tmp, ACE_OS::strlen (tmp));
1276       ACE_TEST_ASSERT (cmp_result == 0);
1277     }
1278
1279 #if defined (ACE_NDEBUG)
1280   // ACE_TEST_ASSERT macro expands to nothing, so...
1281   ACE_UNUSED_ARG (tmp);
1282 #endif /* ACE_NDEBUG */
1283
1284   e_var->destroy ();
1285   svar->destroy ();
1286 }
1287
1288 void
1289 Admin_Client::union_test ()
1290 {
1291   if (this->debug_)
1292     {
1293       ACE_DEBUG ((
1294           LM_DEBUG,
1295           ACE_TEXT ("\n============== UNION TEST ==============\n\n")
1296         ));
1297     }
1298
1299   CORBA::EnumMemberSeq d_members (4);
1300   d_members.length (4);
1301
1302   d_members[0] = CORBA::string_dup ("ZERO");
1303   d_members[1] = CORBA::string_dup ("ONE");
1304   d_members[2] = CORBA::string_dup ("TWO");
1305   d_members[3] = CORBA::string_dup ("THREE");
1306
1307   CORBA::EnumDef_var d_var =
1308     this->repo_->create_enum ("IDL:disc_enum:1.0",
1309                               "disc_enum",
1310                               "1.0",
1311                               d_members);
1312
1313   CORBA::StructMemberSeq s_members (1);
1314   s_members.length (1);
1315   s_members[0].name = CORBA::string_dup ("string_in_struct");
1316   s_members[0].type_def =
1317     this->repo_->create_string (6);
1318   s_members[0].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1319
1320   CORBA::StructDef_var s_var =
1321     this->repo_->create_struct ("IDL:struct_in_union:1.0",
1322                                 "struct_in_union",
1323                                 "1.0",
1324                                 s_members);
1325
1326   CORBA::UnionMemberSeq u_members (4);
1327   u_members.length (4);
1328
1329   u_members[0].name = CORBA::string_dup ("longval");
1330   u_members[0].type_def =
1331     this->repo_->get_primitive (CORBA::pk_long);
1332   u_members[0].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1333   CORBA::TypeCode_var d_type = d_var->type ();
1334   TAO_OutputCDR maker2;
1335   maker2.write_ulong (3);  // THREE
1336   TAO_InputCDR maker2_in (maker2);
1337   TAO::Unknown_IDL_Type *impl2 = 0;
1338   ACE_NEW (impl2,
1339            TAO::Unknown_IDL_Type (d_type.in (),
1340                                   maker2_in));
1341   CORBA::Any any2;
1342   any2.replace (impl2);
1343   u_members[0].label = any2;
1344
1345   u_members[1].name = CORBA::string_dup ("longval");
1346   u_members[1].type_def =
1347     this->repo_->get_primitive (CORBA::pk_long);
1348   u_members[1].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1349   TAO_OutputCDR maker0;
1350   maker0.write_ulong (2);  // TWO
1351   TAO_InputCDR maker0_in (maker0);
1352   TAO::Unknown_IDL_Type *impl0 = 0;
1353   ACE_NEW (impl0,
1354            TAO::Unknown_IDL_Type (d_type.in (),
1355                                   maker0_in));
1356   CORBA::Any any0;
1357   any0.replace (impl0);
1358   u_members[1].label = any0;
1359
1360   u_members[2].name = CORBA::string_dup ("structval");
1361   u_members[2].type_def = CORBA::StructDef::_duplicate (s_var.in ());
1362   u_members[2].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1363
1364   TAO_OutputCDR maker1;
1365   maker1.write_ulong (0); // ZERO
1366   TAO_InputCDR maker1_in (maker1);
1367   TAO::Unknown_IDL_Type *impl1 = 0;
1368   ACE_NEW (impl1,
1369            TAO::Unknown_IDL_Type (d_type.in (),
1370                                   maker1_in));
1371   CORBA::Any any1;
1372   any1.replace (impl1);
1373   u_members[2].label = any1;
1374
1375   u_members[3].name = CORBA::string_dup ("stringval");
1376   u_members[3].type_def =
1377     this->repo_->create_string (17);
1378   u_members[3].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
1379   u_members[3].label <<= CORBA::Any::from_octet (0);   // default case (ONE)
1380
1381   CORBA::UnionDef_var u_var =
1382     this->repo_->create_union ("IDL:my_union:1.0",
1383                                "my_union",
1384                                "1.0",
1385                                d_var.in (),
1386                                u_members);
1387
1388   CORBA::TypeCode_var disc_tc =
1389     u_var->discriminator_type ();
1390
1391   CORBA::ULong length =
1392     disc_tc->member_count ();
1393
1394   if (this->debug_)
1395     {
1396       ACE_DEBUG ((
1397           LM_DEBUG,
1398           ACE_TEXT ("UnionDef::discriminator_type::member_count: %d\n"),
1399           length
1400         ));
1401     }
1402
1403   ACE_TEST_ASSERT (length == 4);
1404
1405   CORBA::TypeCode_var tc = u_var->type ();
1406
1407   length = tc->member_count ();
1408
1409   if (this->debug_)
1410     {
1411       ACE_DEBUG ((LM_DEBUG,
1412                   ACE_TEXT ("UnionDef::type::member_count: %d\n"),
1413                   length));
1414     }
1415
1416   ACE_TEST_ASSERT (length == 3);
1417
1418   CORBA::Long slot = tc->default_index ();
1419
1420   if (this->debug_)
1421     {
1422       ACE_DEBUG ((LM_DEBUG,
1423                   ACE_TEXT ("UnionDef::type::default_index: %d\n\n"),
1424                   slot));
1425     }
1426
1427   ACE_TEST_ASSERT (slot == 2);
1428
1429   CORBA::String_var str;
1430   const char *tmp = 0;
1431
1432   for (CORBA::ULong i = 0; i < length; ++i)
1433     {
1434       str = tc->member_name (i);
1435
1436       if (this->debug_)
1437         {
1438           ACE_DEBUG ((LM_DEBUG,
1439                       ACE_TEXT ("UnionDef::type::member_name[%d]: %C\n"),
1440                       i,
1441                       str.in ()));
1442         }
1443
1444       // Multiple labels for first member shifts index by 1.
1445       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), u_members[i + 1].name) == 0);
1446
1447       CORBA::Any_var label = tc->member_label (i);
1448
1449       TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0));
1450       CORBA::ULong val = 0;
1451
1452       TAO::Any_Impl *impl = label->impl ();
1453       TAO_OutputCDR out;
1454       impl->marshal_value (out);
1455       TAO_InputCDR in (out);
1456
1457       // If we're at the default index, it's in the label as octet 0,
1458       // so just assign the slot value to val.
1459       if (i != (CORBA::ULong) slot)
1460         {
1461           in.read_ulong (val);
1462           tmp = d_members[val];
1463         }
1464
1465       if (this->debug_)
1466         {
1467           ACE_DEBUG ((LM_DEBUG,
1468                       ACE_TEXT ("UnionDef::type::member_label[%d]: %C\n"),
1469                       i,
1470                       i == (CORBA::ULong) slot ? "default" : tmp));
1471         }
1472
1473       // Labels are not in order.
1474       switch (i)
1475         {
1476           case 0:
1477             ACE_TEST_ASSERT (val == 3 || val == 2);
1478             break;
1479           case 1:
1480             ACE_TEST_ASSERT (val == 0);
1481             break;
1482           default:
1483             break;
1484         }
1485     }
1486
1487   u_var->destroy ();
1488   s_var->destroy ();
1489   d_var->destroy ();
1490 }
1491
1492 void
1493 Admin_Client::exception_test ()
1494 {
1495   if (this->debug_)
1496     {
1497       ACE_DEBUG ((
1498           LM_DEBUG,
1499           ACE_TEXT ("\n============== EXCEPTION TEST ==============\n\n")
1500         ));
1501     }
1502
1503   CORBA::StructMemberSeq members (3);
1504   members.length (3);
1505
1506   members[0].name = CORBA::string_dup ("ub_string");
1507   members[0].type_def = this->repo_->get_primitive (CORBA::pk_string);
1508   members[0].type =
1509     members[0].type_def->type ();
1510
1511   members[1].name = CORBA::string_dup ("bd_string");
1512   members[1].type_def = this->repo_->create_string (5);
1513   members[1].type = members[1].type_def->type ();
1514
1515   CORBA::EnumMemberSeq e_members (2);
1516   e_members.length (2);
1517
1518   e_members[0] = CORBA::string_dup ("ZERO");
1519   e_members[1] = CORBA::string_dup ("ONE");
1520
1521   members[2].name = CORBA::string_dup ("my_exception_enum");
1522   CORBA::EnumDef_var e_var =
1523     this->repo_->create_enum ("IDL:my_enum:1.0",
1524                               "my_enum",
1525                               "1.0",
1526                               e_members);
1527
1528   members[2].type_def = CORBA::EnumDef::_duplicate (e_var.in ());
1529
1530   members[2].type =
1531     members[2].type_def->type ();
1532
1533   CORBA::ExceptionDef_var exvar =
1534     this->repo_->create_exception ("IDL:my_exception:1.0",
1535                                    "my_exception",
1536                                    "1.0",
1537                                    members);
1538
1539   CORBA::TypeCode_var tc = exvar->type ();
1540
1541   CORBA::ULong length = tc->member_count ();
1542
1543   if (this->debug_)
1544     {
1545       ACE_DEBUG ((LM_DEBUG,
1546                   ACE_TEXT ("ExceptionDef::type::member_count: %d\n"),
1547                   length));
1548     }
1549
1550   ACE_TEST_ASSERT (length == 3);
1551
1552   CORBA::String_var str;
1553   CORBA::ULong i = 0;
1554
1555   for (i = 0; i < length; ++i)
1556     {
1557       str = tc->member_name (i);
1558
1559       if (this->debug_)
1560         {
1561           ACE_DEBUG ((LM_DEBUG,
1562                       ACE_TEXT ("ExceptionDef::type::member_name[%d]: %C\n"),
1563                       i,
1564                       str.in ()));
1565         }
1566
1567       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), members[i].name) == 0);
1568     }
1569
1570   CORBA::Contained::Description_var desc =
1571     exvar->describe ();
1572
1573   const CORBA::ExceptionDescription *ed = 0;
1574   desc->value >>= ed;
1575
1576   if (this->debug_)
1577     {
1578       ACE_DEBUG ((LM_DEBUG,
1579                   ACE_TEXT ("\nExceptionDef::describe::value::name: %C\n"),
1580                   ed->name.in ()));
1581     }
1582
1583   ACE_TEST_ASSERT (ACE_OS::strcmp (ed->name, "my_exception") == 0);
1584
1585   if (this->debug_)
1586     {
1587       ACE_DEBUG ((LM_DEBUG,
1588                   ACE_TEXT ("ExceptionDef::describe::value::id: %C\n"),
1589                   ed->id.in ()));
1590     }
1591
1592   ACE_TEST_ASSERT (ACE_OS::strcmp (ed->id, "IDL:my_exception:1.0") == 0);
1593
1594   if (this->debug_)
1595     {
1596       ACE_DEBUG ((LM_DEBUG,
1597                   ACE_TEXT ("ExceptionDef::describe::value::defined_in: %C\n"),
1598                   ed->defined_in.in ()));
1599     }
1600
1601   ACE_TEST_ASSERT (ACE_OS::strcmp (ed->defined_in, "") == 0);
1602
1603   if (this->debug_)
1604     {
1605       ACE_DEBUG ((LM_DEBUG,
1606                   ACE_TEXT ("ExceptionDef::describe::value::version: %C\n"),
1607                   ed->version.in ()));
1608     }
1609
1610   ACE_TEST_ASSERT (ACE_OS::strcmp (ed->version, "1.0") == 0);
1611
1612   members.length (2);
1613   members[0].name = CORBA::string_dup ("long_mem");
1614   members[0].type_def = this->repo_->get_primitive (CORBA::pk_long);
1615   members[0].type =
1616     members[0].type_def->type ();
1617
1618   members[1].name = CORBA::string_dup ("array_mem");
1619   CORBA::ArrayDef_ptr a_ptr =
1620     this->repo_->create_array (5,
1621                                members[0].type_def.in ());
1622   members[1].type_def = a_ptr;
1623   members[1].type =
1624     members[1].type_def->type ();
1625
1626   exvar->members (members);
1627
1628   if (this->debug_)
1629     {
1630       ACE_DEBUG ((LM_DEBUG,
1631                   ACE_TEXT ("\nExceptionDef::members (set)\n\n")));
1632     }
1633
1634   CORBA::EnumMemberSeq def_members (2);
1635   def_members.length (2);
1636
1637   def_members[0] = CORBA::string_dup ("FIRST");
1638   def_members[1] = CORBA::string_dup ("SECOND");
1639
1640   CORBA::EnumDef_var e_def_var = exvar->create_enum ("IDL:my_def_enum:1.0",
1641                                                      "my_enum",
1642                                                      "1.0",
1643                                                      def_members);
1644
1645   CORBA::StructMemberSeq_var out_members =
1646     exvar->members ();
1647
1648   length = out_members->length ();
1649   int cmp_result = 0;
1650
1651   for (i = 0; i < length; ++i)
1652     {
1653       if (this->debug_)
1654         ACE_DEBUG ((LM_DEBUG,
1655                     ACE_TEXT ("ExceptionDef::members[%d]::name: %C\n"),
1656                     i,
1657                     out_members[i].name.in ()));
1658
1659       if (i == 2)
1660         {
1661           cmp_result =
1662             ACE_OS::strcmp (out_members[i].name, "my_enum");
1663           ACE_TEST_ASSERT (cmp_result == 0);
1664         }
1665       else
1666         {
1667           cmp_result =
1668             ACE_OS::strcmp (out_members[i].name, members[i].name);
1669           ACE_TEST_ASSERT (cmp_result == 0);
1670         }
1671     }
1672
1673   a_ptr->destroy ();
1674
1675   if (this->debug_)
1676     {
1677       ACE_DEBUG ((LM_DEBUG,
1678                   ACE_TEXT ("\nArrayDef::destroy\n\n")));
1679     }
1680
1681   out_members = exvar->members ();
1682   length = out_members->length ();
1683
1684   for (i = 0; i < length; ++i)
1685     {
1686       if (this->debug_)
1687         {
1688           ACE_DEBUG ((LM_DEBUG,
1689                       ACE_TEXT ("ExceptionDef::members[%d]::name: %C\n"),
1690                       i,
1691                       out_members[i].name.in ()));
1692         }
1693
1694       if (i == 1)
1695         {
1696           cmp_result =
1697             ACE_OS::strcmp (out_members[i].name, "my_enum");
1698           ACE_TEST_ASSERT (cmp_result == 0);
1699         }
1700       else
1701         {
1702           cmp_result =
1703             ACE_OS::strcmp (out_members[i].name, members[i].name);
1704           ACE_TEST_ASSERT (cmp_result == 0);
1705         }
1706     }
1707
1708   CORBA::Contained_var fox = this->repo_->lookup ("::my_exception::my_enum");
1709
1710   str = fox->absolute_name ();
1711
1712   if (this->debug_)
1713     {
1714       ACE_DEBUG ((LM_DEBUG,
1715                   ACE_TEXT ("\nRepository::lookup: %s\n"),
1716                   str.in ()));
1717     }
1718
1719   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_exception::my_enum") == 0);
1720
1721   fox = exvar->lookup ("my_enum");
1722
1723   str = fox->absolute_name ();
1724
1725   if (this->debug_)
1726     {
1727       ACE_DEBUG ((LM_DEBUG,
1728                   ACE_TEXT ("ExceptionDef::lookup: %s\n"),
1729                   str.in ()));
1730     }
1731
1732   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_exception::my_enum") == 0);
1733
1734   CORBA::ContainedSeq_var contents =
1735     this->repo_->contents (CORBA::dk_all,
1736                            0);
1737
1738   length = contents->length ();
1739
1740   if (this->debug_)
1741     {
1742       ACE_DEBUG ((LM_DEBUG,
1743                   ACE_TEXT ("\nRepository::contents::length: %d\n"),
1744                   length));
1745     }
1746
1747   ACE_TEST_ASSERT (length == 2);
1748
1749   contents = exvar->contents (CORBA::dk_all,
1750                               0);
1751
1752   length = contents->length ();
1753
1754   if (this->debug_)
1755     {
1756       ACE_DEBUG ((LM_DEBUG,
1757                   ACE_TEXT ("ExceptionDef::contents::length: %d\n"),
1758                   length));
1759     }
1760
1761   ACE_TEST_ASSERT (length == 1);
1762
1763   for (i = 0; i < length; ++i)
1764     {
1765       str = contents[i]->absolute_name ();
1766
1767       if (this->debug_)
1768         {
1769           ACE_DEBUG ((
1770               LM_DEBUG,
1771               ACE_TEXT ("ExceptionDef::contents[%d]::absolute_name: %C\n"),
1772               i,
1773               str.in ()
1774             ));
1775         }
1776
1777       // Should be only the one member.
1778       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::my_exception::my_enum") == 0);
1779     }
1780
1781   contents = this->repo_->lookup_name ("my_enum",
1782                                        -1,
1783                                        CORBA::dk_all,
1784                                        0);
1785
1786   length = contents->length ();
1787
1788   if (this->debug_)
1789     {
1790       ACE_DEBUG ((LM_DEBUG,
1791                   ACE_TEXT ("\nRepository::lookup_name::length: %d\n"),
1792                   length));
1793     }
1794
1795   ACE_TEST_ASSERT (length == 2);
1796
1797   for (i = 0; i < length; ++i)
1798     {
1799       str = contents[i]->absolute_name ();
1800
1801       if (this->debug_)
1802         {
1803           ACE_DEBUG ((
1804               LM_DEBUG,
1805               ACE_TEXT ("Repository::lookup_name%d]::absolute_name: %C\n"),
1806               i,
1807               str.in ()
1808             ));
1809         }
1810
1811       // Can't use ACE_TEST_ASSERT here - order of search results is unknown.
1812     }
1813
1814   CORBA::Container::DescriptionSeq_var cont_desc =
1815     this->repo_->describe_contents (CORBA::dk_all,
1816                                     0,
1817                                     -1);
1818
1819   length = cont_desc->length ();
1820
1821   if (this->debug_)
1822     {
1823       ACE_DEBUG ((LM_DEBUG,
1824                   ACE_TEXT ("\nRepository::describe_contents::length: %d\n"),
1825                   length));
1826     }
1827
1828   ACE_TEST_ASSERT (length == 2);
1829
1830   const CORBA::TypeDescription *td = 0;
1831
1832   for (i = 0; i < length; ++i)
1833     {
1834       CORBA::DefinitionKind kind = cont_desc[i].kind;
1835
1836       if (kind == CORBA::dk_Exception)
1837         {
1838           cont_desc[i].value >>= ed;
1839           CORBA::TypeCode_ptr tc = ed->type.in ();
1840
1841           length = tc->member_count ();
1842
1843           if (this->debug_)
1844             {
1845               ACE_DEBUG ((LM_DEBUG,
1846                           ACE_TEXT ("Repository::describe_contents[%d]")
1847                           ACE_TEXT ("::value::type::member_count: %d\n"),
1848                           i,
1849                           length));
1850             }
1851
1852           ACE_TEST_ASSERT (length == 2);
1853
1854           if (this->debug_)
1855             {
1856               ACE_DEBUG ((LM_DEBUG,
1857                           ACE_TEXT ("Repository::describe_contents[%d]")
1858                           ACE_TEXT ("::value::name: %C\n"),
1859                           i,
1860                           ed->name.in ()));
1861             }
1862
1863           ACE_TEST_ASSERT (ACE_OS::strcmp (ed->name, "my_exception") == 0);
1864         }
1865       else
1866         {
1867           cont_desc[i].value >>= td;
1868           CORBA::TypeCode_ptr tc = td->type.in ();
1869
1870           length = tc->member_count ();
1871
1872           if (this->debug_)
1873             {
1874               ACE_DEBUG ((LM_DEBUG,
1875                           ACE_TEXT ("Repository::describe_contents[%d]")
1876                           ACE_TEXT ("::value::type::member_count: %d\n"),
1877                           i,
1878                           length));
1879             }
1880
1881           ACE_TEST_ASSERT (length == 2);
1882
1883           if (this->debug_)
1884             {
1885               ACE_DEBUG ((LM_DEBUG,
1886                           ACE_TEXT ("Repository::describe_contents[%d]")
1887                           ACE_TEXT ("::value::name: %C\n"),
1888                           i,
1889                           td->name.in ()));
1890             }
1891
1892           ACE_TEST_ASSERT (ACE_OS::strcmp (td->name, "my_enum") == 0);
1893         }
1894     }
1895
1896   exvar->name ("your_exception");
1897
1898   if (this->debug_)
1899     {
1900       ACE_DEBUG ((LM_DEBUG,
1901                   ACE_TEXT ("\nExceptionDef::name (set)\n\n")));
1902     }
1903
1904   contents = exvar->contents (CORBA::dk_all,
1905                               0);
1906
1907   length = contents->length ();
1908   const char *tmp = "::your_exception";
1909
1910   for (i = 0; i < length; ++i)
1911     {
1912       str = contents[i]->absolute_name ();
1913
1914       if (this->debug_)
1915         {
1916           ACE_DEBUG ((
1917               LM_DEBUG,
1918               ACE_TEXT ("ExceptionDef::contents[%d]::absolute_name: %C\n"),
1919               i,
1920               str.in ()
1921             ));
1922         }
1923
1924       ACE_TEST_ASSERT (ACE_OS::strncmp (str.in (), tmp, ACE_OS::strlen (tmp)) == 0);
1925     }
1926
1927 #if defined (ACE_NDEBUG)
1928   // ACE_TEST_ASSERT macro expands to nothing, so...
1929   ACE_UNUSED_ARG (tmp);
1930 #endif /* ACE_NDEBUG */
1931
1932   e_var->destroy ();
1933   exvar->destroy ();
1934 }
1935
1936 void
1937 Admin_Client::constant_test ()
1938 {
1939   if (this->debug_)
1940     {
1941       ACE_DEBUG ((
1942           LM_DEBUG,
1943           ACE_TEXT ("\n============== CONSTANT TEST ==============\n\n")
1944         ));
1945     }
1946
1947   CORBA::IDLType_var ivar =
1948     this->repo_->get_primitive (CORBA::pk_string);
1949
1950   CORBA::Any any;
1951   const char *s = "hello";
1952   any <<= s;
1953
1954   CORBA::ConstantDef_var cvar =
1955     this->repo_->create_constant ("IDL:my_constant:1.0",
1956                                   "my_constant",
1957                                   "1.0",
1958                                   ivar.in (),
1959                                   any);
1960
1961   CORBA::TypeCode_var tc = cvar->type ();
1962   CORBA::TCKind kind = tc->kind ();
1963
1964   if (this->debug_)
1965     {
1966       ACE_DEBUG ((LM_DEBUG,
1967                   ACE_TEXT ("ConstantDef::type::kind: %d\n"),
1968                   kind));
1969     }
1970
1971   ACE_TEST_ASSERT (kind == CORBA::tk_string);
1972
1973   CORBA::IDLType_var tdef =
1974     cvar->type_def ();
1975   CORBA::DefinitionKind def_kind =
1976     tdef->def_kind ();
1977
1978   if (this->debug_)
1979     {
1980       ACE_DEBUG ((LM_DEBUG,
1981                   ACE_TEXT ("ConstantDef::type_def::def_kind: %d\n"),
1982                   def_kind));
1983     }
1984
1985   ACE_TEST_ASSERT (def_kind == CORBA::dk_Primitive);
1986
1987   CORBA::Any_var out_any;
1988   out_any = cvar->value ();
1989
1990   const char *out_s;
1991   out_any >>= out_s;
1992
1993   if (this->debug_)
1994     {
1995       ACE_DEBUG ((LM_DEBUG,
1996                   ACE_TEXT ("ConstantDef::value (string): %C\n"),
1997                   out_s));
1998     }
1999
2000   ACE_TEST_ASSERT (ACE_OS::strcmp (out_s, s) == 0);
2001
2002   ivar = this->repo_->get_primitive (CORBA::pk_double);
2003   cvar->type_def (ivar.in ());
2004
2005   CORBA::Double double_val = -1223.42256;
2006   any <<= double_val;
2007   cvar->value (any);
2008
2009   if (this->debug_)
2010     {
2011       ACE_DEBUG ((LM_DEBUG,
2012                   ACE_TEXT ("\nConstantDef::type_def (set)\n")
2013                   ACE_TEXT ("ConstantDef::value (set)\n")));
2014     }
2015
2016   out_any = cvar->value ();
2017
2018   CORBA::Double out_double_val;
2019   out_any >>= out_double_val;
2020
2021   if (this->debug_)
2022     {
2023       ACE_DEBUG ((LM_DEBUG,
2024                   ACE_TEXT ("ConstantDef::value (double): %.5f\n"),
2025                   out_double_val));
2026     }
2027
2028   ACE_TEST_ASSERT (ACE::is_equal (out_double_val, double_val));
2029
2030   ivar = this->repo_->get_primitive (CORBA::pk_short);
2031   cvar->type_def (ivar.in ());
2032
2033   if (this->debug_)
2034     {
2035       ACE_DEBUG ((LM_DEBUG,
2036                   ACE_TEXT ("\nConstantDef::type_def (set)\n")
2037                   ACE_TEXT ("ConstantDef::value (set)\n")));
2038     }
2039
2040   CORBA::Short short_val = -65;
2041   any <<= short_val;
2042
2043   cvar->value (any);
2044   out_any = cvar->value ();
2045
2046   CORBA::Short out_short_val;
2047   out_any >>= out_short_val;
2048
2049   if (this->debug_)
2050     {
2051       ACE_DEBUG ((LM_DEBUG,
2052                   ACE_TEXT ("ConstantDef::value (short): %hd\n"),
2053                   out_short_val));
2054     }
2055
2056   ACE_TEST_ASSERT (out_short_val == short_val);
2057
2058   ivar = this->repo_->get_primitive (CORBA::pk_float);
2059   cvar->type_def (ivar.in ());
2060
2061   if (this->debug_)
2062     {
2063       ACE_DEBUG ((LM_DEBUG,
2064                   ACE_TEXT ("\nConstantDef::type_def (set)\n")
2065                   ACE_TEXT ("ConstantDef::value (set)\n")));
2066     }
2067
2068   CORBA::Float float_val = 2.33f;
2069   any <<= float_val;
2070
2071   cvar->value (any);
2072   out_any = cvar->value ();
2073
2074   CORBA::Float out_float_val;
2075   out_any >>= out_float_val;
2076
2077   if (this->debug_)
2078     {
2079       ACE_DEBUG ((LM_DEBUG,
2080                   ACE_TEXT ("ConstantDef::value (float): %.2f\n"),
2081                   out_float_val));
2082     }
2083
2084   ACE_TEST_ASSERT (ACE::is_equal (out_float_val, float_val));
2085
2086   ivar = this->repo_->get_primitive (CORBA::pk_ulonglong);
2087   cvar->type_def (ivar.in ());
2088
2089   if (this->debug_)
2090     {
2091       ACE_DEBUG ((LM_DEBUG,
2092                   ACE_TEXT ("\nConstantDef::type_def (set)\n")
2093                   ACE_TEXT ("ConstantDef::value (set)\n")));
2094     }
2095
2096   CORBA::ULongLong ull_val = 1234567890;
2097   any <<= ull_val;
2098
2099   cvar->value (any);
2100   out_any = cvar->value ();
2101
2102   CORBA::ULongLong out_ull_val;
2103   out_any >>= out_ull_val;
2104
2105   if (this->debug_)
2106     {
2107       ACE_DEBUG ((LM_DEBUG,
2108                   ACE_TEXT ("ConstantDef::value (ulonglong): %Q\n"),
2109                   out_ull_val));
2110     }
2111   ACE_TEST_ASSERT (out_ull_val == ull_val);
2112
2113   cvar->destroy ();
2114 }
2115
2116 void
2117 Admin_Client::interface_test ()
2118 {
2119   if (this->debug_)
2120     {
2121       ACE_DEBUG ((
2122           LM_DEBUG,
2123           ACE_TEXT ("\n============== INTERFACE TEST ==============\n\n")
2124         ));
2125     }
2126
2127   CORBA::ULong i, length;
2128
2129   CORBA::InterfaceDefSeq in_bases (1);
2130   in_bases.length (0);
2131
2132   CORBA::InterfaceDef_var gp_ivar =
2133     this->repo_->create_interface ("IDL:gp_iface:1.0",
2134                                    "gp_iface",
2135                                    "1.0",
2136                                    in_bases);
2137
2138   CORBA::PrimitiveDef_var p_long =
2139     this->repo_->get_primitive (CORBA::pk_long);
2140
2141   CORBA::AttributeDef_var gp_attr =
2142     gp_ivar->create_attribute ("IDL:gp_iface/gp_attr:1.0",
2143                                "gp_attr",
2144                                "1.0",
2145                                p_long.in (),
2146                                CORBA::ATTR_NORMAL);
2147
2148   in_bases.length (1);
2149   in_bases[0] = CORBA::InterfaceDef::_duplicate (gp_ivar.in ());
2150
2151   CORBA::InterfaceDef_var p_ivar =
2152     this->repo_->create_interface ("IDL:p_iface:1.0",
2153                                    "p_iface",
2154                                    "1.0",
2155                                    in_bases);
2156
2157   CORBA::StringDef_var p_string =
2158     this->repo_->create_string (5);
2159
2160   CORBA::AttributeDef_var p_attr =
2161     p_ivar->create_attribute ("IDL:p_iface/p_attr:1.0",
2162                               "p_attr",
2163                               "1.0",
2164                               p_string.in (),
2165                               CORBA::ATTR_READONLY);
2166
2167   const char *names[] = {"inarg", "inoutarg", "outarg"};
2168
2169   const CORBA::ParameterMode modes[] =
2170     {CORBA::PARAM_IN, CORBA::PARAM_INOUT, CORBA::PARAM_OUT};
2171
2172   const char *contexts[] = {"straw", "sticks", "bricks"};
2173
2174   length = 3;
2175   CORBA::ParDescriptionSeq par_seq (3);
2176   par_seq.length (3);
2177
2178   CORBA::StructMemberSeq members (0);
2179   members.length (0);
2180
2181   CORBA::ExceptionDef_var ex_var =
2182     this->repo_->create_exception ("IDL:if_exception:1.0",
2183                                    "if_exception",
2184                                    "1.0",
2185                                    members);
2186
2187   CORBA::ExceptionDefSeq get_seq (1);
2188   get_seq.length (1);
2189   get_seq[0] = CORBA::ExceptionDef::_duplicate (ex_var.in ());
2190
2191   CORBA::ContextIdSeq con_seq (3);
2192   con_seq.length (3);
2193
2194   for (i = 0; i < length; ++i)
2195     {
2196       par_seq[i].name = names[i];
2197       par_seq[i].type_def = CORBA::PrimitiveDef::_duplicate (p_long.in ());
2198       par_seq[i].type = p_long->type ();
2199       par_seq[i].mode = modes[i];
2200       con_seq[i] = contexts[i];
2201     }
2202
2203   CORBA::OperationDef_var p_op =
2204     p_ivar->create_operation ("IDL:p_iface/p_op:1.0",
2205                               "p_op",
2206                               "1.0",
2207                               p_long.in (),
2208                               CORBA::OP_NORMAL,
2209                               par_seq,
2210                               get_seq,
2211                               con_seq);
2212
2213   CORBA::Contained::Description_var desc =
2214     p_op->describe ();
2215
2216   const CORBA::OperationDescription *od = 0;
2217   desc->value >>= od;
2218
2219   if (this->debug_)
2220     {
2221       ACE_DEBUG ((LM_DEBUG,
2222                   ACE_TEXT ("OperationDef::describe::value::")
2223                   ACE_TEXT ("defined_in: %s\n"),
2224                   od->defined_in.in ()));
2225     }
2226
2227   ACE_TEST_ASSERT (ACE_OS::strcmp (od->defined_in, "IDL:p_iface:1.0") == 0);
2228
2229   CORBA::TypeCode_var result = od->result;
2230   CORBA::TCKind kind = result->kind ();
2231
2232   if (this->debug_)
2233     {
2234       ACE_DEBUG ((LM_DEBUG,
2235                   ACE_TEXT ("OperationDef::describe::result::")
2236                   ACE_TEXT ("kind: %d\n"),
2237                   kind));
2238     }
2239
2240   ACE_TEST_ASSERT (kind == CORBA::tk_long);
2241
2242   length = od->parameters.length ();
2243
2244   if (this->debug_)
2245     {
2246       ACE_DEBUG ((LM_DEBUG,
2247                   ACE_TEXT ("\nOperationDef::describe::parameters::")
2248                   ACE_TEXT ("length: %d\n"),
2249                   length));
2250     }
2251
2252   ACE_TEST_ASSERT (length == 3);
2253
2254   const char *tmp = 0;
2255
2256   for (i = 0; i < length; ++i)
2257     {
2258       tmp = od->parameters[i].name;
2259
2260       if (this->debug_)
2261         {
2262           ACE_DEBUG ((LM_DEBUG,
2263                       ACE_TEXT ("OperationDef::describe::parameters[%d]::")
2264                       ACE_TEXT ("name: %C\n"),
2265                       i,
2266                       tmp));
2267         }
2268
2269       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, names[i]) == 0);
2270
2271       if (this->debug_)
2272         {
2273           ACE_DEBUG ((LM_DEBUG,
2274                       ACE_TEXT ("OperationDef::describe::parameters[%d]::")
2275                       ACE_TEXT ("mode: %d\n"),
2276                       i,
2277                       od->parameters[i].mode));
2278         }
2279
2280       ACE_TEST_ASSERT (od->parameters[i].mode == modes[i]);
2281     }
2282
2283   CORBA::Boolean is_it = p_ivar->is_a ("IDL:p_iface:1.0");
2284
2285   if (this->debug_)
2286     {
2287       ACE_DEBUG ((LM_DEBUG,
2288                   ACE_TEXT ("\nInterfaceDef::is_a (same class): %hd\n"),
2289                   is_it));
2290     }
2291
2292   ACE_TEST_ASSERT (is_it == 1);
2293
2294   is_it = p_ivar->is_a ("IDL:gp_iface:1.0");
2295
2296   if (this->debug_)
2297     {
2298       ACE_DEBUG ((LM_DEBUG,
2299                   ACE_TEXT ("InterfaceDef::is_a (base class): %hd\n"),
2300                   is_it));
2301     }
2302
2303   ACE_TEST_ASSERT (is_it == 1);
2304
2305   is_it = gp_ivar->is_a ("IDL:p_iface:1.0");
2306
2307   if (this->debug_)
2308     {
2309       ACE_DEBUG ((LM_DEBUG,
2310                   ACE_TEXT ("InterfaceDef::is_a (derived class): %hd\n"),
2311                   is_it));
2312     }
2313
2314   ACE_TEST_ASSERT (is_it == 0);
2315
2316   CORBA::InterfaceDef::FullInterfaceDescription_var fifd =
2317     p_ivar->describe_interface ();
2318
2319   CORBA::String_var str = fifd->type->id ();
2320
2321   if (this->debug_)
2322     {
2323       ACE_DEBUG ((LM_DEBUG,
2324                   ACE_TEXT ("\nInterfaceDef::describe_interface::")
2325                   ACE_TEXT ("type::id: %C\n"),
2326                   str.in ()));
2327     }
2328
2329   ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "IDL:p_iface:1.0") == 0);
2330
2331   length = fifd->operations.length ();
2332
2333   if (this->debug_)
2334     {
2335       ACE_DEBUG ((LM_DEBUG,
2336                   ACE_TEXT ("\nInterfaceDef::describe_interface::")
2337                   ACE_TEXT ("operations::length: %d\n"),
2338                   length));
2339     }
2340
2341   ACE_TEST_ASSERT (length == 1);
2342
2343   length = fifd->operations[0].contexts.length ();
2344
2345   if (this->debug_)
2346     {
2347       ACE_DEBUG ((LM_DEBUG,
2348                   ACE_TEXT ("\nInterfaceDef::describe_interface::")
2349                   ACE_TEXT ("operations[3]::contexts::length: %d\n"),
2350                   length));
2351     }
2352
2353   ACE_TEST_ASSERT (length == 3);
2354
2355   for (i = 0; i < length; ++i)
2356     {
2357       tmp = fifd->operations[0].contexts[i];
2358
2359       if (this->debug_)
2360         {
2361           ACE_DEBUG ((LM_DEBUG,
2362                       ACE_TEXT ("InterfaceDef::describe_interface::")
2363                       ACE_TEXT ("operations[0]::contexts[%d]: %C\n"),
2364                       i,
2365                       tmp));
2366         }
2367
2368       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, contexts[i]) == 0);
2369     }
2370
2371   length = fifd->operations[0].exceptions.length ();
2372
2373   if (this->debug_)
2374     {
2375       ACE_DEBUG ((LM_DEBUG,
2376                   ACE_TEXT ("\nInterfaceDef::describe_interface::")
2377                   ACE_TEXT ("operations[0]::exceptions::length: %d\n"),
2378                   length));
2379     }
2380
2381   ACE_TEST_ASSERT (length == 1);
2382
2383   for (i = 0; i < length; ++i)
2384     {
2385       const char *tmp = fifd->operations[0].exceptions[i].name;
2386
2387       if (this->debug_)
2388         {
2389           ACE_DEBUG ((LM_DEBUG,
2390                       ACE_TEXT ("InterfaceDef::describe::operations[3]::")
2391                       ACE_TEXT ("contexts[%d]: %C\n"),
2392                       i,
2393                       tmp));
2394         }
2395
2396       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, "if_exception") == 0);
2397     }
2398
2399   tmp = fifd->attributes[0].defined_in;
2400
2401   if (this->debug_)
2402     {
2403       ACE_DEBUG ((LM_DEBUG,
2404                   ACE_TEXT ("\nInterfaceDef::describe_interface::")
2405                   ACE_TEXT ("attributes::defined_in: %C\n"),
2406                   tmp));
2407     }
2408
2409   ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, "IDL:gp_iface:1.0") == 0);
2410
2411   in_bases[0] = CORBA::InterfaceDef::_duplicate (p_ivar.in ());
2412
2413   CORBA::InterfaceDef_var ivar =
2414     this->repo_->create_interface ("IDL:iface:1.0",
2415                                    "iface",
2416                                    "1.0",
2417                                    in_bases);
2418
2419   desc = ivar->describe ();
2420
2421   const CORBA::InterfaceDescription *ifd = 0;
2422   desc->value >>= ifd;
2423
2424   length = ifd->base_interfaces.length ();
2425
2426   if (this->debug_)
2427     {
2428       ACE_DEBUG ((LM_DEBUG,
2429                   ACE_TEXT ("\nInterfaceDef::describe::")
2430                   ACE_TEXT ("base_interfaces::length: %d\n"),
2431                   length));
2432     }
2433
2434   ACE_TEST_ASSERT (length == 2);
2435
2436   const char *base_iface_id = 0;
2437
2438   for (i = 0; i < length; ++i)
2439     {
2440       base_iface_id = ifd->base_interfaces[i];
2441
2442       if (this->debug_)
2443         {
2444           ACE_DEBUG ((LM_DEBUG,
2445                       ACE_TEXT ("InterfaceDef::describe::")
2446                       ACE_TEXT ("base_interfaces[%d]: %C\n"),
2447                       i,
2448                       base_iface_id));
2449         }
2450     }
2451
2452   CORBA::InterfaceDefSeq_var out_bases =
2453     ivar->base_interfaces ();
2454
2455   length = out_bases->length ();
2456
2457   if (this->debug_)
2458     {
2459       ACE_DEBUG ((LM_DEBUG,
2460                   ACE_TEXT ("\nInterfaceDef::base_interfaces::length: %d\n"),
2461                   length));
2462     }
2463
2464   ACE_TEST_ASSERT (length == 2);
2465
2466   for (i = 0; i < length; ++i)
2467     {
2468       str = out_bases[i]->name ();
2469
2470       if (this->debug_)
2471         {
2472           ACE_DEBUG ((
2473               LM_DEBUG,
2474               ACE_TEXT ("InterfaceDef::base_interfaces[%d]::name: %C\n"),
2475               i,
2476               str.in ()
2477             ));
2478         }
2479     }
2480
2481   CORBA::ContainedSeq_var contents = ivar->contents (CORBA::dk_all,
2482                                                      0);
2483
2484   length = contents->length ();
2485
2486   if (this->debug_)
2487     {
2488       ACE_DEBUG ((LM_DEBUG,
2489                   ACE_TEXT ("\nInterfaceDef::contents::length: %d\n"),
2490                   length));
2491     }
2492
2493   ACE_TEST_ASSERT (length == 3);
2494
2495   for (i = 0; i < length; ++i)
2496     {
2497       str = contents[i]->name ();
2498
2499       if (this->debug_)
2500         {
2501           ACE_DEBUG ((LM_DEBUG,
2502                       ACE_TEXT ("InterfaceDef::contents[%d]::name: %C\n"),
2503                       i,
2504                       str.in ()));
2505         }
2506
2507       CORBA::Container_var cr =
2508         contents[i]->defined_in ();
2509
2510       CORBA::Contained_var cd =
2511         CORBA::Contained::_narrow (cr.in ());
2512
2513       str = cd->name ();
2514
2515       if (this->debug_)
2516         {
2517           ACE_DEBUG ((LM_DEBUG,
2518                       ACE_TEXT ("InterfaceDef::contents[%d]::")
2519                       ACE_TEXT ("defined_in::name: %C\n"),
2520                       i,
2521                       str.in ()));
2522         }
2523
2524       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "p_iface") == 0
2525                   || ACE_OS::strcmp (str.in (), "gp_iface") == 0);
2526     }
2527
2528   ex_var->destroy ();
2529   ivar->destroy ();
2530   gp_ivar->destroy ();
2531   p_ivar->destroy ();
2532 }
2533
2534 void
2535 Admin_Client::move_test ()
2536 {
2537   if (this->debug_)
2538     {
2539       ACE_DEBUG ((
2540           LM_DEBUG,
2541           ACE_TEXT ("\n============== MOVE TEST ==============\n\n")
2542         ));
2543     }
2544
2545   CORBA::EnumMemberSeq e_members (2);
2546   e_members.length (2);
2547
2548   e_members[0] = CORBA::string_dup ("ZERO");
2549   e_members[1] = CORBA::string_dup ("ONE");
2550
2551   CORBA::EnumDef_var e_var =
2552     this->repo_->create_enum ("IDL:o_enum:1.0",
2553                               "o_enum",
2554                               "1.0",
2555                               e_members);
2556
2557   e_members[0] = CORBA::string_dup ("TEN");
2558   e_members[1] = CORBA::string_dup ("ELEVEN");
2559
2560   CORBA::EnumDef_var e_var2 =
2561     this->repo_->create_enum ("IDL:i_enum:1.0",
2562                               "i_enum",
2563                               "1.0",
2564                               e_members);
2565
2566   CORBA::StructMemberSeq s_members (2);
2567   s_members.length (2);
2568
2569   const char *s_names[] = {"s_string", "s_enum"};
2570
2571   s_members[0].name = s_names[0];
2572   s_members[0].type_def =
2573     this->repo_->get_primitive (CORBA::pk_string);
2574   s_members[0].type =
2575     s_members[0].type_def->type ();
2576
2577   s_members[1].name = s_names[1];
2578   s_members[1].type_def = CORBA::EnumDef::_duplicate (e_var2.in ());
2579   s_members[1].type =
2580     s_members[1].type_def->type ();
2581
2582   CORBA::StructDef_var s_var =
2583     this->repo_->create_struct ("IDL:o_struct:1.0",
2584                                 "o_struct",
2585                                 "1.0",
2586                                 s_members);
2587
2588   CORBA::UnionMemberSeq u_members (2);
2589   u_members.length (2);
2590
2591   const char *u_names[] = {"u_enum", "u_struct"};
2592
2593   u_members[0].name = u_names[0];
2594   u_members[0].type_def = CORBA::EnumDef::_duplicate (e_var.in ());
2595   u_members[0].type = e_var->type ();
2596   CORBA::Long label = 0;
2597   CORBA::Any any;
2598   any <<= label;
2599   u_members[0].label = any;
2600
2601   u_members[1].name = u_names[1];
2602   u_members[1].type_def = CORBA::StructDef::_duplicate (s_var.in ());
2603   u_members[1].type = s_var->type ();
2604   label = 1;
2605   any <<= label;
2606   u_members[1].label = any;
2607
2608   CORBA::PrimitiveDef_var d_var =
2609     this->repo_->get_primitive (CORBA::pk_long);
2610
2611   CORBA::UnionDef_var u_var =
2612     this->repo_->create_union ("IDL:the_union:1.0",
2613                                "the_union",
2614                                "1.0",
2615                                d_var.in (),
2616                                u_members);
2617
2618   CORBA::UnionMemberSeq_var out_u_members =
2619     u_var->members ();
2620
2621   CORBA::ULong length = out_u_members->length ();
2622
2623   if (this->debug_)
2624     {
2625       ACE_DEBUG ((LM_DEBUG,
2626                   ACE_TEXT ("UnionDef::members::length: %d\n"),
2627                   length));
2628     }
2629
2630   ACE_TEST_ASSERT (length == 2);
2631
2632   CORBA::ULong i = 0;
2633   const char *tmp = 0;
2634
2635   for (i = 0; i < length; ++i)
2636     {
2637       tmp = out_u_members[i].name;
2638
2639       if (this->debug_)
2640         {
2641           ACE_DEBUG ((LM_DEBUG,
2642                       ACE_TEXT ("UnionDef::members[%d]::name: %C\n"),
2643                       i,
2644                       tmp));
2645         }
2646
2647       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, u_members[i].name) == 0);
2648     }
2649
2650   CORBA::ContainedSeq_var out_contents =
2651     u_var->contents (CORBA::dk_all,
2652                      1);
2653
2654   length = out_contents->length ();
2655
2656   if (this->debug_)
2657     {
2658       ACE_DEBUG ((LM_DEBUG,
2659                   ACE_TEXT ("\nUnionDef::contents::length: %d\n"),
2660                   length));
2661     }
2662
2663   ACE_TEST_ASSERT (length == 0);
2664
2665   e_var->move (u_var.in (),
2666                u_names[0],
2667                "1.0");
2668
2669   if (this->debug_)
2670     {
2671       ACE_DEBUG ((LM_DEBUG,
2672                   ACE_TEXT ("\nEnumDef::move (into union)\n")));
2673     }
2674
2675   out_u_members = u_var->members ();
2676
2677   length = out_u_members->length ();
2678
2679   if (this->debug_)
2680     {
2681       ACE_DEBUG ((LM_DEBUG,
2682                   ACE_TEXT ("\nUnionDef::members::length: %d\n"),
2683                   length));
2684     }
2685
2686   ACE_TEST_ASSERT (length == 2);
2687
2688   for (i = 0; i < length; ++i)
2689     {
2690       tmp = out_u_members[i].name;
2691
2692       if (this->debug_)
2693         {
2694           ACE_DEBUG ((LM_DEBUG,
2695                       ACE_TEXT ("UnionDef::members[%d]::name: %C\n"),
2696                       i,
2697                       tmp));
2698         }
2699
2700       if (i == 0)
2701         {
2702           ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, "u_enum") == 0);
2703         }
2704       else
2705         {
2706           ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, u_members[i].name) == 0);
2707         }
2708     }
2709
2710   out_contents = u_var->contents (CORBA::dk_all,
2711                                   1);
2712
2713   length = out_contents->length ();
2714
2715   if (this->debug_)
2716     {
2717       ACE_DEBUG ((LM_DEBUG,
2718                   ACE_TEXT ("\nUnionDef::contents::length: %d\n"),
2719                   length));
2720     }
2721
2722   ACE_TEST_ASSERT (length == 1);
2723
2724   CORBA::String_var str;
2725
2726   for (i = 0; i < length; ++i)
2727     {
2728       str = out_contents[i]->absolute_name ();
2729
2730       if (this->debug_)
2731         {
2732           ACE_DEBUG ((
2733               LM_DEBUG,
2734               ACE_TEXT ("UnionDef::contents[%d]::absolute_name: %C\n"),
2735               i,
2736               str.in ()
2737             ));
2738         }
2739
2740       if (i == 0)
2741         {
2742           ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::the_union::u_enum") == 0);
2743         }
2744     }
2745
2746   e_var2->move (s_var.in (),
2747                 s_names[1],
2748                 "1.0");
2749
2750   s_var->move (u_var.in (),
2751                u_names[1],
2752                "1.0");
2753
2754   if (this->debug_)
2755     {
2756       ACE_DEBUG ((LM_DEBUG,
2757                   ACE_TEXT ("\nEnumDef::move (into struct)\n")
2758                   ACE_TEXT ("StructDef::move (into union)\n")));
2759     }
2760
2761   out_contents = this->repo_->contents (CORBA::dk_all,
2762                                         1);
2763
2764   length = out_contents->length ();
2765
2766   if (this->debug_)
2767     {
2768       ACE_DEBUG ((LM_DEBUG,
2769                   ACE_TEXT ("\nRepository::contents::length: %d\n"),
2770                   length));
2771     }
2772
2773   ACE_TEST_ASSERT (length == 1);
2774
2775   out_u_members = u_var->members ();
2776
2777   length = out_u_members->length ();
2778
2779   if (this->debug_)
2780     {
2781       ACE_DEBUG ((LM_DEBUG,
2782                   ACE_TEXT ("\nUnionDef::members::length: %d\n"),
2783                   length));
2784     }
2785
2786   ACE_TEST_ASSERT (length == 2);
2787
2788   for (i = 0; i < length; ++i)
2789     {
2790       tmp = out_u_members[i].name;
2791
2792       if (this->debug_)
2793         {
2794           ACE_DEBUG ((LM_DEBUG,
2795                       ACE_TEXT ("UnionDef::members[%d]::name: %C\n"),
2796                       i,
2797                       tmp));
2798         }
2799
2800       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, u_names[i]) == 0);
2801     }
2802
2803   out_contents = u_var->contents (CORBA::dk_all,
2804                                   1);
2805
2806   length = out_contents->length ();
2807
2808   if (this->debug_)
2809     {
2810       ACE_DEBUG ((LM_DEBUG,
2811                   ACE_TEXT ("\nUnionDef::contents::length: %d\n"),
2812                   length));
2813     }
2814
2815   ACE_TEST_ASSERT (length == 2);
2816
2817   ACE_CString scoped ("::the_union::");
2818   CORBA::StructDef_var s_tmp;
2819   int cmp_result = 0;
2820
2821   for (i = 0; i < length; ++i)
2822     {
2823       str = out_contents[i]->absolute_name ();
2824
2825       if (this->debug_)
2826         {
2827           ACE_DEBUG ((LM_DEBUG,
2828                       ACE_TEXT ("UnionDef::contents[%d]::absolute_name: %C\n"),
2829                       i,
2830                       str.in ()));
2831         }
2832
2833       cmp_result =
2834         ACE_OS::strcmp (str.in (), (scoped + u_names[i]).c_str ());
2835
2836       ACE_TEST_ASSERT (cmp_result == 0);
2837
2838       if (i == 1)
2839         {
2840           s_tmp = CORBA::StructDef::_narrow (out_contents[i]);
2841         }
2842     }
2843
2844   out_contents = s_tmp->contents (CORBA::dk_all,
2845                                   0);
2846
2847   length = out_contents->length ();
2848
2849   if (this->debug_)
2850     {
2851       ACE_DEBUG ((LM_DEBUG,
2852                   ACE_TEXT ("\nStructDef::contents::length: %d\n"),
2853                   length));
2854     }
2855
2856   ACE_TEST_ASSERT (length == 1);
2857
2858   const char *base = "::the_union::u_struct";
2859
2860   for (i = 0; i < length; ++i)
2861     {
2862       str = out_contents[i]->absolute_name ();
2863
2864       if (this->debug_)
2865         {
2866           ACE_DEBUG ((LM_DEBUG,
2867                       ACE_TEXT ("StructDef::contents[%d]::absolute_name: %C\n"),
2868                       i,
2869                       str.in ()));
2870         }
2871
2872       cmp_result =
2873         ACE_OS::strncmp (str.in (), base, ACE_OS::strlen (base));
2874
2875       ACE_TEST_ASSERT (cmp_result == 0);
2876     }
2877
2878 #if defined (ACE_NDEBUG)
2879   // ACE_TEST_ASSERT macro expands to nothing, so...
2880   ACE_UNUSED_ARG (base);
2881 #endif /* ACE_NDEBUG */
2882
2883   CORBA::StructMemberSeq_var out_s_members =
2884     s_tmp->members ();
2885
2886   length = out_s_members->length ();
2887
2888   if (this->debug_)
2889     {
2890       ACE_DEBUG ((LM_DEBUG,
2891                   ACE_TEXT ("\nStructDef::members::length: %d\n"),
2892                   length));
2893     }
2894
2895   ACE_TEST_ASSERT (length == 2);
2896
2897   for (i = 0; i < length; ++i)
2898     {
2899       tmp = out_s_members[i].name;
2900
2901       if (this->debug_)
2902         {
2903           ACE_DEBUG ((LM_DEBUG,
2904                       ACE_TEXT ("StructDef::members[%d]::name: %C\n"),
2905                       i,
2906                       tmp));
2907         }
2908
2909       ACE_TEST_ASSERT (ACE_OS::strcmp (tmp, s_names[i]) == 0);
2910    }
2911
2912   u_var->destroy ();
2913 }
2914
2915 void
2916 Admin_Client::module_test ()
2917 {
2918   if (this->debug_)
2919     {
2920       ACE_DEBUG ((
2921           LM_DEBUG,
2922           ACE_TEXT ("\n============== MODULE TEST ==============\n\n")
2923         ));
2924     }
2925
2926   CORBA::ModuleDef_var outer =
2927     this->repo_->create_module ("IDL:outer:1.0",
2928                                 "outer",
2929                                 "1.0");
2930
2931   CORBA::ModuleDef_var middle =
2932     outer->create_module ("IDL:outer/middle:1.0",
2933                           "middle",
2934                           "1.0");
2935
2936   CORBA::ModuleDef_var inner =
2937     middle->create_module ("IDL:outer/middle/inner:1.0",
2938                            "inner",
2939                            "1.0");
2940
2941   CORBA::InterfaceDefSeq in_bases (1);
2942   in_bases.length (0);
2943
2944   CORBA::InterfaceDef_var p_iface =
2945     outer->create_interface ("IDL:p_iface:1.0",
2946                              "p_iface",
2947                              "1.0",
2948                              in_bases);
2949
2950   in_bases.length (1);
2951   in_bases[0] = CORBA::InterfaceDef::_duplicate (p_iface.in ());
2952
2953   CORBA::InterfaceDef_var iface =
2954     inner->create_interface ("IDL:iface:1.0",
2955                              "iface",
2956                              "1.0",
2957                              in_bases);
2958
2959   CORBA::PrimitiveDef_var p_void =
2960     this->repo_->get_primitive (CORBA::pk_void);
2961   CORBA::PrimitiveDef_var p_long =
2962     this->repo_->get_primitive (CORBA::pk_long);
2963
2964   CORBA::AttributeDef_var attr =
2965     p_iface->create_attribute ("IDL:iface/attr:1.0",
2966                                "attr",
2967                                "1.0",
2968                                p_void.in (),
2969                                CORBA::ATTR_NORMAL);
2970
2971   CORBA::ULong length = 3;
2972   CORBA::ULong i = 0;
2973
2974   CORBA::ParDescriptionSeq par_seq (length);
2975   par_seq.length (length);
2976
2977   CORBA::ContextIdSeq con_seq (length);
2978   con_seq.length (length);
2979
2980   const char *p_names[] = {"inarg", "outarg", "inoutarg"};
2981   const char *contexts[] = {"straw", "sticks", "bricks"};
2982
2983   for (i = 0; i < length; ++i)
2984     {
2985       par_seq[i].name = p_names[i];
2986       par_seq[i].type_def = CORBA::PrimitiveDef::_duplicate (p_long.in ());
2987       par_seq[i].type = p_long->type ();
2988       par_seq[i].mode = static_cast<CORBA::ParameterMode> (i);
2989
2990       con_seq[i] = contexts[i];
2991     }
2992
2993   CORBA::StructMemberSeq members (0);
2994   members.length (0);
2995
2996   CORBA::ExceptionDef_var ex_var =
2997     this->repo_->create_exception ("IDL:if_exception:1.0",
2998                                    "if_exception",
2999                                    "1.0",
3000                                    members);
3001
3002   CORBA::ExceptionDefSeq get_seq (1);
3003   get_seq.length (1);
3004   get_seq[0] = CORBA::ExceptionDef::_duplicate (ex_var.in ());
3005
3006   CORBA::OperationDef_var op =
3007     iface->create_operation ("IDL:iface/op:1.0",
3008                              "op",
3009                              "1.0",
3010                              p_void.in (),
3011                              CORBA::OP_NORMAL,
3012                              par_seq,
3013                              get_seq,
3014                              con_seq);
3015
3016   CORBA::String_var str;
3017
3018   CORBA::Contained_var result =
3019     inner->lookup ("::outer::middle::inner::iface::op");
3020
3021   str = result->absolute_name ();
3022
3023   if (this->debug_)
3024     {
3025       ACE_DEBUG ((
3026           LM_DEBUG,
3027           ACE_TEXT ("ModuleDef::lookup (absolute)::absolute_name: %C\n"),
3028           str.in ()
3029         ));
3030     }
3031
3032   int cmp_result =
3033     ACE_OS::strcmp (str.in (), "::outer::middle::inner::iface::op");
3034
3035   ACE_TEST_ASSERT (cmp_result == 0);
3036
3037   result = middle->lookup ("inner::iface::op");
3038
3039   str = result->absolute_name ();
3040
3041   if (this->debug_)
3042     {
3043       ACE_DEBUG ((
3044           LM_DEBUG,
3045           ACE_TEXT ("ModuleDef::lookup (relative)::absolute_name: %C\n"),
3046           str.in ()
3047         ));
3048     }
3049
3050   cmp_result =
3051     ACE_OS::strcmp (str.in (), "::outer::middle::inner::iface::op");
3052
3053   ACE_TEST_ASSERT (cmp_result == 0);
3054
3055   CORBA::ContainedSeq_var cseq =
3056     this->repo_->lookup_name ("op",
3057                               -1,
3058                               CORBA::dk_all,
3059                               0);
3060
3061   length = cseq->length ();
3062
3063   if (this->debug_)
3064     {
3065       ACE_DEBUG ((LM_DEBUG,
3066                   ACE_TEXT ("Repository::lookup_name::length: %d\n"),
3067                   length));
3068     }
3069
3070   ACE_TEST_ASSERT (length == 1);
3071
3072   for (i = 0; i < length; ++i)
3073     {
3074       str = cseq[i]->absolute_name ();
3075
3076       if (this->debug_)
3077         {
3078           ACE_DEBUG ((
3079               LM_DEBUG,
3080               ACE_TEXT ("Repository::lookup_name[%d]::absolute_name: %C\n"),
3081               i,
3082               str.in ()
3083             ));
3084         }
3085
3086       cmp_result =
3087         ACE_OS::strcmp (str.in (), "::outer::middle::inner::iface::op");
3088
3089       ACE_TEST_ASSERT (cmp_result == 0);
3090     }
3091
3092   cseq = middle->lookup_name ("attr",
3093                               3,
3094                               CORBA::dk_Attribute,
3095                               0);
3096
3097   length = cseq->length ();
3098
3099   if (this->debug_)
3100     {
3101       ACE_DEBUG ((LM_DEBUG,
3102                   ACE_TEXT ("Repository::lookup_name::length: %d\n"),
3103                   length));
3104     }
3105
3106   ACE_TEST_ASSERT (length == 1);
3107
3108   for (i = 0; i < length; ++i)
3109     {
3110       str = cseq[i]->absolute_name ();
3111
3112       if (this->debug_)
3113         {
3114           ACE_DEBUG ((
3115               LM_DEBUG,
3116               ACE_TEXT ("Repository::lookup_name[%d]::absolute_name: %C\n"),
3117               i,
3118               str.in ()
3119             ));
3120         }
3121
3122       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::outer::p_iface::attr") == 0);
3123     }
3124
3125   iface->move (outer.in (),
3126                "iface",
3127                "1.0");
3128
3129   if (this->debug_)
3130     {
3131       ACE_DEBUG ((LM_DEBUG,
3132                   ACE_TEXT ("\nInterfaceDef::move (into outer module)\n")));
3133     }
3134
3135   cseq = this->repo_->lookup_name ("op",
3136                                    -1,
3137                                    CORBA::dk_all,
3138                                    0);
3139
3140   length = cseq->length ();
3141
3142   if (this->debug_)
3143     {
3144       ACE_DEBUG ((LM_DEBUG,
3145                   ACE_TEXT ("Repository::lookup_name::length: %d\n"),
3146                   length));
3147     }
3148
3149   ACE_TEST_ASSERT (length == 1);
3150
3151   for (i = 0; i < length; ++i)
3152     {
3153       str = cseq[i]->absolute_name ();
3154
3155       if (this->debug_)
3156         {
3157           ACE_DEBUG ((
3158               LM_DEBUG,
3159               ACE_TEXT ("Repository::lookup_name[%d]::absolute_name: %C\n"),
3160               i,
3161               str.in ()
3162             ));
3163         }
3164
3165       ACE_TEST_ASSERT (ACE_OS::strcmp (str.in (), "::outer::iface::op") == 0);
3166     }
3167
3168   ex_var->destroy ();
3169   outer->destroy ();
3170 }