TAO/tests/RTCORBA/Collocation/Collocation.cpp

   1 #include "ace/Get_Opt.h"
   2 #include "ace/Array_Base.h"
   3 #include "ace/Task.h"
   4 #include "tao/ORB_Core.h"
   5 #include "tao/RTCORBA/Thread_Pool.h"
   6 #include "testS.h"
   7 #include "tao/RTPortableServer/RTPortableServer.h"
   8 #include "../check_supported_priorities.cpp"
   9
  10 RTCORBA::Priority default_thread_priority;
  11
  12 class test_i;
  13
  14 struct Test_Object_And_Servant
  15 {
  16   test_var object_;
  17   test_i *servant_;
  18 };
  19
  20 typedef ACE_Array_Base<Test_Object_And_Servant> Tests;
  21
  22 void
  23 setup_test_parameters (Test_Object_And_Servant *test,
  24                        RTCORBA::Current_ptr current,
  25                        CORBA::ORB_ptr orb);
  26 class test_i :
  27   public POA_test
  28 {
  29 public:
  30   test_i (CORBA::ORB_ptr orb,
  31           PortableServer::POA_ptr poa,
  32           Tests &tests);
  33
  34   void start ();
  35
  36   void method ();
  37
  38   PortableServer::POA_ptr _default_POA ();
  39
  40   int client_propagated ();
  41
  42   void client_propagated (int);
  43
  44   int server_declared ();
  45
  46   void server_declared (int);
  47
  48   RTCORBA::Priority server_priority ();
  49
  50   void server_priority (RTCORBA::Priority);
  51
  52   int in_lane ();
  53
  54   void in_lane (int);
  55
  56   int serviced_by_rt_tp ();
  57
  58   void serviced_by_rt_tp (int);
  59
  60   void thread_info (const char *method_name);
  61
  62   void invocation_pool_and_lane (CORBA::ULong pool,
  63                                  CORBA::ULong lane);
  64
  65   void invocation_pool (CORBA::ULong pool);
  66
  67   void invocation_lane (CORBA::ULong lane);
  68
  69   RTCORBA::Priority invocation_priority ();
  70
  71   void invocation_priority (RTCORBA::Priority);
  72
  73 private:
  74   CORBA::ORB_var orb_;
  75   PortableServer::POA_var poa_;
  76   Tests &tests_;
  77
  78   int client_propagated_;
  79   int server_declared_;
  80   RTCORBA::Priority server_priority_;
  81   int in_lane_;
  82   int serviced_by_rt_tp_;
  83
  84   CORBA::ULong pool_;
  85   CORBA::ULong lane_;
  86   RTCORBA::Priority invocation_priority_;
  87
  88   RTCORBA::Current_var current_;
  89 };
  90
  91 test_i::test_i (CORBA::ORB_ptr orb,
  92                 PortableServer::POA_ptr poa,
  93                 Tests &tests)
  94   : orb_ (CORBA::ORB::_duplicate (orb)),
  95     poa_ (PortableServer::POA::_duplicate (poa)),
  96     tests_ (tests),
  97     client_propagated_ (0),
  98     server_declared_ (0),
  99     server_priority_ (0),
 100     serviced_by_rt_tp_ (1),
 101     invocation_priority_ (0)
 102 {
 103   CORBA::Object_var object =
 104     this->orb_->resolve_initial_references ("RTCurrent");
 105
 106   this->current_ =
 107     RTCORBA::Current::_narrow (object.in ());
 108 }
 109
 110 int
 111 test_i::client_propagated ()
 112 {
 113   return this->client_propagated_;
 114 }
 115
 116 void
 117 test_i::client_propagated (int client_propagated)
 118 {
 119   this->client_propagated_ = client_propagated;
 120 }
 121
 122 int
 123 test_i::server_declared ()
 124 {
 125   return this->server_declared_;
 126 }
 127
 128 void
 129 test_i::server_declared (int server_declared)
 130 {
 131   this->server_declared_ = server_declared;
 132 }
 133
 134 RTCORBA::Priority
 135 test_i::server_priority ()
 136 {
 137   return this->server_priority_;
 138 }
 139
 140 void
 141 test_i::server_priority (RTCORBA::Priority server_priority)
 142 {
 143   this->server_priority_ = server_priority;
 144 }
 145
 146 int
 147 test_i::in_lane ()
 148 {
 149   return this->in_lane_;
 150 }
 151
 152 void
 153 test_i::in_lane (int in_lane)
 154 {
 155   this->in_lane_ = in_lane;
 156 }
 157
 158 int
 159 test_i::serviced_by_rt_tp ()
 160 {
 161   return this->serviced_by_rt_tp_;
 162 }
 163
 164 void
 165 test_i::serviced_by_rt_tp (int serviced_by_rt_tp)
 166 {
 167   this->serviced_by_rt_tp_ = serviced_by_rt_tp;
 168 }
 169
 170 void
 171 test_i::invocation_pool_and_lane (CORBA::ULong pool,
 172                                   CORBA::ULong lane)
 173 {
 174   this->pool_ = pool;
 175   this->lane_ = lane;
 176 }
 177
 178 void
 179 test_i::invocation_pool (CORBA::ULong pool)
 180 {
 181   this->pool_ = pool;
 182 }
 183
 184 void
 185 test_i::invocation_lane (CORBA::ULong lane)
 186 {
 187   this->lane_ = lane;
 188 }
 189
 190 RTCORBA::Priority
 191 test_i::invocation_priority ()
 192 {
 193   return this->invocation_priority_;
 194 }
 195
 196 void
 197 test_i::invocation_priority (RTCORBA::Priority invocation_priority)
 198 {
 199   this->invocation_priority_ = invocation_priority;
 200 }
 201
 202 void
 203 test_i::start ()
 204 {
 205   ACE_DEBUG ((LM_DEBUG,
 206               "\n"));
 207
 208   this->thread_info ("test_i::start");
 209
 210   ACE_DEBUG ((LM_DEBUG,
 211               "\n"));
 212
 213   Tests::ITERATOR iterator (this->tests_);
 214   while (!iterator.done ())
 215     {
 216       Test_Object_And_Servant *test = 0;
 217       iterator.next (test);
 218
 219       setup_test_parameters (test,
 220                              this->current_.in (),
 221                              this->orb_.in ());
 222
 223       test->object_->method ();
 224
 225       CORBA::String_var ior =
 226         this->orb_->object_to_string (test->object_.in ());
 227
 228       CORBA::Object_var object =
 229         this->orb_->string_to_object (ior.in ());
 230
 231       test_var test_from_string =
 232         test::_narrow (object.in ());
 233
 234       test_from_string->method ();
 235
 236       iterator.advance ();
 237     }
 238 }
 239
 240 void
 241 test_i::thread_info (const char *method_name)
 242 {
 243   // Get the ORB_Core's TSS resources.
 244   TAO_ORB_Core_TSS_Resources *tss =
 245     this->orb_->orb_core ()->get_tss_resources ();
 246
 247   /// Get the lane attribute in TSS.
 248     TAO_Thread_Lane *lane =
 249       (TAO_Thread_Lane *) tss->lane_;
 250
 251     if (lane)
 252       {
 253         ACE_DEBUG ((LM_DEBUG,
 254                     "(%t) %s (pool = %d; lane = %d); priority = %d (should be %d)\n",
 255                     method_name,
 256                     lane->pool ().id (),
 257                     lane->id (),
 258                     this->current_->the_priority (),
 259                     this->invocation_priority ()));
 260
 261         ACE_ASSERT (this->pool_ == lane->pool ().id ());
 262         ACE_ASSERT (this->lane_ == lane->id ());
 263         ACE_ASSERT (this->current_->the_priority () ==
 264                     this->invocation_priority ());
 265       }
 266     else
 267       {
 268         ACE_DEBUG ((LM_DEBUG,
 269                     "(%t) %s (default thread pool); priority = %d (should be %d)\n",
 270                     method_name,
 271                     this->current_->the_priority (),
 272                     this->invocation_priority ()));
 273
 274         ACE_ASSERT (this->pool_ == 0);
 275         ACE_ASSERT (this->lane_ == 0);
 276         ACE_ASSERT (this->current_->the_priority () ==
 277                     this->invocation_priority ());
 278       }
 279 }
 280
 281 void
 282 test_i::method ()
 283 {
 284   this->thread_info ("test_i::method");
 285 }
 286
 287 PortableServer::POA_ptr
 288 test_i::_default_POA ()
 289 {
 290   return PortableServer::POA::_duplicate (this->poa_.in ());
 291 }
 292
 293 void
 294 setup_test_parameters (Test_Object_And_Servant *test,
 295                        RTCORBA::Current_ptr current,
 296                        CORBA::ORB_ptr orb)
 297 {
 298   CORBA::Short current_thread_priority;
 299
 300   try
 301     {
 302       current_thread_priority =
 303         current->the_priority ();
 304     }
 305   catch (const CORBA::INITIALIZE&)
 306     {
 307       try
 308         {
 309           current_thread_priority = get_implicit_thread_CORBA_priority (orb);
 310         }
 311       catch (const CORBA::Exception &ex)
 312         {
 313           ex._tao_print_exception ("Exception in ::setup_test_parameters calling ::get_implicit_thread_CORBA_priority: ");
 314           throw;
 315         }
 316     }
 317   catch (const CORBA::Exception& dc)
 318     {
 319       dc._tao_print_exception ("Exception in ::setup_test_parameters calling current->the_priority(): ");
 320       throw;
 321     }
 322
 323    current->the_priority (current_thread_priority);
 324
 325   if (!test->servant_->serviced_by_rt_tp () ||
 326       test->servant_->client_propagated ())
 327     {
 328       test->servant_->invocation_priority (current_thread_priority);
 329     }
 330   else if (test->servant_->server_declared ())
 331     {
 332       test->servant_->invocation_priority (test->servant_->server_priority ());
 333     }
 334   else
 335     {
 336       test->servant_->invocation_priority (default_thread_priority);
 337     }
 338
 339   if (test->servant_->client_propagated () &&
 340       test->servant_->in_lane ())
 341     {
 342       if (current_thread_priority == default_thread_priority)
 343         test->servant_->invocation_lane (0);
 344       else
 345         test->servant_->invocation_lane (1);
 346     }
 347
 348   if (!test->servant_->serviced_by_rt_tp ())
 349     {
 350       // Get the ORB_Core's TSS resources.
 351       TAO_ORB_Core_TSS_Resources *tss =
 352         orb->orb_core ()->get_tss_resources ();
 353
 354       /// Get the lane attribute in TSS.
 355         TAO_Thread_Lane *lane =
 356           (TAO_Thread_Lane *) tss->lane_;
 357
 358         if (lane)
 359           {
 360             test->servant_->invocation_pool_and_lane (lane->pool ().id (),
 361                                                       lane->id ());
 362           }
 363         else
 364           {
 365             test->servant_->invocation_pool_and_lane (0, 0);
 366           }
 367     }
 368 }
 369
 370 class Server
 371 {
 372 public:
 373   Server (CORBA::ORB_ptr orb);
 374
 375   void create_servant_in_root_poa ();
 376   void create_poa_and_servant_with_tp_policy (const char *poa_name,
 377                                               int set_priority_model,
 378                                               RTCORBA::PriorityModel priority_model);
 379   void create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name,
 380                                                          RTCORBA::PriorityModel priority_model);
 381   void test ();
 382   void start_testing ();
 383
 384   //FUZZ: disable check_for_lack_ACE_OS
 385   void shutdown ();
 386   //FUZZ: enable check_for_lack_ACE_OS
 387
 388   CORBA::ORB_var orb_;
 389   RTCORBA::RTORB_var rt_orb_;
 390   PortableServer::POA_var root_poa_;
 391   PortableServer::POAManager_var poa_manager_;
 392   RTCORBA::Current_var current_;
 393
 394   Tests tests_;
 395
 396   CORBA::ULong stacksize_;
 397   CORBA::ULong static_threads_;
 398   CORBA::ULong dynamic_threads_;
 399   CORBA::Boolean allow_request_buffering_;
 400   CORBA::Boolean allow_borrowing_;
 401   CORBA::ULong max_buffered_requests_;
 402   CORBA::ULong max_request_buffer_size_;
 403 };
 404
 405 Server::Server (CORBA::ORB_ptr orb)
 406   : orb_ (CORBA::ORB::_duplicate (orb)),
 407     stacksize_ (0),
 408     static_threads_ (1),
 409     dynamic_threads_ (0),
 410     allow_request_buffering_ (0),
 411     allow_borrowing_ (0),
 412     max_buffered_requests_ (0),
 413     max_request_buffer_size_ (0)
 414 {
 415   CORBA::Object_var object =
 416     this->orb_->resolve_initial_references ("RTORB");
 417
 418   this->rt_orb_ =
 419     RTCORBA::RTORB::_narrow (object.in ());
 420
 421   object =
 422     this->orb_->resolve_initial_references ("RTCurrent");
 423
 424   this->current_ =
 425     RTCORBA::Current::_narrow (object.in ());
 426
 427   default_thread_priority =
 428     get_implicit_thread_CORBA_priority (this->orb_.in ());
 429
 430   object =
 431     this->orb_->resolve_initial_references ("RootPOA");
 432
 433   this->root_poa_ =
 434     PortableServer::POA::_narrow (object.in ());
 435
 436   this->poa_manager_ =
 437     this->root_poa_->the_POAManager ();
 438
 439   this->poa_manager_->activate ();
 440 }
 441
 442 void
 443 Server::create_servant_in_root_poa ()
 444 {
 445   test_i *servant = 0;
 446   ACE_NEW_THROW_EX (servant,
 447                     test_i (this->orb_.in (),
 448                             this->root_poa_.in (),
 449                             this->tests_),
 450                     CORBA::NO_MEMORY ());
 451
 452   servant->invocation_pool_and_lane (0, 0);
 453   servant->in_lane (0);
 454   servant->serviced_by_rt_tp (0);
 455
 456   PortableServer::ServantBase_var safe_servant (servant);
 457
 458   this->tests_.size (this->tests_.size () + 1);
 459   this->tests_[this->tests_.size () - 1].servant_ =
 460     servant;
 461   this->tests_[this->tests_.size () - 1].object_ =
 462     servant->_this ();
 463 }
 464
 465 void
 466 Server::create_poa_and_servant_with_tp_policy (const char *poa_name,
 467                                                int set_priority_model,
 468                                                RTCORBA::PriorityModel priority_model)
 469 {
 470   RTCORBA::ThreadpoolId threadpool_id =
 471     this->rt_orb_->create_threadpool (this->stacksize_,
 472                                       this->static_threads_,
 473                                       this->dynamic_threads_,
 474                                       default_thread_priority,
 475                                       this->allow_request_buffering_,
 476                                       this->max_buffered_requests_,
 477                                       this->max_request_buffer_size_);
 478
 479   CORBA::Policy_var threadpool_policy =
 480     this->rt_orb_->create_threadpool_policy (threadpool_id);
 481
 482   CORBA::Policy_var priority_model_policy =
 483     this->rt_orb_->create_priority_model_policy (priority_model,
 484                                                  default_thread_priority);
 485
 486   CORBA::PolicyList policies;
 487
 488   policies.length (policies.length () + 1);
 489   policies[policies.length () - 1] =
 490     threadpool_policy;
 491
 492   if (set_priority_model)
 493     {
 494       policies.length (policies.length () + 1);
 495       policies[policies.length () - 1] =
 496         priority_model_policy;
 497     }
 498
 499   PortableServer::POA_var poa =
 500     this->root_poa_->create_POA (poa_name,
 501                                  this->poa_manager_.in (),
 502                                  policies);
 503
 504   RTPortableServer::POA_var rt_poa =
 505     RTPortableServer::POA::_narrow (poa.in ());
 506
 507   test_i *servant1 = 0;
 508   ACE_NEW_THROW_EX (servant1,
 509                     test_i (this->orb_.in (),
 510                             poa.in (),
 511                             this->tests_),
 512                     CORBA::NO_MEMORY ());
 513
 514   servant1->in_lane (0);
 515
 516   PortableServer::ObjectId_var id1;
 517
 518   if (set_priority_model)
 519     {
 520       if (priority_model == RTCORBA::CLIENT_PROPAGATED)
 521         {
 522           servant1->invocation_pool_and_lane (1, 0);
 523           servant1->client_propagated (1);
 524
 525           id1 =
 526             rt_poa->activate_object (servant1);
 527         }
 528       else
 529         {
 530           test_i *servant2 = 0;
 531
 532           ACE_NEW_THROW_EX (servant2,
 533                             test_i (this->orb_.in (),
 534                                     poa.in (),
 535                                     this->tests_),
 536                             CORBA::NO_MEMORY ());
 537
 538           servant2->in_lane (0);
 539
 540           PortableServer::ServantBase_var safe_servant2 (servant2);
 541
 542           PortableServer::ObjectId_var id2;
 543
 544           servant1->invocation_pool_and_lane (2, 0);
 545           servant2->invocation_pool_and_lane (2, 0);
 546           servant1->server_declared (1);
 547           servant2->server_declared (1);
 548           servant1->server_priority (default_thread_priority + 1);
 549           servant2->server_priority (default_thread_priority);
 550
 551           id1 =
 552             rt_poa->activate_object_with_priority (servant1,
 553                                                    default_thread_priority + 1);
 554
 555           id2 =
 556             rt_poa->activate_object_with_priority (servant2,
 557                                                    default_thread_priority);
 558
 559           CORBA::Object_var object2 =
 560             poa->id_to_reference (id2.in ());
 561
 562           this->tests_.size (this->tests_.size () + 1);
 563           this->tests_[this->tests_.size () - 1].object_ =
 564             test::_narrow (object2.in ());
 565           this->tests_[this->tests_.size () - 1].servant_ =
 566             servant2;
 567         }
 568     }
 569   else
 570     {
 571       servant1->invocation_pool_and_lane (3, 0);
 572
 573       id1 =
 574         rt_poa->activate_object (servant1);
 575     }
 576
 577   PortableServer::ServantBase_var safe_servant (servant1);
 578
 579   CORBA::Object_var object1 =
 580     poa->id_to_reference (id1.in ());
 581
 582   this->tests_.size (this->tests_.size () + 1);
 583   this->tests_[this->tests_.size () - 1].object_ =
 584     test::_narrow (object1.in ());
 585   this->tests_[this->tests_.size () - 1].servant_ =
 586     servant1;
 587 }
 588
 589 void
 590 Server::create_poa_and_servant_with_tp_with_lanes_policy (const char *poa_name,
 591                                                           RTCORBA::PriorityModel priority_model)
 592 {
 593   RTCORBA::ThreadpoolLanes lanes (2);
 594   lanes.length (2);
 595
 596   lanes[0].lane_priority = default_thread_priority;
 597   lanes[0].static_threads = this->static_threads_;
 598   lanes[0].dynamic_threads = this->dynamic_threads_;
 599
 600   lanes[1].lane_priority = default_thread_priority + 1;
 601   lanes[1].static_threads = this->static_threads_;
 602   lanes[1].dynamic_threads = this->dynamic_threads_;
 603
 604   RTCORBA::ThreadpoolId threadpool_id =
 605     this->rt_orb_->create_threadpool_with_lanes (this->stacksize_,
 606                                                  lanes,
 607                                                  this->allow_borrowing_,
 608                                                  this->allow_request_buffering_,
 609                                                  this->max_buffered_requests_,
 610                                                  this->max_request_buffer_size_);
 611
 612   CORBA::Policy_var threadpool_policy =
 613     this->rt_orb_->create_threadpool_policy (threadpool_id);
 614
 615   CORBA::Policy_var priority_model_policy =
 616     this->rt_orb_->create_priority_model_policy (priority_model,
 617                                                  default_thread_priority);
 618
 619   CORBA::PolicyList policies;
 620
 621   policies.length (policies.length () + 1);
 622   policies[policies.length () - 1] =
 623     threadpool_policy;
 624
 625   policies.length (policies.length () + 1);
 626   policies[policies.length () - 1] =
 627     priority_model_policy;
 628
 629   PortableServer::POA_var poa =
 630     this->root_poa_->create_POA (poa_name,
 631                                  this->poa_manager_.in (),
 632                                  policies);
 633
 634   RTPortableServer::POA_var rt_poa =
 635     RTPortableServer::POA::_narrow (poa.in ());
 636
 637   test_i *servant1 = 0;
 638   ACE_NEW_THROW_EX (servant1,
 639                     test_i (this->orb_.in (),
 640                             poa.in (),
 641                             this->tests_),
 642                     CORBA::NO_MEMORY ());
 643
 644   servant1->in_lane (1);
 645
 646   PortableServer::ServantBase_var safe_servant1 (servant1);
 647
 648   PortableServer::ObjectId_var id1;
 649
 650   if (priority_model == RTCORBA::CLIENT_PROPAGATED)
 651     {
 652       servant1->invocation_pool (4);
 653       servant1->client_propagated (1);
 654
 655       id1 =
 656         rt_poa->activate_object (servant1);
 657     }
 658   else
 659     {
 660       test_i *servant2 = 0;
 661
 662       ACE_NEW_THROW_EX (servant2,
 663                         test_i (this->orb_.in (),
 664                                 poa.in (),
 665                                 this->tests_),
 666                         CORBA::NO_MEMORY ());
 667
 668       servant2->in_lane (1);
 669
 670       PortableServer::ServantBase_var safe_servant2 (servant2);
 671
 672       PortableServer::ObjectId_var id2;
 673
 674       servant1->invocation_pool_and_lane (5, 1);
 675       servant2->invocation_pool_and_lane (5, 0);
 676       servant1->server_declared (1);
 677       servant2->server_declared (1);
 678       servant1->server_priority (default_thread_priority + 1);
 679       servant2->server_priority (default_thread_priority);
 680
 681       id1 =
 682         rt_poa->activate_object_with_priority (servant1,
 683                                                default_thread_priority + 1);
 684
 685       id2 =
 686         rt_poa->activate_object_with_priority (servant2,
 687                                                default_thread_priority);
 688
 689       CORBA::Object_var object2 =
 690         poa->id_to_reference (id2.in ());
 691
 692       this->tests_.size (this->tests_.size () + 1);
 693       this->tests_[this->tests_.size () - 1].object_ =
 694         test::_narrow (object2.in ());
 695       this->tests_[this->tests_.size () - 1].servant_ =
 696         servant2;
 697     }
 698
 699   CORBA::Object_var object1 =
 700     poa->id_to_reference (id1.in ());
 701
 702   this->tests_.size (this->tests_.size () + 1);
 703   this->tests_[this->tests_.size () - 1].object_ =
 704     test::_narrow (object1.in ());
 705   this->tests_[this->tests_.size () - 1].servant_ =
 706     servant1;
 707 }
 708
 709 void
 710 Server::start_testing ()
 711 {
 712   Tests::ITERATOR iterator (this->tests_);
 713   while (!iterator.done ())
 714     {
 715       Test_Object_And_Servant *test = 0;
 716       iterator.next (test);
 717
 718       setup_test_parameters (test,
 719                              this->current_.in (),
 720                              this->orb_.in ());
 721
 722       test->object_->start ();
 723
 724       iterator.advance ();
 725     }
 726 }
 727
 728 void
 729 Server::test ()
 730 {
 731   this->start_testing ();
 732
 733   ACE_DEBUG ((LM_DEBUG,
 734               "\n\n*** Changing priority to be higher ***\n\n"));
 735
 736   this->current_->the_priority (default_thread_priority + 1);
 737
 738   this->start_testing ();
 739 }
 740
 741 void
 742 Server::shutdown ()
 743 {
 744   this->orb_->shutdown (true);
 745
 746   this->orb_->destroy ();
 747 }
 748
 749 class Task : public ACE_Task_Base
 750 {
 751 public:
 752   Task (ACE_Thread_Manager &thread_manager,
 753         CORBA::ORB_ptr orb);
 754
 755   int svc ();
 756
 757   CORBA::ORB_var orb_;
 758 };
 759
 760 Task::Task (ACE_Thread_Manager &thread_manager,
 761             CORBA::ORB_ptr orb)
 762   : ACE_Task_Base (&thread_manager),
 763     orb_ (CORBA::ORB::_duplicate (orb))
 764 {
 765 }
 766
 767 int
 768 Task::svc ()
 769 {
 770   try
 771     {
 772       Server server (this->orb_.in ());
 773
 774       server.create_servant_in_root_poa ();
 775
 776       server.create_poa_and_servant_with_tp_policy ("tp_client_propagated_poa",
 777                                                     1,
 778                                                     RTCORBA::CLIENT_PROPAGATED);
 779
 780       server.create_poa_and_servant_with_tp_policy ("tp_server_declared_poa",
 781                                                     1,
 782                                                     RTCORBA::SERVER_DECLARED);
 783
 784       server.create_poa_and_servant_with_tp_policy ("tp_no_priority_model_poa",
 785                                                     0,
 786                                                     RTCORBA::CLIENT_PROPAGATED);
 787
 788       server.create_poa_and_servant_with_tp_with_lanes_policy ("tp_with_lanes_client_propagated_poa",
 789                                                                RTCORBA::CLIENT_PROPAGATED);
 790
 791       server.create_poa_and_servant_with_tp_with_lanes_policy ("tp_with_lanes_server_declared_poa",
 792                                                                RTCORBA::SERVER_DECLARED);
 793
 794       server.test ();
 795
 796       server.shutdown ();
 797     }
 798   catch (const CORBA::Exception& ex)
 799     {
 800       ex._tao_print_exception ("Exception caught:");
 801       return -1;
 802     }
 803
 804   return 0;
 805 }
 806
 807 int
 808 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 809 {
 810   try
 811     {
 812       CORBA::ORB_var orb =
 813         CORBA::ORB_init (argc,
 814                          argv);
 815
 816       // Make sure we can support multiple priorities that are
 817       // required for this test.
 818       if (!check_supported_priorities (orb.in ()))
 819         return 2;
 820
 821       // Thread Manager for managing task.
 822       ACE_Thread_Manager thread_manager;
 823
 824       // Create task.
 825       Task task (thread_manager,
 826                  orb.in ());
 827
 828       // Task activation flags.
 829       long flags =
 830         THR_NEW_LWP |
 831         THR_JOINABLE |
 832         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 833
 834       // Activate task.
 835       int result =
 836         task.activate (flags);
 837       if (result == -1)
 838         {
 839           if (errno == EPERM)
 840             {
 841               ACE_ERROR_RETURN ((LM_ERROR,
 842                                  "Cannot create thread with scheduling policy %s\n"
 843                                  "because the user does not have the appropriate privileges, terminating program....\n"
 844                                  "Check svc.conf options and/or run as root\n",
 845                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 846                                 2);
 847             }
 848           else
 849             // Unexpected error.
 850             ACE_ASSERT (0);
 851         }
 852
 853       // Wait for task to exit.
 854       result =
 855         thread_manager.wait ();
 856       ACE_ASSERT (result != -1);
 857     }
 858   catch (const CORBA::Exception& ex)
 859     {
 860       ex._tao_print_exception ("Exception caught:");
 861       return -1;
 862     }
 863
 864   return 0;
 865 }