TAO/tests/Bug_3801_Regression/simple_client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    simple_client.cpp
   5  *
   6  *  A very simple client which uses the AMI callback model.
   7  *
   8  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
   9  *  @author Michael Kircher <Michael.Kircher@mchp.siemens.de>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "ace/Get_Opt.h"
  15 #include "ace/Task.h"
  16
  17 #include "ami_testS.h"
  18
  19 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  20 int shutdown_flag = 0;
  21 int debug = 0;
  22 int result = 0;
  23
  24 int
  25 parse_args (int argc, ACE_TCHAR *argv[])
  26 {
  27   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("dk:x"));
  28   int c;
  29
  30   while ((c = get_opts ()) != -1)
  31     switch (c)
  32       {
  33       case 'd':
  34         debug = 1;
  35         break;
  36       case 'k':
  37         ior = get_opts.opt_arg ();
  38         break;
  39       case 'x':
  40         shutdown_flag = 1;
  41         break;
  42       case '?':
  43       default:
  44         ACE_ERROR_RETURN ((LM_ERROR,
  45                            "usage:  %s "
  46                            "-k <ior> "
  47                            "-x "
  48                            "\n",
  49                            argv [0]),
  50                           -1);
  51       }
  52   // Indicates successful parsing of the command line
  53   return 0;
  54 }
  55
  56 class Handler : public POA_A::AMI_AMI_TestHandler
  57 {
  58 public:
  59   /// Constructor.
  60   Handler () = default;
  61
  62   /// Destructor.
  63     ~Handler () = default;
  64
  65   void get_yadda (CORBA::Long result)
  66     {
  67       ACE_ERROR ((LM_ERROR,
  68                   "Error: Callback method <get_yadda> called: result <%d>\n",
  69                   result));
  70       result = 1;
  71     };
  72
  73   void get_yadda_excep (::Messaging::ExceptionHolder *excep_holder)
  74     {
  75       ACE_DEBUG ((LM_DEBUG,
  76                   "Callback method <get_yadda_excep> called:\n"));
  77       try
  78         {
  79           excep_holder->raise_exception ();
  80         }
  81       catch (const A::DidTheRightThingB& ex)
  82         {
  83           ACE_DEBUG ((LM_DEBUG,
  84                       "... exception received successfully\n"));
  85           if (ex.id != 42)
  86             {
  87               ACE_ERROR ((LM_ERROR,
  88                           "ERROR: ex.id not 42: %d\n",
  89                           ex.id));
  90               result = 1;
  91             }
  92           if (ACE_OS::strcmp (ex.whatDidTheRightThing.in (), "Hello world") != 0)
  93             {
  94               ACE_ERROR ((LM_ERROR,
  95                           "ERROR: ex.whatDidTheRightThing not ok: <%C>\n",
  96                           ex.whatDidTheRightThing.in ()));
  97               result = 1;
  98             }
  99         }
 100       catch (const CORBA::Exception& ex)
 101         {
 102           ex._tao_print_exception ("ERROR");
 103           ACE_ERROR ((LM_ERROR,
 104                       "... caught the wrong exception -> ERROR\n"));
 105         }
 106     };
 107
 108   void set_yadda ()
 109     {
 110       ACE_ERROR ((LM_ERROR,
 111                   "Error: Callback method <set_yadda> called:\n"));
 112       result = 1;
 113     };
 114
 115   void set_yadda_excep (::Messaging::ExceptionHolder *excep_holder)
 116     {
 117       ACE_DEBUG ((LM_DEBUG,
 118                   "Callback method <set_yadda_excep> called:\n"));
 119       try
 120         {
 121           excep_holder->raise_exception ();
 122         }
 123       catch (const A::DidTheRightThing& ex)
 124         {
 125           ACE_DEBUG ((LM_DEBUG,
 126                       "... exception received successfully\n"));
 127           if (ex.id != 42)
 128             {
 129               ACE_ERROR ((LM_ERROR,
 130                           "ERROR: ex.id not 42: %d\n",
 131                           ex.id));
 132               result = 1;
 133             }
 134           if (ACE_OS::strcmp (ex.whatDidTheRightThing.in (), "Hello world") != 0)
 135             {
 136               ACE_ERROR ((LM_ERROR,
 137                           "ERROR: ex.whatDidTheRightThing not ok: <%C>\n",
 138                           ex.whatDidTheRightThing.in ()));
 139               result = 1;
 140             }
 141         }
 142       catch (const CORBA::Exception& ex)
 143         {
 144           ex._tao_print_exception ("ERROR");
 145           ACE_ERROR ((LM_ERROR,
 146                       "... caught the wrong exception -> ERROR\n"));
 147         }
 148     };
 149
 150   void get_dadda (CORBA::Long result)
 151     {
 152       ACE_ERROR ((LM_ERROR,
 153                   "Error: Callback method <get_dadda> called: result <%d>\n",
 154                   result));
 155       result = 1;
 156     };
 157
 158   void get_dadda_excep (::Messaging::ExceptionHolder *excep_holder)
 159     {
 160       ACE_DEBUG ((LM_DEBUG,
 161                   "Callback method <get_dadda_excep> called:\n"));
 162       try
 163         {
 164           excep_holder->raise_exception ();
 165         }
 166       catch (const A::DidTheRightThing& ex)
 167         {
 168           ACE_DEBUG ((LM_DEBUG,
 169                       "... exception received successfully\n"));
 170           if (ex.id != 42)
 171             {
 172               ACE_ERROR ((LM_ERROR,
 173                           "ERROR: ex.id not 42: %d\n",
 174                           ex.id));
 175               result = 1;
 176             }
 177           if (ACE_OS::strcmp (ex.whatDidTheRightThing.in (), "Hello world") != 0)
 178             {
 179               ACE_ERROR ((LM_ERROR,
 180                           "ERROR: ex.whatDidTheRightThing not ok: <%C>\n",
 181                           ex.whatDidTheRightThing.in ()));
 182               result = 1;
 183             }
 184         }
 185       catch (const CORBA::Exception& ex)
 186         {
 187           ex._tao_print_exception ("ERROR");
 188           ACE_ERROR ((LM_ERROR,
 189                       "... caught the wrong exception -> ERROR\n"));
 190         }
 191     };
 192
 193   void inout_arg_test (const char *)
 194   {
 195     ACE_DEBUG ((LM_DEBUG,
 196                 "Callback method <set_yadda_excep> called:\n"));
 197   }
 198
 199   void inout_arg_test_excep (::Messaging::ExceptionHolder *)
 200   {
 201   }
 202 };
 203
 204 int
 205 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 206 {
 207   try
 208     {
 209       CORBA::ORB_var orb =
 210         CORBA::ORB_init (argc, argv);
 211
 212       CORBA::Object_var object_var =
 213         orb->resolve_initial_references ("RootPOA");
 214
 215       PortableServer::POA_var poa_var =
 216         PortableServer::POA::_narrow (object_var.in ());
 217
 218       PortableServer::POAManager_var poa_manager_var =
 219         poa_var->the_POAManager ();
 220
 221       poa_manager_var->activate ();
 222
 223       if (parse_args (argc, argv) != 0)
 224         return 1;
 225
 226       // We reuse the object_var smart pointer!
 227       object_var = orb->string_to_object (ior);
 228
 229       A::AMI_Test_var ami_test_var =
 230         A::AMI_Test::_narrow (object_var.in ());
 231
 232       if (CORBA::is_nil (ami_test_var.in ()))
 233         {
 234           ACE_ERROR_RETURN ((LM_ERROR,
 235                              "Object reference <%s> is nil.\n",
 236                              ior),
 237                             1);
 238         }
 239
 240       // Instantiate the ReplyHandler and register that with the POA.
 241       Handler handler;
 242       PortableServer::ObjectId_var id =
 243         poa_var->activate_object (&handler);
 244
 245       CORBA::Object_var object = poa_var->id_to_reference (id.in ());
 246
 247       A::AMI_AMI_TestHandler_var the_handler_var =
 248         A::AMI_AMI_TestHandler::_narrow (object.in ());
 249
 250       // Begin test of attributes
 251       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 252
 253       ami_test_var->sendc_set_yadda (the_handler_var.in (), 4711);
 254
 255       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 256
 257       ami_test_var->sendc_get_dadda (the_handler_var.in ());
 258       // End test of attributes
 259
 260       if (debug)
 261         {
 262           ACE_DEBUG ((LM_DEBUG,
 263                       "Issuing a synchronous method to collect the AMI replies\n"));
 264         }
 265
 266       CORBA::String_var mystring = CORBA::string_dup ("Hello");
 267
 268       ami_test_var->inout_arg_test (mystring.inout ());
 269
 270       if (shutdown_flag)
 271         {
 272           ami_test_var->shutdown ();
 273         }
 274
 275       poa_var->destroy (1,  // ethernalize objects
 276                         0); // wait for completion
 277
 278       orb->destroy ();
 279     }
 280   catch (const CORBA::Exception& ex)
 281     {
 282       ex._tao_print_exception ("Caught exception:");
 283       return 1;
 284     }
 285
 286   return result;
 287 }