TAO/tests/DynAny_Test/test_dynunion.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    test_dynunion.cpp
   4  *
   5  *  Implementation of the simple DynUnion test
   6  *
   7  *  @author Jeff Parsons <parsons@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11 #include "da_testsC.h"
  12 #include "test_dynunion.h"
  13 #include "data.h"
  14 #include "analyzer.h"
  15 #include "tao/DynamicAny/DynamicAny.h"
  16 #include "ace/OS_NS_string.h"
  17
  18 Test_DynUnion::Test_DynUnion (CORBA::ORB_var orb, int debug)
  19   : orb_ (orb),
  20     test_name_ (CORBA::string_dup ("test_dynunion")),
  21     error_count_ (0),
  22     debug_ (debug)
  23 {
  24 }
  25
  26 Test_DynUnion::~Test_DynUnion ()
  27 {
  28   CORBA::string_free (this->test_name_);
  29   this->test_name_ = 0;
  30 }
  31
  32 const char*
  33 Test_DynUnion::test_name () const
  34 {
  35   return this->test_name_;
  36 }
  37
  38 int
  39 Test_DynUnion::run_test ()
  40 {
  41   Data data (this->orb_);
  42
  43   DynAnyTests::test_union tu;
  44
  45   try
  46     {
  47       ACE_DEBUG ((LM_DEBUG,
  48                  "\t*=*=*=*= %C =*=*=*=*\n",
  49                  data.labels[12]));
  50
  51       CORBA::Object_var factory_obj =
  52         this->orb_->resolve_initial_references ("DynAnyFactory");
  53
  54       DynamicAny::DynAnyFactory_var dynany_factory =
  55         DynamicAny::DynAnyFactory::_narrow (factory_obj.in ());
  56
  57       if (CORBA::is_nil (dynany_factory.in ()))
  58         {
  59           ACE_ERROR_RETURN ((LM_ERROR,
  60                              "Nil dynamic any factory after narrow\n"),
  61                             -1);
  62         }
  63
  64       DynAnyAnalyzer analyzer(this->orb_.in(), dynany_factory.in(), debug_);
  65
  66       ACE_DEBUG ((LM_DEBUG,
  67                  "testing: constructor(Any)/from_any/to_any with string\n"));
  68
  69       DynAnyTests::test_union tstring;
  70       tstring._d (DynAnyTests::TE_THIRD);
  71       tstring.str (CORBA::string_dup (data.m_string1));
  72       CORBA::Any in_any4;
  73       in_any4 <<= tstring;
  74       DynamicAny::DynAny_var dp4 =
  75         dynany_factory->create_dyn_any (in_any4);
  76       DynamicAny::DynUnion_var fa4 =
  77         DynamicAny::DynUnion::_narrow (dp4.in ());
  78
  79       analyzer.analyze(fa4.in());
  80
  81       CORBA::Any_var out_any5 = fa4->to_any ();
  82
  83       DynamicAny::DynAny_var dp5 =
  84         dynany_factory->create_dyn_any (out_any5.in());
  85
  86       ACE_DEBUG ((LM_DEBUG,
  87                  "testing: constructor(Any)/insert/get\n"));
  88
  89       tu._d (DynAnyTests::TE_SECOND);
  90       tu.tc (data.m_typecode2);
  91       CORBA::Any in_any1;
  92       in_any1 <<= tu;
  93       DynamicAny::DynAny_var dp1 =
  94         dynany_factory->create_dyn_any (in_any1);
  95       DynamicAny::DynUnion_var fa1 =
  96         DynamicAny::DynUnion::_narrow (dp1.in ());
  97       fa1->seek (1);
  98       fa1->insert_typecode (data.m_typecode1);
  99
 100       CORBA::TypeCode_var s_out1 = fa1->get_typecode ();
 101
 102       CORBA::Boolean const equal_tc1 =
 103         s_out1->equal (data.m_typecode1);
 104
 105       if (equal_tc1)
 106         {
 107           ACE_DEBUG ((LM_DEBUG,
 108                      "++ OK ++\n"));
 109         }
 110       else
 111         {
 112           ++this->error_count_;
 113         }
 114
 115       ACE_DEBUG ((LM_DEBUG,
 116                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 117
 118       analyzer.analyze (fa1.in());
 119
 120       CORBA::Any_var out_any1 = fa1->to_any ();
 121       DynamicAny::DynAny_var ftc1_base =
 122         dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_union);
 123
 124       DynamicAny::DynUnion_var ftc1 =
 125         DynamicAny::DynUnion::_narrow (ftc1_base.in ());
 126
 127       if (CORBA::is_nil (ftc1.in ()))
 128         {
 129           ACE_ERROR_RETURN ((LM_ERROR,
 130                              "DynUnion::_narrow() returned nil\n"),
 131                             -1);
 132         }
 133
 134       ftc1->from_any (out_any1.in ());
 135
 136       ftc1->seek (1);
 137
 138       CORBA::TypeCode_var s_out2 =
 139         ftc1->get_typecode ();
 140
 141       CORBA::Boolean const equal_tc2 =
 142         s_out2->equal (data.m_typecode1);
 143
 144       if (equal_tc2)
 145         {
 146           ACE_DEBUG ((LM_DEBUG,
 147                      "++ OK ++\n"));
 148         }
 149       else
 150         {
 151           ++this->error_count_;
 152         }
 153
 154       ACE_DEBUG ((LM_DEBUG,
 155                  "testing: constructor(TypeCode alias)/from_any/to_any\n"));
 156
 157       analyzer.analyze( fa1.in());
 158
 159       CORBA::Any_var out_any2 = fa1->to_any ();
 160
 161       CORBA::TypeCode_var s_out3;
 162
 163       try
 164         {
 165           DynamicAny::DynAny_var ftc2_base =
 166             dynany_factory->create_dyn_any_from_type_code
 167             (DynAnyTests::_tc_test_union_alias);
 168
 169           DynamicAny::DynUnion_var ftc2 =
 170             DynamicAny::DynUnion::_narrow (ftc2_base.in ());
 171
 172           if (CORBA::is_nil (ftc2.in ()))
 173             {
 174               ACE_ERROR_RETURN ((LM_ERROR,
 175                                  "DynUnion::_narrow() returned nil\n"),
 176                                 -1);
 177             }
 178
 179           ftc2->from_any (out_any2.in ());
 180
 181           ftc2->seek (1);
 182
 183           s_out3 = ftc2->get_typecode ();
 184         }
 185       catch (const CORBA::TypeCode::BadKind& )
 186         {
 187           // Failed to create
 188         }
 189
 190       if (!CORBA::is_nil (s_out3.in ()))
 191         {
 192           CORBA::Boolean const equal_tc =
 193             s_out3->equal (data.m_typecode1);
 194
 195           if (equal_tc)
 196             {
 197               ACE_DEBUG ((LM_DEBUG,
 198                           "++ OK ++\n"));
 199             }
 200           else
 201             {
 202               ++this->error_count_;
 203             }
 204         }
 205       else
 206         {
 207           ++this->error_count_;
 208         }
 209
 210       ACE_DEBUG ((LM_DEBUG,
 211                  "testing:discriminator/discriminator_kind\n"));
 212
 213       DynamicAny::DynAny_var dp2 =
 214         ftc1->get_discriminator ();
 215
 216       CORBA::TypeCode_var tc2 =
 217         dp2->type ();
 218
 219       CORBA::TCKind tc1kind =
 220         ftc1->discriminator_kind ();
 221
 222       CORBA::TCKind tc2kind = tc2->kind ();
 223
 224       if (tc2kind == tc1kind)
 225         {
 226           ACE_DEBUG ((LM_DEBUG,
 227                      "++ OK ++\n"));
 228         }
 229       else
 230         {
 231           ++this->error_count_;
 232         }
 233
 234       ACE_DEBUG ((LM_DEBUG,
 235                  "testing:member/member_kind/member_name\n"));
 236
 237       DynamicAny::DynAny_var dp3 =
 238         ftc1->member ();
 239
 240       CORBA::String_var m_nm =
 241         ftc1->member_name ();
 242
 243       CORBA::TCKind tk =
 244         ftc1->member_kind ();
 245
 246       CORBA::TypeCode_var tc3 =
 247         dp3->get_typecode ();
 248
 249       CORBA::Boolean const equal_tc3 =
 250         data.m_typecode1->equal (tc3.in ());
 251
 252       if (!ACE_OS::strcmp (m_nm.in (), "tc")
 253           && tk == CORBA::tk_TypeCode
 254           && equal_tc3)
 255         {
 256           ACE_DEBUG ((LM_DEBUG,
 257                      "++ OK ++\n"));
 258         }
 259       else
 260         {
 261           ++this->error_count_;
 262         }
 263
 264       ACE_DEBUG ((LM_DEBUG,
 265                  "testing: set_to_default_member\n"));
 266
 267       ftc1->set_to_default_member ();
 268
 269       ftc1->seek (1);
 270
 271       ftc1->insert_short (data.m_short1);
 272
 273       DynamicAny::DynAny_var mem =
 274         ftc1->member ();
 275
 276       CORBA::Short out_s =
 277         mem->get_short ();
 278
 279       if (out_s == data.m_short1)
 280         {
 281           ACE_DEBUG ((LM_DEBUG,
 282                       "++ OK ++\n"));
 283         }
 284       else
 285         {
 286           ++this->error_count_;
 287         }
 288
 289       fa1->destroy ();
 290
 291       ftc1->destroy ();
 292
 293       ACE_DEBUG ((LM_DEBUG,
 294                  "testing: create_dyn_any with _default()\n"));
 295       DynAnyTests::test_implicit_def test_implicit_def_union;
 296       CORBA::Any any_union;
 297
 298       test_implicit_def_union._default();
 299
 300       any_union <<= test_implicit_def_union;
 301
 302       DynamicAny::DynAny_var da_union =
 303         dynany_factory->create_dyn_any (any_union);
 304       ACE_DEBUG ((LM_DEBUG,
 305                   "++ OK ++\n"));
 306
 307       ACE_DEBUG ((LM_DEBUG,
 308                  "testing: union_no_active_member destroy\n"));
 309
 310       // Test fix for bug on destroy when there is no active member in union.
 311       DynAnyTests::test_union_no_active_member l_union_value_no_active_member;
 312
 313       CORBA::Any corba_union;
 314       corba_union <<= l_union_value_no_active_member;
 315
 316       DynamicAny::DynAny_var l_dynany = dynany_factory->create_dyn_any (corba_union);
 317       try
 318       {
 319         l_dynany->destroy ();
 320         ACE_DEBUG ((LM_DEBUG,
 321                     "++ OK ++\n"));
 322       }
 323       catch (...)
 324       {
 325         ++this->error_count_;
 326       }
 327
 328
 329       // if we get here the create_dyn_any worked.
 330     }
 331   catch (const CORBA::Exception& ex)
 332     {
 333       ex._tao_print_exception ("test_dynunion::run_test");
 334       ++this->error_count_;
 335     }
 336
 337   ACE_DEBUG ((LM_DEBUG,
 338               "\n%d errors\n",
 339               this->error_count_));
 340
 341   return !!error_count_;
 342 }