TAO/tests/Param_Test/big_union.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    big_union.cpp
   5  *
   6  *  tests Big_Unions
   7  *
   8  *  @author   Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12
  13 #include "helper.h"
  14 #include "big_union.h"
  15
  16 // ************************************************************************
  17 //               Test_Big_Union
  18 // ************************************************************************
  19
  20 size_t Test_Big_Union::counter = 0;
  21
  22 Test_Big_Union::Test_Big_Union ()
  23   : opname_ (CORBA::string_dup ("test_big_union"))
  24 {
  25 }
  26
  27 Test_Big_Union::~Test_Big_Union ()
  28 {
  29   CORBA::string_free (this->opname_);
  30   this->opname_ = 0;
  31 }
  32
  33 const char *
  34 Test_Big_Union::opname () const
  35 {
  36   return this->opname_;
  37 }
  38
  39 void
  40 Test_Big_Union::dii_req_invoke (CORBA::Request *req)
  41 {
  42   req->add_in_arg ("s1") <<= this->in_;
  43   req->add_inout_arg ("s2") <<= this->inout_;
  44   req->add_out_arg ("s3") <<= this->out_.in ();
  45
  46   req->set_return_type (Param_Test::_tc_Big_Union);
  47
  48   req->invoke ();
  49
  50   const Param_Test::Big_Union *tmp = 0;
  51   req->return_value () >>= tmp;
  52   this->ret_ = new Param_Test::Big_Union (*tmp);
  53
  54   CORBA::NamedValue_ptr o2 =
  55     req->arguments ()->item (1);
  56   *o2->value () >>= tmp;
  57   this->inout_ = *tmp;
  58
  59   CORBA::NamedValue_ptr o3 =
  60     req->arguments ()->item (2);
  61   *o3->value () >>= tmp;
  62   this->out_ = new Param_Test::Big_Union (*tmp);
  63 }
  64
  65 int
  66 Test_Big_Union::init_parameters (Param_Test_ptr objref)
  67 {
  68   try
  69     {
  70       // get access to a Coffee Object
  71       this->cobj_ = objref->make_coffee ();
  72
  73       this->reset_parameters ();
  74       return 0;
  75     }
  76   catch (const CORBA::SystemException& sysex)
  77     {
  78       sysex._tao_print_exception ("System Exception doing make_coffee");
  79     }
  80   catch (const CORBA::Exception& ex)
  81     {
  82       ex._tao_print_exception (
  83         "An exception caught in make_coffee");
  84     }
  85   return -1;
  86 }
  87
  88 int
  89 Test_Big_Union::reset_parameters ()
  90 {
  91   Generator *gen = GENERATOR::instance (); // value generator
  92   CORBA::ULong index = (counter++ % Test_Big_Union::BIG_UNION_N_BRANCHES);
  93
  94   switch (index)
  95     {
  96     case 0:
  97       {
  98         Param_Test::Fixed_Array x;
  99         for (CORBA::ULong i = 0; i < Param_Test::DIM1; ++i)
 100           {
 101             x[i] = gen->gen_long ();
 102           }
 103         this->in_.the_array (x);
 104         this->inout_.the_array (x);
 105       }
 106       break;
 107     case 1:
 108       {
 109         this->in_.the_interface (this->cobj_.in ());
 110         this->inout_.the_interface (this->cobj_.in ());
 111       }
 112       break;
 113     case 2:
 114       {
 115         CORBA::Long x = gen->gen_long ();
 116         this->in_.the_long (x);
 117         this->inout_.the_long (x);
 118       }
 119       break;
 120     case 3:
 121       {
 122         Param_Test::short_array x;
 123
 124         for (int i = 0; i < 32; ++i)
 125           {
 126             x[i] = gen->gen_short ();
 127           }
 128         this->in_.another_array (x);
 129         this->inout_.another_array (x);
 130       }
 131       break;
 132     case 4:
 133       {
 134         CORBA::String_var str = gen->gen_string ();
 135         this->in_.the_string (str);
 136         this->inout_.the_string (str);
 137       }
 138       break;
 139     case 5:
 140       {
 141         CORBA::ShortSeq seq;
 142         seq.length (gen->gen_short () % 50);
 143         for (size_t i = 0; i < seq.length (); i++)
 144           seq[i] = gen->gen_short ();
 145         this->in_.the_sequence (seq);
 146         this->inout_.the_sequence (seq);
 147       }
 148       break;
 149     case 6:
 150       {
 151         CORBA::Any any;
 152         any <<= CORBA::Short (25);
 153         this->in_.the_any (any);
 154         this->inout_.the_any (any);
 155       }
 156       break;
 157     case 7:
 158       {
 159         CORBA::Octet octet = gen->gen_short () % 255;
 160         this->in_.the_octet (octet);
 161         this->inout_.the_octet (octet);
 162       }
 163       break;
 164     case 8:
 165       {
 166         CORBA::Char x = '@';
 167         this->in_.the_char (x);
 168         this->inout_.the_char (x);
 169       }
 170       break;
 171     case 9:
 172       {
 173         CORBA::Boolean x = gen->gen_short () % 2;
 174         this->in_.the_boolean (x);
 175         this->inout_.the_boolean (x);
 176       }
 177       break;
 178     case 10:
 179       {
 180         Param_Test::Var_Struct var_struct;
 181         var_struct.dbl = 3.14159;
 182         var_struct.boole = gen->gen_short () % 2;
 183         var_struct.shrt = gen->gen_short ();
 184         // set the length of the sequence
 185         var_struct.dummy1 = gen->gen_string ();
 186         var_struct.dummy2 = gen->gen_string ();
 187         CORBA::ULong len = gen->gen_long () % 10 + 1;
 188         var_struct.seq.length (len);
 189         for (CORBA::ULong i = 0; i != len; ++i)
 190           {
 191             var_struct.seq[i] = gen->gen_string ();
 192           }
 193         this->in_.the_var_struct (var_struct);
 194         this->inout_.the_var_struct (var_struct);
 195       }
 196       break;
 197     case 11:
 198       {
 199         Param_Test::Fixed_Struct fixed_struct;
 200         fixed_struct.l = gen->gen_long ();
 201         fixed_struct.c = gen->gen_long () % 255;
 202         fixed_struct.s = gen->gen_long () % 32768;
 203         fixed_struct.o = gen->gen_long () % 255;
 204         fixed_struct.f = gen->gen_short () / 255.0f;
 205         fixed_struct.b = gen->gen_long () % 2;
 206         fixed_struct.d = gen->gen_short () / 255.0;
 207         this->in_.the_fixed_struct (fixed_struct);
 208         this->inout_.the_fixed_struct (fixed_struct);
 209       }
 210       break;
 211     }
 212   this->out_ = new Param_Test::Big_Union (this->in_);
 213   this->ret_ = new Param_Test::Big_Union (this->in_);
 214   return 0;
 215 }
 216
 217 int
 218 Test_Big_Union::run_sii_test (Param_Test_ptr objref)
 219 {
 220   try
 221     {
 222       this->ret_ = objref->test_big_union (this->in_,
 223                                            this->inout_,
 224                                            this->out_);
 225
 226       return 0;
 227     }
 228   catch (const CORBA::Exception& ex)
 229     {
 230       ex._tao_print_exception ("Test_Big_Union::run_sii_test\n");
 231     }
 232   return -1;
 233 }
 234
 235 CORBA::Boolean
 236 Test_Big_Union::check_validity ()
 237 {
 238   if (this->in_._d () != this->inout_._d ()
 239       || this->in_._d () != this->out_->_d ()
 240       || this->in_._d () != this->ret_->_d ())
 241     {
 242       ACE_DEBUG ((LM_DEBUG, "mismatch of discriminators\n"));
 243       return 0;
 244     }
 245
 246
 247   switch (this->in_._d ())
 248     {
 249     case 0:
 250       {
 251         Param_Test::Fixed_Array_slice* in_array    = this->in_.the_array ();
 252         Param_Test::Fixed_Array_slice* inout_array = this->inout_.the_array ();
 253         Param_Test::Fixed_Array_slice* out_array   = this->out_->the_array ();
 254         Param_Test::Fixed_Array_slice* ret_array   = this->ret_->the_array ();
 255         for (CORBA::ULong i = 0; i < Param_Test::DIM1; ++i)
 256           {
 257             if (in_array[i] != inout_array[i]
 258                 || in_array[i] != out_array[i]
 259                 || in_array[i] != ret_array[i])
 260               {
 261                 ACE_DEBUG ((LM_DEBUG,
 262                             "mismatch of arrays\n"));
 263                 return 0;
 264               }
 265           }
 266       }
 267       break;
 268     case 1:
 269       {
 270         try
 271           {
 272             Coffee_ptr in    = this->in_.the_interface ();
 273             Coffee_ptr inout = this->inout_.the_interface ();
 274             Coffee_ptr out   = this->out_->the_interface ();
 275             Coffee_ptr ret   = this->ret_->the_interface ();
 276
 277             if (CORBA::is_nil (in)
 278                 || CORBA::is_nil (inout)
 279                 || CORBA::is_nil (out)
 280                 || CORBA::is_nil (ret))
 281               return 0;
 282
 283             Coffee::Desc_var in_desc =
 284               in->description ();
 285             Coffee::Desc_var inout_desc =
 286               inout->description ();
 287             Coffee::Desc_var out_desc =
 288               out->description ();
 289             Coffee::Desc_var ret_desc =
 290               ret->description ();
 291
 292             if (ACE_OS::strcmp (in_desc->name.in (),
 293                                 inout_desc->name.in ())
 294                 || ACE_OS::strcmp (in_desc->name.in (),
 295                                    out_desc->name.in ())
 296                 || ACE_OS::strcmp (in_desc->name.in (),
 297                                    ret_desc->name.in ()))
 298               return 0;
 299           }
 300         catch (const CORBA::Exception&)
 301           {
 302             return 0;
 303           }
 304       }
 305       break;
 306     case 2:
 307       {
 308         CORBA::Long in    = this->in_.the_long ();
 309         CORBA::Long inout = this->inout_.the_long ();
 310         CORBA::Long out   = this->out_->the_long ();
 311         CORBA::Long ret   = this->ret_->the_long ();
 312
 313         if (in != out || in != inout || in != ret)
 314           {
 315             return 0;
 316           }
 317       }
 318       break;
 319     case 3:
 320       {
 321         Param_Test::short_array_slice* in_array    =
 322           this->in_.another_array ();
 323         Param_Test::short_array_slice* inout_array =
 324           this->inout_.another_array ();
 325         Param_Test::short_array_slice* out_array   =
 326           this->out_->another_array ();
 327         Param_Test::short_array_slice* ret_array   =
 328           this->ret_->another_array ();
 329
 330         for (int i = 0; i != 32; ++i)
 331           {
 332             if (in_array[i] != inout_array[i]
 333                 || in_array[i] != out_array[i]
 334                 || in_array[i] != ret_array[i])
 335               {
 336                 return 0;
 337               }
 338           }
 339       }
 340       break;
 341     case 4:
 342       {
 343         const char* in    = this->in_.the_string ();
 344         const char* inout = this->inout_.the_string ();
 345         const char* out   = this->out_->the_string ();
 346         const char* ret   = this->ret_->the_string ();
 347
 348         if (ACE_OS::strcmp (in,out)
 349             || ACE_OS::strcmp (in,inout)
 350             || ACE_OS::strcmp (in,ret))
 351           {
 352             return 0;
 353           }
 354       }
 355       break;
 356     case 5:
 357       {
 358         const CORBA::ShortSeq& in =
 359           this->in_.the_sequence ();
 360         const CORBA::ShortSeq& inout =
 361           this->inout_.the_sequence ();
 362         const CORBA::ShortSeq& out =
 363           this->out_->the_sequence ();
 364         const CORBA::ShortSeq& ret =
 365           this->ret_->the_sequence ();
 366
 367         if (in.length () != out.length ()
 368             || in.length () != inout.length ()
 369             || in.length () != ret.length ())
 370           return 0;
 371
 372         for (CORBA::ULong i = 0; i != in.length (); ++i)
 373           {
 374             if (in[i] != out[i]
 375                 || in[i] != inout[i]
 376                 || in[i] != ret[i])
 377               {
 378                 return 0;
 379               }
 380           }
 381       }
 382       break;
 383     case 6:
 384       {
 385         CORBA::Any in = this->in_.the_any ();
 386         CORBA::Any inout = this->inout_.the_any ();
 387         CORBA::Any out = this->out_->the_any ();
 388         CORBA::Any ret = this->ret_->the_any ();
 389
 390         CORBA::Short in_short;
 391         CORBA::Short inout_short;
 392         CORBA::Short out_short;
 393         CORBA::Short ret_short;
 394
 395         if (!(in >>= in_short)
 396             || !(inout >>= inout_short)
 397             || !(out >>= out_short)
 398             || !(ret >>= ret_short))
 399           {
 400             return 0;
 401           }
 402
 403         if (in_short != inout_short
 404             || in_short != out_short
 405             || in_short != ret_short)
 406           {
 407             return 0;
 408           }
 409       }
 410       break;
 411     case 7:
 412       {
 413         CORBA::Octet in    = this->in_.the_octet ();
 414         CORBA::Octet inout = this->inout_.the_octet ();
 415         CORBA::Octet out   = this->out_->the_octet ();
 416         CORBA::Octet ret   = this->ret_->the_octet ();
 417
 418         if (in != out || in != inout || in != ret)
 419           {
 420             return 0;
 421           }
 422       }
 423       break;
 424     case 8:
 425       {
 426         CORBA::Char in    = this->in_.the_char ();
 427         CORBA::Char inout = this->inout_.the_char ();
 428         CORBA::Char out   = this->out_->the_char ();
 429         CORBA::Char ret   = this->ret_->the_char ();
 430
 431         if (in != out || in != inout || in != ret)
 432           {
 433             return 0;
 434           }
 435       }
 436       break;
 437     case 9:
 438       {
 439         CORBA::Boolean in    = this->in_.the_boolean ();
 440         CORBA::Boolean inout = this->inout_.the_boolean ();
 441         CORBA::Boolean out   = this->out_->the_boolean ();
 442         CORBA::Boolean ret   = this->ret_->the_boolean ();
 443
 444         if (in != out || in != inout || in != ret)
 445           {
 446             return 0;
 447           }
 448       }
 449       break;
 450     case 10:
 451       {
 452         const Param_Test::Var_Struct& in =
 453           this->in_.the_var_struct ();
 454         const Param_Test::Var_Struct& inout =
 455           this->inout_.the_var_struct ();
 456         const Param_Test::Var_Struct& out =
 457           this->out_->the_var_struct ();
 458         const Param_Test::Var_Struct& ret =
 459           this->ret_->the_var_struct ();
 460
 461         if (!(ACE_OS::strcmp (in.dummy1.in (),
 462                               inout.dummy1.in ()) == 0
 463               && ACE_OS::strcmp (in.dummy2.in (),
 464                                  inout.dummy2.in ()) == 0)
 465             || !(ACE_OS::strcmp (in.dummy1.in (),
 466                                  out.dummy1.in ()) == 0
 467                && ACE_OS::strcmp (in.dummy2.in (),
 468                                   out.dummy2.in ()) == 0)
 469             || !(ACE_OS::strcmp (in.dummy1.in (),
 470                                  ret.dummy1.in ()) == 0
 471                && ACE_OS::strcmp (in.dummy2.in (),
 472                                   ret.dummy2.in ()) == 0))
 473           {
 474             return 0;
 475           }
 476
 477         if (in.seq.length () != inout.seq.length ()
 478             || in.seq.length () != out.seq.length ()
 479             || in.seq.length () != ret.seq.length ())
 480           {
 481             return 0;
 482           }
 483
 484         CORBA::ULong len = in.seq.length ();
 485
 486         for (CORBA::ULong i = 0; i != len; ++i)
 487           {
 488             if (ACE_OS::strcmp (in.seq[i],
 489                                 inout.seq[i])
 490                 || ACE_OS::strcmp (in.seq[i],
 491                                    out.seq[i])
 492                 || ACE_OS::strcmp (in.seq[i],
 493                                    ret.seq[i]))
 494               {
 495                 return 0;
 496               }
 497           }
 498       }
 499       break;
 500     case 11:
 501       {
 502         const Param_Test::Fixed_Struct& in =
 503           this->in_.the_fixed_struct ();
 504         const Param_Test::Fixed_Struct& inout =
 505           this->inout_.the_fixed_struct ();
 506         const Param_Test::Fixed_Struct& out =
 507           this->out_->the_fixed_struct ();
 508         const Param_Test::Fixed_Struct& ret =
 509           this->ret_->the_fixed_struct ();
 510
 511         if (! (in.l == inout.l
 512                && in.c == inout.c
 513                && in.s == inout.s
 514                && in.o == inout.o
 515                && ACE::is_equal (in.f, inout.f)
 516                && in.b == inout.b
 517                && ACE::is_equal (in.d, inout.d))
 518             || !(in.l == out.l
 519                  && in.c == out.c
 520                  && in.s == out.s
 521                  && in.o == out.o
 522                  && ACE::is_equal (in.f, out.f)
 523                  && in.b == out.b
 524                  && ACE::is_equal (in.d, out.d))
 525             || !(in.l == ret.l
 526                  && in.c == ret.c
 527                  && in.s == ret.s
 528                  && in.o == ret.o
 529                  && ACE::is_equal (in.f, ret.f)
 530                  && in.b == ret.b
 531                  && ACE::is_equal (in.d, ret.d)))
 532           {
 533             return 0;
 534           }
 535       }
 536       break;
 537     }
 538
 539   return 1;
 540 }
 541
 542 CORBA::Boolean
 543 Test_Big_Union::check_validity (CORBA::Request_ptr /*req*/)
 544 {
 545   //ACE_UNUSED_ARG (req);
 546   return this->check_validity ();
 547 }
 548
 549 void
 550 Test_Big_Union::print_values ()
 551 {
 552 }