TAO/tests/DynAny_Test/test_dynany.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    test_dynany.cpp
   4  *
   5  *  Implementation of the basic test for simple DynAnys
   6  *
   7  *  @author Jeff Parsons <parsons@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
  12 #include "tao/AnyTypeCode/ShortSeqA.h"
  13 #include "tao/DynamicAny/DynamicAny.h"
  14
  15 #include "test_dynany.h"
  16 #include "data.h"
  17 #include "analyzer.h"
  18
  19 Test_DynAny::Test_DynAny (CORBA::ORB_var orb, int debug)
  20   : orb_ (orb),
  21     test_name_ (CORBA::string_dup ("test_dynany")),
  22     error_count_ (0),
  23     debug_ (debug)
  24 {
  25 }
  26
  27 Test_DynAny::~Test_DynAny ()
  28 {
  29   CORBA::string_free (this->test_name_);
  30   this->test_name_ = 0;
  31 }
  32
  33 const char*
  34 Test_DynAny::test_name () const
  35 {
  36   return this->test_name_;
  37 }
  38
  39 int
  40 Test_DynAny::run_test ()
  41 {
  42   Data data (this->orb_);
  43
  44   try
  45     {
  46       CORBA::Object_var factory_obj =
  47         this->orb_->resolve_initial_references ("DynAnyFactory");
  48
  49       DynamicAny::DynAnyFactory_var dynany_factory =
  50         DynamicAny::DynAnyFactory::_narrow (factory_obj.in ());
  51
  52       if (CORBA::is_nil (dynany_factory.in ()))
  53         {
  54           ACE_ERROR_RETURN ((LM_ERROR,
  55                              "Nil dynamic any factory after narrow\n"),
  56                             -1);
  57         }
  58
  59       DynAnyAnalyzer analyzer (this->orb_.in (),
  60                                dynany_factory.in (),
  61                                debug_);
  62       {
  63         ACE_DEBUG ((LM_DEBUG,
  64                     "\t*=*=*=*= %C =*=*=*=*\n",
  65                     data.labels[8]));
  66
  67         ACE_DEBUG ((LM_DEBUG,
  68                     "testing: constructor(Any)/insert/get\n"));
  69
  70         CORBA::Any in1;
  71         in1 <<= data.m_double2;
  72         DynamicAny::DynAny_var fa1 =
  73           dynany_factory->create_dyn_any (in1);
  74
  75         if (fa1->equal(fa1.in ()))
  76           {
  77             ACE_DEBUG ((LM_DEBUG,
  78                         "++ OK ++\n"));
  79           }
  80         else
  81           {
  82             ACE_DEBUG ((LM_DEBUG,
  83                         "Double Not equal\n"));
  84             ++this->error_count_;
  85           }
  86         fa1->insert_double (data.m_double1);
  87
  88         CORBA::Double d_out =
  89           fa1->get_double ();
  90
  91         if (ACE::is_equal (d_out, data.m_double1))
  92           {
  93             ACE_DEBUG ((LM_DEBUG,
  94                         "++ OK ++\n"));
  95           }
  96         else
  97           {
  98             ++this->error_count_;
  99           }
 100
 101         ACE_DEBUG ((LM_DEBUG,
 102                     "testing: constructor(TypeCode)/from_any/to_any\n"));
 103
 104         d_out = data.m_double2;
 105         DynamicAny::DynAny_var ftc1 =
 106           dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_double);
 107         CORBA::Any in_any1;
 108         in_any1 <<= data.m_double1;
 109         ftc1->from_any (in_any1);
 110         analyzer.analyze (ftc1.in());
 111         CORBA::Any_var out_any1 = ftc1->to_any ();
 112         out_any1 >>= d_out;
 113
 114         if (ACE::is_equal (d_out, data.m_double1))
 115           {
 116             ACE_DEBUG ((LM_DEBUG,
 117                         "++ OK ++\n"));
 118           }
 119         else
 120           {
 121             ++this->error_count_;
 122           }
 123
 124         fa1->destroy ();
 125         ftc1->destroy ();
 126       }
 127
 128       {
 129         ACE_DEBUG ((LM_DEBUG,
 130                     "\t*=*=*=*= %C =*=*=*=*\n",
 131                     data.labels[17]));
 132
 133         ACE_DEBUG ((LM_DEBUG,
 134                     "testing: constructor(Any)/insert/get\n"));
 135
 136         CORBA::Any in1;
 137         in1 <<= data.m_longdouble2;
 138         DynamicAny::DynAny_var fa1 =
 139           dynany_factory->create_dyn_any (in1);
 140
 141         if (fa1->equal(fa1.in ()))
 142           {
 143             ACE_DEBUG ((LM_DEBUG,
 144                         "++ OK ++\n"));
 145           }
 146         else
 147           {
 148             ACE_DEBUG ((LM_DEBUG,
 149                         "Long Double Not equal\n"));
 150             ++this->error_count_;
 151           }
 152
 153         fa1->insert_longdouble (data.m_longdouble1);
 154
 155         CORBA::LongDouble d_out = fa1->get_longdouble ();
 156
 157         if (ACE::is_equal (d_out, data.m_longdouble1))
 158           {
 159             ACE_DEBUG ((LM_DEBUG,
 160                         "++ OK ++\n"));
 161           }
 162         else
 163           {
 164             ++this->error_count_;
 165           }
 166
 167         ACE_DEBUG ((LM_DEBUG,
 168                     "testing: constructor(TypeCode)/from_any/to_any\n"));
 169
 170         d_out = data.m_longdouble2;
 171         DynamicAny::DynAny_var ftc1 =
 172           dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_longdouble);
 173
 174         CORBA::Any in_any1;
 175         in_any1 <<= data.m_longdouble1;
 176         ftc1->from_any (in_any1);
 177
 178         analyzer.analyze(ftc1.in());
 179
 180         CORBA::Any_var out_any1 = ftc1->to_any ();
 181
 182         out_any1.in() >>= d_out;
 183
 184         if (ACE::is_equal (d_out, data.m_longdouble1))
 185           {
 186             ACE_DEBUG ((LM_DEBUG,
 187                         "++ OK ++\n"));
 188           }
 189         else
 190           {
 191             ++this->error_count_;
 192           }
 193
 194         fa1->destroy ();
 195         ftc1->destroy ();
 196       }
 197
 198       ACE_DEBUG ((LM_DEBUG,
 199                   "\t*=*=*=*= %C =*=*=*=*\n",
 200                   data.labels[12]));
 201
 202       ACE_DEBUG ((LM_DEBUG,
 203                   "testing: constructor(Any)/insert/get\n"));
 204
 205       CORBA::Any in;
 206       in <<= data.m_typecode2;
 207       DynamicAny::DynAny_var fa2 =
 208         dynany_factory->create_dyn_any (in);
 209       fa2->insert_typecode (data.m_typecode1);
 210       CORBA::TypeCode_var tc_out =
 211         fa2->get_typecode ();
 212
 213       if (tc_out->equal (data.m_typecode1))
 214         {
 215           ACE_DEBUG ((LM_DEBUG,
 216                       "++ OK ++\n"));
 217         }
 218       else
 219         {
 220           ++this->error_count_;
 221         }
 222
 223
 224       ACE_DEBUG ((LM_DEBUG,
 225                   "testing: constructor(TypeCode)/from_any/to_any\n"));
 226
 227       DynamicAny::DynAny_var ftc2 =
 228         dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_TypeCode);
 229       CORBA::Any in_any2;
 230       in_any2 <<= data.m_typecode1;
 231       ftc2->from_any (in_any2);
 232       analyzer.analyze (ftc2.in());
 233       CORBA::Any_var out_any2 = ftc2->to_any ();
 234       CORBA::TypeCode_ptr out_tc;
 235       out_any2 >>= out_tc;
 236
 237       CORBA::Boolean equal = out_tc->equal (data.m_typecode1);
 238
 239       if (equal)
 240         {
 241           ACE_DEBUG ((LM_DEBUG,
 242                       "++ OK ++\n"));
 243         }
 244       else
 245         {
 246           ++this->error_count_;
 247         }
 248
 249
 250       fa2->destroy ();
 251       ftc2->destroy ();
 252
 253       ACE_DEBUG ((LM_DEBUG,
 254                   "\t*=*=*=*= %C =*=*=*=*\n",
 255                   data.labels[16]));
 256
 257       ACE_DEBUG ((LM_DEBUG,
 258                   "testing: constructor(Any)/insert/get\n"));
 259
 260       CORBA::Any in3;
 261       CORBA::ShortSeq ss;
 262       ss.length (0UL);
 263       in3 <<= ss;
 264       DynamicAny::DynAny_var fa3 =
 265         dynany_factory->create_dyn_any (in3);
 266       fa3->insert_short_seq (data.m_shortseq1);
 267       data.m_shortseq2 =
 268         fa3->get_short_seq ();
 269
 270       bool good =
 271         data.m_shortseq2->length () == data.m_shortseq1.length ();
 272
 273       if (good)
 274         {
 275           for (CORBA::ULong i = 0; i < data.m_shortseq1.length (); ++i)
 276             {
 277               if (data.m_shortseq2[i] != data.m_shortseq1[i])
 278                 {
 279                   good = false;
 280                   break;
 281                 }
 282             }
 283         }
 284
 285       if (good)
 286         {
 287           ACE_DEBUG ((LM_DEBUG,
 288                       "++ OK ++\n"));
 289         }
 290       else
 291         {
 292           ++this->error_count_;
 293         }
 294
 295
 296       ACE_DEBUG ((LM_DEBUG,
 297                   "testing: constructor(TypeCode)/from_any/to_any\n"));
 298
 299       DynamicAny::DynAny_var ftc3 =
 300         dynany_factory->create_dyn_any_from_type_code (CORBA::_tc_ShortSeq);
 301       CORBA::Any in_any3;
 302       in_any3 <<= data.m_shortseq1;
 303       ftc3->from_any (in_any3);
 304       analyzer.analyze (ftc3.in ());
 305       CORBA::Any_var out_any3 = ftc3->to_any ();
 306
 307       const CORBA::ShortSeq *outseq = 0;
 308       out_any3.in () >>= outseq;
 309
 310       good =
 311         outseq->length () == data.m_shortseq1.length ();
 312
 313       if (good)
 314         {
 315           for (CORBA::ULong i = 0; i < data.m_shortseq1.length (); ++i)
 316             {
 317               if ((*outseq)[i] != data.m_shortseq1[i])
 318                 {
 319                   good = false;
 320                   break;
 321                 }
 322             }
 323         }
 324
 325       if (good)
 326         {
 327           ACE_DEBUG ((LM_DEBUG,
 328                       "++ OK ++\n"));
 329         }
 330       else
 331         {
 332           ++this->error_count_;
 333         }
 334
 335       fa3->destroy ();
 336       ftc3->destroy ();
 337
 338       ACE_DEBUG ((LM_DEBUG,
 339                   "testing: equal\n"));
 340
 341       // Simple equal to self test for basic sequence
 342       // Check equal to self, not equal for different length
 343       // not equal for different values
 344       CORBA::Any in4;
 345       in4 <<= data.m_shortseq1;
 346       DynamicAny::DynAny_var fa4 =
 347         dynany_factory->create_dyn_any (in4);
 348
 349       // is equal to self
 350       good = fa4->equal(fa4.in ());
 351
 352       CORBA::ShortSeq ss5;
 353       ss5.length(1);
 354       ss5[0] = 5;
 355       CORBA::Any in5;
 356       in5 <<= ss5;
 357       DynamicAny::DynAny_var fa5 =
 358         dynany_factory->create_dyn_any (in5);
 359
 360       // is not equal for different lengths
 361       good = good && !fa4->equal(fa5.in ());
 362
 363       CORBA::ShortSeq ss6(data.m_shortseq1);
 364       ss6[0]++;
 365       CORBA::Any in6;
 366       in6 <<= ss6;
 367
 368       DynamicAny::DynAny_var fa6 =
 369         dynany_factory->create_dyn_any (in6);
 370
 371       // is not equal for different values
 372       good = good && !fa4->equal(fa6.in ());
 373
 374
 375       CORBA::Any in7;
 376       in7 <<= data.m_shortseq1;
 377       DynamicAny::DynAny_var fa7 =
 378         dynany_factory->create_dyn_any (in7);
 379
 380
 381       // is equal to identical sequence, not self
 382       good = good && fa4->equal(fa7.in ());
 383
 384
 385       if (good)
 386         {
 387           ACE_DEBUG ((LM_DEBUG,
 388                       "++ OK ++\n"));
 389         }
 390       else
 391         {
 392           ++this->error_count_;
 393         }
 394
 395     }
 396   catch (const CORBA::Exception& ex)
 397     {
 398       ex._tao_print_exception ("test_dynany::run_test");
 399       ++this->error_count_;
 400     }
 401
 402   ACE_DEBUG ((LM_DEBUG,
 403               "\n%d errors\n",
 404               this->error_count_));
 405
 406   return error_count_;
 407 }