TAO/tests/Param_Test/except.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file   except.cpp
   5  *
   6  * tests exception
   7  *
   8  *  @author Carlos O'Ryan
   9  */
  10 //=============================================================================
  11
  12
  13 #include "helper.h"
  14 #include "except.h"
  15 #include "tao/debug.h"
  16
  17 #include "tao/DynamicInterface/Unknown_User_Exception.h"
  18
  19 // ************************************************************************
  20 //               Test_Exception
  21 // ************************************************************************
  22
  23 Test_Exception::Test_Exception ()
  24   : opname_ (CORBA::string_dup ("test_exception")),
  25     iterations_ (0)
  26 {
  27 }
  28
  29 Test_Exception::~Test_Exception ()
  30 {
  31   CORBA::string_free (this->opname_);
  32   this->opname_ = 0;
  33 }
  34
  35 const char *
  36 Test_Exception::opname () const
  37 {
  38   return this->opname_;
  39 }
  40
  41 void
  42 Test_Exception::dii_req_invoke (CORBA::Request_ptr req)
  43 {
  44   try
  45     {
  46       this->in_++;
  47       req->add_in_arg ("s1") <<= this->in_;
  48       req->add_inout_arg ("s2") <<= this->inout_;
  49       req->add_out_arg ("s3") <<= this->out_;
  50
  51       req->set_return_type (CORBA::_tc_ulong);
  52
  53       req->exceptions ()->add (CORBA::TypeCode::_duplicate (Param_Test::_tc_Ooops));
  54
  55       req->invoke ();
  56
  57       req->return_value () >>= this->ret_;
  58
  59       CORBA::NamedValue_ptr o2 =
  60         req->arguments ()->item (1);
  61
  62       *o2->value () >>= this->inout_;
  63
  64       CORBA::NamedValue_ptr o3 =
  65         req->arguments ()->item (2);
  66
  67       *o3->value () >>= this->out_;
  68     }
  69   catch (CORBA::UnknownUserException& user_ex)
  70     {
  71       const Param_Test::Ooops* oops = 0;
  72       const Param_Test::BadBoy* bad_boy = 0;
  73
  74       if (user_ex.exception () >>= oops)
  75         {
  76           const char *reason = oops->reason.in ();
  77           CORBA::ULong mod_value = oops->input;
  78
  79           if (TAO_debug_level > 0)
  80             {
  81               ACE_DEBUG ((LM_DEBUG,
  82                           "Test_Exception::dii_req_invoke - "
  83                           "expected user exception"
  84                           " (%s,%d)\n",
  85                           reason,
  86                           mod_value));
  87             }
  88
  89           if (reason != 0 && mod_value == 1)
  90             {
  91               this->inout_ = this->in_ * 2;
  92               this->out_ = this->in_ * 3;
  93               this->ret_ = this->in_ * 4;
  94             }
  95         }
  96       else if (user_ex.exception () >>= bad_boy)
  97         {
  98           (*bad_boy)._tao_print_exception (
  99             "Test_Exception::dii_req_invoke - "
 100             "unexpected (but known) user exception\n");
 101
 102           // Since 'BadBoy' is not in the exception list the DII request,
 103           // it should not be caught explicitly. See comment below.
 104           this->inout_ = this->in_ * 5;
 105           this->out_ = this->in_ * 5;
 106           this->ret_ = this->in_ * 5;
 107         }
 108       else
 109         {
 110           ACE_ERROR ((LM_ERROR,
 111                       "ERROR Test_Exception::dii_req_invoke - "
 112                       "unexpected (and unknown) user exception\n"));
 113         }
 114
 115       return;
 116     }
 117   // Catch the SystemException type CORBA::NO_MEMORY thrown by the
 118   // server to test the system exception.
 119   catch (const CORBA::NO_MEMORY&)
 120     {
 121       // 'NO_MEMORY' system exception should be caught here. This
 122       // happens when the IN arg == 2.
 123       // Otherwise we don't set the other arg values so the validity
 124       // check will flag the error.
 125       if (this->in_ % 4 == 2)
 126         {
 127           this->inout_ = this->in_ * 2;
 128           this->out_ = this->in_ * 3;
 129           this->ret_ = this->in_ * 4;
 130
 131           if (TAO_debug_level > 0)
 132             {
 133               ACE_DEBUG ((LM_DEBUG,
 134                           "Test_Exception::dii_req_invoke - "
 135                           "expected CORBA::NO_MEMORY system exception\n"));
 136             }
 137         }
 138       else if (this->in_ % 4 == 1)
 139         {
 140           // We caught NO_MEMORY system exception when we should have caught Ooops.
 141           if (TAO_debug_level > 0)
 142             {
 143               ACE_DEBUG ((LM_DEBUG,
 144                           "Test_Exception::dii_req_invoke - "
 145                           "caught NO_MEMORY system exception - "
 146                           "expected known user exception\n"));
 147             }
 148         }
 149       else if (this->in_ % 4 == 3)
 150         {
 151           // We caught NO_MEMORY system exception when we should have caught UNKNOWN.
 152           if (TAO_debug_level > 0)
 153             {
 154               ACE_DEBUG ((LM_DEBUG,
 155                           "Test_Exception::dii_req_invoke - "
 156                           "caught NO_MEMORY system exception - "
 157                           "expected UNKNOWN exception\n"));
 158             }
 159         }
 160       else
 161         {
 162           // We caught NO_MEMORY system exception when we should have caught nothing.
 163           if (TAO_debug_level > 0)
 164             {
 165               ACE_DEBUG ((LM_DEBUG,
 166                           "Test_Exception::dii_req_invoke - "
 167                           "caught unexpected unknown exception\n"));
 168             }
 169         }
 170     }
 171   catch (const CORBA::UNKNOWN&)
 172     {
 173       // 'BadBoy' should be caught here. This happens when the IN arg == 3.
 174       // Otherwise we don't set the other arg values so the validity
 175       // check will flag the error.
 176       if (this->in_ % 4 == 3)
 177         {
 178           this->inout_ = this->in_ * 2;
 179           this->out_ = this->in_ * 3;
 180           this->ret_ = this->in_ * 4;
 181
 182           if (TAO_debug_level > 0)
 183             {
 184               ACE_DEBUG ((LM_DEBUG,
 185                           "Test_Exception::dii_req_invoke - "
 186                           "expected CORBA::UNKNOWN\n"));
 187             }
 188         }
 189       else if (this->in_ % 4 == 1)
 190         {
 191           // We caught UNKNOWN when we should have caught Ooops.
 192           if (TAO_debug_level > 0)
 193             {
 194               ACE_DEBUG ((LM_DEBUG,
 195                           "Test_Exception::dii_req_invoke - "
 196                           "caught unknown exception - "
 197                           "expected known user exception\n"));
 198             }
 199         }
 200       else if (this->in_ % 4 == 2)
 201         {
 202           // We caught UNKNOWN exception when we should have caught NO_MEMORY.
 203           if (TAO_debug_level > 0)
 204             {
 205               ACE_DEBUG ((LM_DEBUG,
 206                           "Test_Exception::dii_req_invoke - "
 207                           "caught unknown exception - "
 208                           "expected NO_MEMORY system exception\n"));
 209             }
 210         }
 211       else
 212         {
 213           // We caught UNKNOWN when we should have caught nothing.
 214           if (TAO_debug_level > 0)
 215             {
 216               ACE_DEBUG ((LM_DEBUG,
 217                           "Test_Exception::dii_req_invoke - "
 218                           "caught unexpected unknown exception\n"));
 219             }
 220         }
 221     }
 222 }
 223
 224 int
 225 Test_Exception::init_parameters (Param_Test_ptr)
 226 {
 227   this->in_ = 0;
 228   this->inout_ =  0;
 229   return 0;
 230 }
 231
 232 int
 233 Test_Exception::reset_parameters ()
 234 {
 235   this->inout_ =  0;
 236   this->out_ =  0;
 237   this->ret_ =  0;
 238   return 0;
 239 }
 240
 241 int
 242 Test_Exception::run_sii_test (Param_Test_ptr objref)
 243 {
 244   try
 245     {
 246       this->in_++;
 247       this->ret_ = objref->test_exception (this->in_,
 248                                            this->inout_,
 249                                            this->out_);
 250     }
 251   catch (const Param_Test::Ooops& ex)
 252     {
 253       const char *reason = ex.reason.in ();
 254
 255       if (reason == 0)
 256         {
 257           return -1;
 258         }
 259
 260       CORBA::ULong const mod_value = ex.input;
 261
 262       // We should be catching Ooops only when this is true.
 263       if (mod_value != 1)
 264         {
 265           return -1;
 266         }
 267
 268       if (TAO_debug_level > 0)
 269         {
 270           ACE_DEBUG ((LM_DEBUG,
 271                       "Test_Exception::run_sii_test - "
 272                       "expected user exception"
 273                       " (%C,%d)\n",
 274                       reason,
 275                       mod_value));
 276         }
 277
 278       // These weren't passed back because of the exception. We
 279       // set them here to the 'correct' values so the validity
 280       // check won't return an error.
 281       this->inout_ = this->in_ * 2;
 282       this->out_ = this->in_ * 3;
 283       this->ret_ = this->in_ * 4;
 284       return 0;
 285     }
 286   catch (const CORBA::NO_MEMORY& ex)
 287     {
 288       // 'SystemException' should be caught here, 'CORBA::NO_MEMORY'
 289       // system exception is thrown by the servant when the
 290           // IN argument == 2.
 291       int d = this->in_ % 4;
 292
 293       if (d != 2)
 294         {
 295           if (d == 1 && TAO_debug_level > 0)
 296             {
 297               ACE_DEBUG ((LM_DEBUG,
 298                           "Test_Exception::run_sii_test - "
 299                           "caught system exception - "
 300                           "expected known user exception\n"));
 301             }
 302           else if (d == 3 && TAO_debug_level > 0)
 303             {
 304               ACE_DEBUG ((LM_DEBUG,
 305                           "Test_Exception::run_sii_test - "
 306                           "caught system exception - "
 307                           "expected unknown exception\n"));
 308             }
 309
 310           return -1;
 311         }
 312
 313       if (TAO_debug_level > 0)
 314         {
 315           ex._tao_print_exception (
 316             "Test_Exception::run_sii_test - ""expected system exception\n");
 317         }
 318
 319       // These weren't passed back because of the exception. We
 320       // set them here to the 'correct' values so the validity
 321       // check won't return an error.
 322       this->inout_ = this->in_ * 2;
 323       this->out_ = this->in_ * 3;
 324       this->ret_ = this->in_ * 4;
 325       return 0;
 326     }
 327   catch (const CORBA::UNKNOWN& ex)
 328     {
 329       // 'BadBoy' should be caught here, since generated code for
 330       // Param_Test::test_exception() knows nothing about it.
 331       // 'Ooops' however, should not be caught here. 'BadBoy'
 332       // is thrown by the servant when the IN argument == 3.
 333       int d = this->in_ % 4;
 334
 335       if (d != 3)
 336         {
 337           if (d == 1 && TAO_debug_level > 0)
 338             {
 339               ACE_DEBUG ((LM_DEBUG,
 340                           "Test_Exception::run_sii_test - "
 341                           "caught unknown exception - "
 342                           "expected known user exception\n"));
 343             }
 344           else if (d == 2 && TAO_debug_level > 0)
 345             {
 346               ACE_DEBUG ((LM_DEBUG,
 347                           "Test_Exception::run_sii_test - "
 348                           "caught unknown exception - "
 349                           "expected known system exception\n"));
 350             }
 351
 352           return -1;
 353         }
 354
 355       if (TAO_debug_level > 0)
 356         {
 357           ex._tao_print_exception (
 358             "Test_Exception::run_sii_test - ""expected unknown exception\n");
 359         }
 360
 361       // These weren't passed back because of the exception. We
 362       // set them here to the 'correct' values so the validity
 363       // check won't return an error.
 364       this->inout_ = this->in_ * 2;
 365       this->out_ = this->in_ * 3;
 366       this->ret_ = this->in_ * 4;
 367       return 0;
 368     }
 369   catch (const Param_Test::BadBoy& ex)
 370     {
 371       // We shouldn't end up here. See comment above.
 372       ex._tao_print_exception (
 373         "Test_Exception::run_sii_test - ""unexpected user exception\n");
 374
 375       return -1;
 376     }
 377
 378   // Normal reply - no exception thrown.
 379   return 0;
 380 }
 381
 382 CORBA::Boolean
 383 Test_Exception::check_validity ()
 384 {
 385   if (this->inout_ == this->in_ * 2 &&
 386       this->out_ == this->in_ * 3 &&
 387       this->ret_ == this->in_ * 4)
 388     {
 389       return 1;
 390     }
 391
 392   return 0;
 393 }
 394
 395 CORBA::Boolean
 396 Test_Exception::check_validity (CORBA::Request_ptr)
 397 {
 398   return this->check_validity ();
 399 }
 400
 401 void
 402 Test_Exception::print_values ()
 403 {
 404   ACE_DEBUG ((LM_DEBUG,
 405               "\n=*=*=*=*=*=*\n"
 406               "in = %d, "
 407               "inout = %d, "
 408               "out = %d, "
 409               "ret = %d\n"
 410               "\n=*=*=*=*=*=*\n",
 411               this->in_,
 412               this->inout_,
 413               this->out_,
 414               this->ret_));
 415 }