TAO/orbsvcs/tests/Notify/Basic/ConnectDisconnect.cpp

   1 #include "ace/Arg_Shifter.h"
   2 #include "ace/Get_Opt.h"
   3 #include "tao/debug.h"
   4 #include "ConnectDisconnect.h"
   5
   6
   7 #define CD_IMPLEMENT_ENTITY(X)\
   8 \
   9 CD_##X::CD_##X (ConnectDisconnect* cd, int id) \
  10   :CD_Entity (cd, id) \
  11 { \
  12 }
  13
  14 CD_Entity::CD_Entity (ConnectDisconnect* cd, int id)
  15   :id_ (id),
  16    cd_ (cd)
  17 {
  18 }
  19
  20 CD_Entity::~CD_Entity ()
  21 {
  22   if (TAO_debug_level)
  23     {
  24       ACE_DEBUG ((LM_DEBUG, "Entity #%d destroyed\n", this->id_));
  25     }
  26
  27   cd_->on_entity_destroyed ();
  28 }
  29
  30 CD_IMPLEMENT_ENTITY(PushConsumer)
  31 CD_IMPLEMENT_ENTITY(StructuredPushConsumer)
  32 CD_IMPLEMENT_ENTITY(SequencePushConsumer)
  33
  34 CD_IMPLEMENT_ENTITY(PushSupplier)
  35 CD_IMPLEMENT_ENTITY(StructuredPushSupplier)
  36 CD_IMPLEMENT_ENTITY(SequencePushSupplier)
  37
  38 //*****************************************************************************************************
  39
  40 ConnectDisconnect::ConnectDisconnect ()
  41   :any_consumer_ (0),
  42    structured_consumer_ (0),
  43    sequence_consumer_ (0),
  44    any_supplier_ (0),
  45    structured_supplier_ (0),
  46    sequence_supplier_ (0),
  47    count_ (3),
  48    consumers_ (3),
  49    suppliers_ (3)
  50 {
  51 }
  52
  53 ConnectDisconnect::~ConnectDisconnect ()
  54 {
  55   delete [] this->any_consumer_;
  56   delete [] this->structured_consumer_;
  57   delete [] this->sequence_consumer_;
  58
  59   delete [] this->any_supplier_;
  60   delete [] this->structured_supplier_;
  61   delete [] this->sequence_supplier_;
  62 }
  63
  64 void
  65 ConnectDisconnect::on_entity_destroyed ()
  66 {
  67   this->result_count_++;
  68
  69   if (TAO_debug_level)
  70     ACE_DEBUG ((LM_DEBUG,
  71                 "result_count = %d\n",
  72                 this->result_count_.value ()));
  73 }
  74
  75 int
  76 ConnectDisconnect::init (int argc,
  77                          ACE_TCHAR* argv [])
  78 {
  79   // Initialize the base class.
  80   Notify_Test_Client::init (argc,
  81                             argv);
  82
  83   // Create all participants.
  84   this->create_EC ();
  85
  86   CosNotifyChannelAdmin::AdminID adminid;
  87
  88   this->supplier_admin_ =
  89     ec_->new_for_suppliers (this->ifgop_,
  90                             adminid);
  91
  92   ACE_ASSERT (!CORBA::is_nil (supplier_admin_.in ()));
  93
  94   this->consumer_admin_ =
  95     ec_->new_for_consumers (this->ifgop_,
  96                             adminid);
  97
  98   ACE_ASSERT (!CORBA::is_nil (consumer_admin_.in ()));
  99
 100   // How many are we counting..?
 101   this->expected_count_ = count_ * (consumers_ * 3 + suppliers_ * 3);
 102
 103   // Create the consumers and suppliers.
 104
 105   // Arrays of Consumers.
 106   ACE_NEW_RETURN (this->any_consumer_,
 107                   TAO_Notify_Tests_PushConsumer*[this->consumers_],
 108                   -1);
 109   ACE_NEW_RETURN (this->structured_consumer_,
 110                  TAO_Notify_Tests_StructuredPushConsumer*[this->consumers_],
 111                  -1);
 112   ACE_NEW_RETURN (this->sequence_consumer_,
 113                   TAO_Notify_Tests_SequencePushConsumer*[this->consumers_],
 114                   -1);
 115
 116   // Arrays of Suppliers.
 117   ACE_NEW_RETURN (this->any_supplier_,
 118                   TAO_Notify_Tests_PushSupplier*[this->suppliers_],
 119                   -1);
 120   ACE_NEW_RETURN (this->structured_supplier_,
 121                   TAO_Notify_Tests_StructuredPushSupplier*[this->suppliers_],
 122                   -1);
 123   ACE_NEW_RETURN (this->sequence_supplier_,
 124                   TAO_Notify_Tests_SequencePushSupplier*[this->suppliers_],
 125                   -1);
 126
 127   consumer_start(0);
 128   return 0;
 129 }
 130
 131 int
 132 ConnectDisconnect::parse_args(int argc, ACE_TCHAR *argv[])
 133 {
 134   ACE_Arg_Shifter arg_shifter (argc,
 135                               argv);
 136
 137     const ACE_TCHAR *current_arg = 0;
 138
 139     while (arg_shifter.is_anything_left ())
 140     {
 141       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-count"))))
 142         {
 143           this->count_ = ACE_OS::atoi (current_arg);
 144           arg_shifter.consume_arg ();
 145         }
 146       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-consumers"))))
 147         {
 148           this->consumers_ = ACE_OS::atoi (current_arg);
 149           arg_shifter.consume_arg ();
 150         }
 151       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-suppliers"))))
 152         {
 153           this->suppliers_ = ACE_OS::atoi (current_arg);
 154           arg_shifter.consume_arg ();
 155         }
 156       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
 157         {
 158           ACE_DEBUG((LM_DEBUG,
 159                      "usage: %s "
 160                      "-count testcount\n"
 161                      "-consumers number_of_consumers"
 162                      "-suppliers number_of_suppliers",
 163                      argv[0],
 164                      argv[0]));
 165
 166           arg_shifter.consume_arg ();
 167
 168           return -1;
 169         }
 170       else
 171         {
 172           arg_shifter.ignore_arg ();
 173         }
 174     }
 175
 176   return 0;
 177 }
 178
 179 void
 180 ConnectDisconnect::create_EC ()
 181 {
 182   CosNotifyChannelAdmin::ChannelID id;
 183
 184   this->ec_ = notify_factory_->create_channel (this->initial_qos_,
 185                                                this->initial_admin_,
 186                                                id);
 187
 188   ACE_ASSERT (!CORBA::is_nil (ec_.in ()));
 189 }
 190
 191 void
 192 ConnectDisconnect::run_test ()
 193 {
 194   for (int iterations = 0; iterations < count_; ++iterations)
 195     {
 196       int i = 0;
 197
 198       for (i = 0; i < this->consumers_; ++i)
 199         {
 200           // Create and connect Any consumers.
 201           ACE_NEW (this->any_consumer_[i],
 202                    CD_PushConsumer (this,
 203                                     i));
 204           this->any_consumer_[i]->init (root_poa_.in ());
 205           this->any_consumer_[i]->connect (this->consumer_admin_.in ());
 206
 207           // Create and connect Structured consumers.
 208           ACE_NEW (this->structured_consumer_[i],
 209                    CD_StructuredPushConsumer (this,
 210                                               i));
 211           this->structured_consumer_[i]->init (root_poa_.in ());
 212           this->structured_consumer_[i]->connect (this->consumer_admin_.in ());
 213
 214           // Create and connect Sequence consumers.
 215           ACE_NEW (this->sequence_consumer_[i],
 216                    CD_SequencePushConsumer (this,
 217                                             i));
 218           this->sequence_consumer_[i]->init (root_poa_.in ());
 219           this->sequence_consumer_[i]->connect (this->consumer_admin_.in ());
 220         }
 221
 222       for (i = 0; i < this->suppliers_; ++i)
 223         {
 224           ACE_NEW (this->any_supplier_[i],
 225                    CD_PushSupplier (this,
 226                                     i));
 227           this->any_supplier_[i]->init (root_poa_.in ());
 228           this->any_supplier_[i]->connect (this->supplier_admin_.in ());
 229
 230           // Create and connect Structured suppliers.
 231           ACE_NEW (this->structured_supplier_[i],
 232                    CD_StructuredPushSupplier (this,
 233                                               i));
 234           this->structured_supplier_[i]->init (root_poa_.in ());
 235           this->structured_supplier_[i]->connect (this->supplier_admin_.in ());
 236
 237           // Create and connect Sequence suppliers.
 238           ACE_NEW (this->sequence_supplier_[i],
 239                    CD_SequencePushSupplier (this,
 240                                             i));
 241           this->sequence_supplier_[i]->init (root_poa_.in ());
 242           this->sequence_supplier_[i]->connect (this->supplier_admin_.in ());
 243         }
 244
 245       for (i = 0; i < this->consumers_; ++i)
 246         {
 247           // Disconnnect Any consumers.
 248           this->any_consumer_[i]->disconnect ();
 249
 250           // Disconnect Structured Consumers.
 251           this->structured_consumer_[i]->disconnect ();
 252
 253           // Disconnect Sequence Consumers.
 254           this->sequence_consumer_[i]->disconnect ();
 255         }
 256
 257       for (i = 0; i < this->suppliers_; ++i)
 258         {
 259           // Disconnnect Any suppliers.
 260           this->any_supplier_[i]->disconnect ();
 261
 262           // Disconnect Structured Suppliers.
 263           this->structured_supplier_[i]->disconnect ();
 264
 265           // Disconnect Sequence Suppliers.
 266           this->sequence_supplier_[i]->disconnect ();
 267         }
 268     }
 269 }
 270
 271 void
 272 ConnectDisconnect::end_test ()
 273 {
 274   consumer_done(0);
 275 }
 276
 277 int
 278 ConnectDisconnect::check_results ()
 279 {
 280   ACE_DEBUG ((LM_DEBUG, "result_count_ = %d", this->result_count_.value ()));
 281   ACE_DEBUG ((LM_DEBUG, " expected_count_ = %d\n", this->expected_count_));
 282
 283   if (this->result_count_ != this->expected_count_)
 284     {
 285       ACE_DEBUG ((LM_DEBUG, "ConnectDisconnect test failed\n"));
 286     }
 287   else
 288     {
 289       ACE_DEBUG ((LM_DEBUG, "ConnectDisconnect test succeeded\n"));
 290     }
 291
 292   // Destroy the channel.
 293   this->ec_->destroy ();
 294
 295   return 0;
 296 }
 297
 298 /***************************************************************************/
 299
 300 int
 301 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 302 {
 303   ConnectDisconnect client;
 304
 305   if (client.parse_args (argc, argv) == -1)
 306     {
 307       return 1;
 308     }
 309
 310   try
 311     {
 312       client.init (argc, argv);
 313
 314       client.run_test ();
 315
 316       client.end_test ();
 317     }
 318   catch (const CORBA::Exception& se)
 319     {
 320       se._tao_print_exception ("Error: ");
 321       return 1;
 322     }
 323
 324   int status = 0;
 325
 326   try
 327     {
 328       status = client.check_results ();
 329     }
 330   catch (const CORBA::Exception& se)
 331     {
 332       se._tao_print_exception ("Error: ");
 333       status = 1;
 334     }
 335
 336   return status;
 337 }
 338