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 (void);
  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
  87   // The ORB reference
  88   CORBA::ORB_var orb_;
  89   // The exceptions caught.
  90   int received_ex_kind_;
  91   // The number of received exceptions.
  92   int num_received_ex_;
  93   // Flag for test completion. The result is
  94   // collected before done.
  95   bool done_;
  96 };
  97
  98 int
  99 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 100 {
 101   try
 102     {
 103       CORBA::ORB_var orb =
 104         CORBA::ORB_init (argc, argv);
 105
 106       if (parse_args (argc, argv) != 0)
 107         return 1;
 108
 109       Worker worker (orb.in ());
 110
 111       if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
 112                            nthreads) != 0)
 113         ACE_ERROR_RETURN ((LM_ERROR,
 114                            "(%P|%t) Cannot activate worker threads\n"),
 115                           1);
 116
 117       int timeout = 30;
 118       int now = 0;
 119       while (now < timeout
 120         && ((expect_ex_kind != TAO::FOE_NON
 121              && worker.received_ex_kind () != expect_ex_kind
 122              && worker.num_received_ex () != expect_num_ex)
 123             || expect_ex_kind == TAO::FOE_NON))
 124       {
 125         std::cout << ".";
 126         now += 1;
 127         ACE_Time_Value tv (1, 0);
 128         orb->run (tv);
 129       }
 130       std::cout << std::endl;
 131
 132       worker.done ();
 133
 134       if (do_shutdown)
 135         {
 136           CORBA::Object_var object =
 137             orb->string_to_object (ior);
 138
 139           Simple_Server_var server =
 140             Simple_Server::_narrow (object.in ());
 141
 142           server->shutdown ();
 143         }
 144
 145       ACE_OS::sleep (1);
 146
 147       orb->destroy ();
 148
 149       worker.thr_mgr ()->wait ();
 150
 151       if (worker.received_ex_kind () != expect_ex_kind
 152         || worker.num_received_ex () != expect_num_ex)
 153       {
 154         ACE_ERROR_RETURN ((LM_ERROR,
 155           ("(%P|%t)client: test failed - expected is different from received. "
 156           "expected %d/%d received %d/%d.\n"),
 157           expect_ex_kind, expect_num_ex, worker.received_ex_kind (), worker.num_received_ex()),
 158                           1);
 159       }
 160
 161       ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
 162     }
 163   catch (const CORBA::Exception& ex)
 164     {
 165       ex._tao_print_exception ("Exception caught in main:");
 166       return 1;
 167     }
 168
 169   return 0;
 170 }
 171
 172 // ****************************************************************
 173
 174 Worker::Worker (CORBA::ORB_ptr orb)
 175 :    orb_ (CORBA::ORB::_duplicate (orb)),
 176      received_ex_kind_ (TAO::FOE_NON),
 177      num_received_ex_ (0),
 178      done_ (false)
 179 {
 180 }
 181
 182 int
 183 Worker::svc (void)
 184 {
 185   try
 186     {
 187       CORBA::Object_var object =
 188         this->orb_->string_to_object (ior);
 189
 190       Simple_Server_var server =
 191         Simple_Server::_narrow (object.in ());
 192
 193       if (CORBA::is_nil (server.in ()))
 194         {
 195           ACE_ERROR ((LM_ERROR,
 196                       "Object reference <%s> is nil.\n",
 197                       ior));
 198           return 0;
 199         }
 200
 201       for (int i = 0; i < num_requests; ++i)
 202       {
 203         try {
 204           CORBA::Boolean r =
 205             server->test_is_a ("IDL:Foo:1.0");
 206
 207           if (r != 0)
 208             ACE_DEBUG ((LM_DEBUG,
 209                         "(%P|%t) unexpected result = %d\n",
 210                         r));
 211
 212         }
 213         catch (const CORBA::OBJECT_NOT_EXIST &)
 214           {
 215             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received OBJECT_NOT_EXIST \n"));
 216             if (!this->done_)
 217             {
 218               ++ this->num_received_ex_;
 219               received_ex_kind_ |= TAO::FOE_OBJECT_NOT_EXIST;
 220             }
 221           }
 222         catch (const CORBA::COMM_FAILURE &)
 223           {
 224             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received COMM_FAILURE \n"));
 225             if (!this->done_)
 226             {
 227               ++ this->num_received_ex_;
 228               received_ex_kind_ |= TAO::FOE_COMM_FAILURE;
 229             }
 230           }
 231         catch (const CORBA::TRANSIENT &)
 232           {
 233             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received TRANSIENT \n"));
 234             if (!this->done_)
 235             {
 236               ++ this->num_received_ex_;
 237               received_ex_kind_ |= TAO::FOE_TRANSIENT;
 238             }
 239           }
 240         catch (const CORBA::INV_OBJREF &)
 241           {
 242             //ACE_DEBUG ((LM_DEBUG, "(%P|%t)received INV_OBJREF \n"));
 243             if (!this->done_)
 244             {
 245               ++ this->num_received_ex_;
 246               received_ex_kind_ |= TAO::FOE_INV_OBJREF;
 247             }
 248           }
 249        }
 250     }
 251   catch (const CORBA::Exception& ex)
 252     {
 253       ex._tao_print_exception (
 254         "Unexpected exception caught");
 255     }
 256
 257   return 0;
 258 }
 259
 260
 261 int
 262 Worker::received_ex_kind () const
 263 {
 264   return received_ex_kind_;
 265 }
 266
 267 int
 268 Worker::num_received_ex () const
 269 {
 270   return num_received_ex_;
 271 }
 272
 273 void
 274 Worker::done ()
 275 {
 276   done_ = true;
 277 }
 278