TAO/tests/ForwardOnceUponException/client.cpp

   1 #include "testC.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/Task.h"
   4 #include "ace/streams.h"
   5 #include "tao/Invocation_Utils.h"
   6 #include "ace/OS_NS_unistd.h"
   7
   8 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
   9 int nthreads = 1;
  10 int do_shutdown = 0;
  11 static const ACE_TCHAR corbaloc_prefix[] = ACE_TEXT("corbaloc:");
  12 int expect_ex_kind = TAO::FOE_NON;
  13 int num_requests = 1;
  14 int expect_num_ex = 1;
  15
  16 int
  17 parse_args (int argc, ACE_TCHAR *argv[])
  18 {
  19   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("xk:e:i:n:"));
  20   int c;
  21
  22   while ((c = get_opts ()) != -1)
  23     switch (c)
  24       {
  25       case 'x':
  26         do_shutdown = 1;
  27         break;
  28
  29       case 'k':
  30         ior = get_opts.opt_arg ();
  31         break;
  32
  33       case 'e':
  34         expect_ex_kind = ACE_OS::atoi (get_opts.opt_arg ());
  35         break;
  36
  37       case 'i':
  38         num_requests = ACE_OS::atoi (get_opts.opt_arg ());
  39         break;
  40
  41       case 'n':
  42         expect_num_ex = ACE_OS::atoi (get_opts.opt_arg ());
  43         break;
  44
  45       case '?':
  46       default:
  47         ACE_ERROR_RETURN ((LM_ERROR,
  48                            "usage:  %s "
  49                            "-k <ior> -x "
  50                            "-e <expected exception kind> "
  51                            "-i <num_requests> "
  52                            "-n <expected number of exceptions> "
  53                            "\n",
  54                            argv [0]),
  55                           -1);
  56       }
  57
  58   if (ACE_OS::strncmp (ior,
  59                        corbaloc_prefix,
  60                        ACE_OS::strlen(corbaloc_prefix)) != 0)
  61     return 1;
  62
  63   // Indicates successful parsing of the command line
  64   return 0;
  65 }
  66
  67 class Worker : public ACE_Task_Base
  68 {
  69 public:
  70   Worker (CORBA::ORB_ptr orb);
  71   // Constructor
  72
  73   // = The Task_Base methods
  74   virtual int svc ();
  75
  76   // Caught any exception ?
  77   int received_ex_kind () const;
  78
  79   // Return number of received exceptions.
  80   int num_received_ex () const;
  81
  82   // Is test done ?
  83   void done ();
  84
  85 private:
  86   // The ORB reference
  87   CORBA::ORB_var orb_;
  88   // The exceptions caught.
  89   int received_ex_kind_;
  90   // The number of received exceptions.
  91   int num_received_ex_;
  92   // Flag for test completion. The result is
  93   // collected before done.
  94   bool done_;
  95 };
  96
  97 int
  98 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  99 {
 100   try
 101     {
 102       CORBA::ORB_var orb =
 103         CORBA::ORB_init (argc, argv);
 104
 105       if (parse_args (argc, argv) != 0)
 106         return 1;
 107
 108       Worker worker (orb.in ());
 109
 110       if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
 111                            nthreads) != 0)
 112         ACE_ERROR_RETURN ((LM_ERROR,
 113                            "(%P|%t) Cannot activate worker threads\n"),
 114                           1);
 115
 116       int timeout = 30;
 117       int now = 0;
 118       while (now < timeout
 119         && ((expect_ex_kind != TAO::FOE_NON
 120              && worker.received_ex_kind () != expect_ex_kind
 121              && worker.num_received_ex () != expect_num_ex)
 122             || expect_ex_kind == TAO::FOE_NON))
 123       {
 124         std::cout << ".";
 125         now += 1;
 126         ACE_Time_Value tv (1, 0);
 127         orb->run (tv);
 128       }
 129       std::cout << std::endl;
 130
 131       worker.done ();
 132
 133       if (do_shutdown)
 134         {
 135           CORBA::Object_var object =
 136             orb->string_to_object (ior);
 137
 138           Simple_Server_var server =
 139             Simple_Server::_narrow (object.in ());
 140
 141           server->shutdown ();
 142         }
 143
 144       ACE_OS::sleep (1);
 145
 146       orb->destroy ();
 147
 148       worker.thr_mgr ()->wait ();
 149
 150       if (worker.received_ex_kind () != expect_ex_kind
 151         || worker.num_received_ex () != expect_num_ex)
 152       {
 153         ACE_ERROR_RETURN ((LM_ERROR,
 154           ("(%P|%t)client: test failed - expected is different from received. "
 155           "expected %d/%d received %d/%d.\n"),
 156           expect_ex_kind, expect_num_ex, worker.received_ex_kind (), worker.num_received_ex()),
 157                           1);
 158       }
 159
 160       ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
 161     }
 162   catch (const CORBA::Exception& ex)
 163     {
 164       ex._tao_print_exception ("Exception caught in main:");
 165       return 1;
 166     }
 167
 168   return 0;
 169 }
 170
 171 // ****************************************************************
 172
 173 Worker::Worker (CORBA::ORB_ptr orb)
 174 :    orb_ (CORBA::ORB::_duplicate (orb)),
 175      received_ex_kind_ (TAO::FOE_NON),
 176      num_received_ex_ (0),
 177      done_ (false)
 178 {
 179 }
 180
 181 int
 182 Worker::svc ()
 183 {
 184   try
 185     {
 186       CORBA::Object_var object =
 187         this->orb_->string_to_object (ior);
 188
 189       Simple_Server_var server =
 190         Simple_Server::_narrow (object.in ());
 191
 192       if (CORBA::is_nil (server.in ()))
 193         {
 194           ACE_ERROR ((LM_ERROR,
 195                       "Object reference <%s> is nil.\n",
 196                       ior));
 197           return 0;
 198         }
 199
 200       for (int i = 0; i < num_requests; ++i)
 201       {
 202         try {
 203           CORBA::Boolean r =
 204             server->test_is_a ("IDL:Foo:1.0");
 205
 206           if (r != 0)
 207             ACE_DEBUG ((LM_DEBUG,
 208                         "(%P|%t) unexpected result = %d\n",
 209                         r));
 210         }
 211         catch (const CORBA::OBJECT_NOT_EXIST &)
 212           {
 213             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received OBJECT_NOT_EXIST \n"));
 214             if (!this->done_)
 215             {
 216               ++ this->num_received_ex_;
 217               received_ex_kind_ |= TAO::FOE_OBJECT_NOT_EXIST;
 218             }
 219           }
 220         catch (const CORBA::COMM_FAILURE &)
 221           {
 222             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received COMM_FAILURE \n"));
 223             if (!this->done_)
 224             {
 225               ++ this->num_received_ex_;
 226               received_ex_kind_ |= TAO::FOE_COMM_FAILURE;
 227             }
 228           }
 229         catch (const CORBA::TRANSIENT &)
 230           {
 231             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received TRANSIENT \n"));
 232             if (!this->done_)
 233             {
 234               ++ this->num_received_ex_;
 235               received_ex_kind_ |= TAO::FOE_TRANSIENT;
 236             }
 237           }
 238         catch (const CORBA::INV_OBJREF &)
 239           {
 240             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received INV_OBJREF \n"));
 241             if (!this->done_)
 242             {
 243               ++ this->num_received_ex_;
 244               received_ex_kind_ |= TAO::FOE_INV_OBJREF;
 245             }
 246           }
 247        }
 248     }
 249   catch (const CORBA::Exception& ex)
 250     {
 251       ex._tao_print_exception (
 252         "Unexpected exception caught");
 253     }
 254
 255   return 0;
 256 }
 257
 258
 259 int
 260 Worker::received_ex_kind () const
 261 {
 262   return received_ex_kind_;
 263 }
 264
 265 int
 266 Worker::num_received_ex () const
 267 {
 268   return num_received_ex_;
 269 }
 270
 271 void
 272 Worker::done ()
 273 {
 274   done_ = true;
 275 }
 276