TAO/tests/DynAny_Test/test_dynstruct.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    test_dynstruct.cpp
   4  *
   5  *  Implementation of the DynStruct basic test
   6  *
   7  *  @author Jeff Parsons <parsons@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11
  12 #include "test_dynstruct.h"
  13 #include "da_testsC.h"
  14 #include "data.h"
  15 #include "tao/DynamicAny/DynamicAny.h"
  16 #include "analyzer.h"
  17 #include "ace/OS_NS_string.h"
  18
  19 Test_DynStruct::Test_DynStruct (CORBA::ORB_var orb, int debug)
  20   : orb_ (orb),
  21     test_name_ (CORBA::string_dup ("test_dynstruct")),
  22     error_count_ (0),
  23     debug_ (debug)
  24 {
  25 }
  26
  27 Test_DynStruct::~Test_DynStruct ()
  28 {
  29   CORBA::string_free (this->test_name_);
  30   this->test_name_ = 0;
  31 }
  32
  33 const char*
  34 Test_DynStruct::test_name () const
  35 {
  36   return this->test_name_;
  37 }
  38
  39 int
  40 Test_DynStruct::run_test ()
  41 {
  42   Data data (this->orb_);
  43
  44   DynAnyTests::test_struct ts;
  45   ts.c = data.m_char2;
  46   ts.ss.length (0UL);
  47   ts.es.f = data.m_float2;
  48   ts.es.s = data.m_short2;
  49
  50   try
  51     {
  52       ACE_DEBUG ((LM_DEBUG,
  53                   "testing: constructor(Any)/insert/get/next/seek/"
  54                   "rewind/current_component\n"));
  55
  56       CORBA::Object_var factory_obj =
  57         this->orb_->resolve_initial_references ("DynAnyFactory");
  58
  59       DynamicAny::DynAnyFactory_var dynany_factory =
  60         DynamicAny::DynAnyFactory::_narrow (factory_obj.in ());
  61
  62       if (CORBA::is_nil (dynany_factory.in ()))
  63         {
  64           ACE_ERROR_RETURN ((LM_ERROR,
  65                              "Nil dynamic any factory after narrow\n"),
  66                             -1);
  67         }
  68
  69       DynAnyAnalyzer analyzer (this->orb_.in (),
  70                                dynany_factory.in (),
  71                                debug_);
  72
  73       CORBA::Any in_any1;
  74       in_any1 <<= ts;
  75       DynamicAny::DynAny_var dp1 =
  76         dynany_factory->create_dyn_any (in_any1);
  77
  78       DynamicAny::DynStruct_var fa1 =
  79         DynamicAny::DynStruct::_narrow (dp1.in ());
  80
  81       fa1->insert_char (data.m_char1);
  82
  83       fa1->next ();
  84
  85       fa1->insert_short_seq (data.m_shortseq1);
  86
  87       fa1->next ();
  88
  89       DynamicAny::DynAny_var cc =
  90         fa1->current_component ();
  91
  92       cc->insert_float (data.m_float1);
  93
  94       cc->next ();
  95
  96       cc->insert_short (data.m_short1);
  97       cc->rewind ();
  98
  99       // To show that calling destroy() on a component does
 100       // nothing, as required by the spec.
 101       cc->destroy ();
 102
 103       fa1->rewind ();
 104
 105       CORBA::Char c = fa1->get_char ();
 106
 107       if (c != data.m_char1)
 108         {
 109           ++this->error_count_;
 110         }
 111
 112       fa1->next ();
 113
 114       data.m_shortseq2 =
 115         fa1->get_short_seq ();
 116
 117       bool good =
 118         data.m_shortseq2->length () == data.m_shortseq1.length ();
 119
 120       if (good)
 121         {
 122           for (CORBA::ULong i = 0; i < data.m_shortseq1.length (); ++i)
 123             {
 124               if (data.m_shortseq2[i] != data.m_shortseq1[i])
 125                 {
 126                   ++this->error_count_;
 127                   break;
 128                 }
 129             }
 130         }
 131       else
 132         {
 133           ++this->error_count_;
 134         }
 135
 136       fa1->next ();
 137
 138       cc = fa1->current_component ();
 139
 140       cc->seek (1);
 141
 142       CORBA::Short s = cc->get_short ();
 143
 144       if (s != data.m_short1)
 145         {
 146           ++this->error_count_;
 147         }
 148
 149       if (this->error_count_ == 0)
 150         {
 151           ACE_DEBUG ((LM_DEBUG,
 152                       "++ OK ++\n"));
 153         }
 154
 155       ACE_DEBUG ((LM_DEBUG,
 156                   "testing: constructor(TypeCode)/from_any/to_any\n"));
 157
 158       DynamicAny::DynAny_var ftc1_base =
 159         dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_test_struct);
 160
 161       DynamicAny::DynStruct_var ftc1 =
 162         DynamicAny::DynStruct::_narrow (ftc1_base.in ());
 163
 164       if (CORBA::is_nil (ftc1.in ()))
 165         {
 166           ACE_ERROR_RETURN ((LM_ERROR,
 167                              "DynStruct::_narrow() returned nil\n"),
 168                             -1);
 169         }
 170
 171       ts.c = data.m_char1;
 172       ts.ss.length (0UL);
 173       ts.es.f = data.m_float1;
 174       ts.es.s = data.m_short1;
 175       CORBA::Any in_any2;
 176       in_any2 <<= ts;
 177       ftc1->from_any (in_any2);
 178
 179       analyzer.analyze (ftc1.in ());
 180
 181       CORBA::Any_var out_any1 =
 182         ftc1->to_any ();
 183
 184       const DynAnyTests::test_struct* ts_out = 0;
 185       out_any1.in () >>= ts_out;
 186
 187       if (ts_out->es.s == data.m_short1)
 188         {
 189           ACE_DEBUG ((LM_DEBUG,
 190                       "++ OK ++\n"));
 191         }
 192       else
 193         {
 194           ++this->error_count_;
 195         }
 196
 197       ACE_DEBUG ((LM_DEBUG,
 198                   "testing: constructor(TypeCode alias)/from_any/to_any\n"));
 199
 200
 201       const DynAnyTests::test_struct *ts_out2 = 0;
 202       CORBA::Any_var out_any2 ;
 203       DynamicAny::DynStruct_var ftc2;
 204
 205       try
 206         {
 207           DynamicAny::DynAny_var ftc2_base =
 208             dynany_factory->create_dyn_any_from_type_code (
 209                                 DynAnyTests::_tc_test_struct_alias);
 210
 211           ftc2 = DynamicAny::DynStruct::_narrow (ftc2_base.in ());
 212
 213           if (CORBA::is_nil (ftc2.in ()))
 214             {
 215               ACE_ERROR_RETURN ((LM_ERROR,
 216                                  "DynStruct::_narrow() returned nil\n"),
 217                                 -1);
 218             }
 219
 220           ts.c = data.m_char1;
 221           ts.ss.length (0UL);
 222           ts.es.f = data.m_float1;
 223           ts.es.s = data.m_short1;
 224           CORBA::Any in_any3;
 225           in_any3 <<= ts;
 226           ftc2->from_any (in_any3);
 227
 228 //          char c = ftc2->get_char ();
 229 //          CORBA::Boolean status = ftc2->next ();
 230 //          CORBA::Long lo = ftc2->get_long ();
 231 //          analyzer.analyze (ftc2.in ());
 232
 233           out_any2 = ftc2->to_any ();
 234
 235           if (!(out_any2.in () >>= ts_out2)) // problem
 236             {
 237               ts_out2 = 0;
 238             }
 239         }
 240       catch (const CORBA::TypeCode::BadKind& )
 241         {
 242         }
 243
 244       if (ts_out2 != 0 && ts_out2->es.s == data.m_short1)
 245         {
 246           ACE_DEBUG ((LM_DEBUG,
 247                       "++ OK ++\n"));
 248         }
 249       else
 250         {
 251           ++this->error_count_;
 252         }
 253
 254
 255       ACE_DEBUG ((LM_DEBUG,
 256                   "testing: current_member_name/current_member_kind\n"));
 257
 258       ftc1->seek (2);
 259
 260       DynamicAny::FieldName_var fn =
 261         ftc1->current_member_name ();
 262
 263       if (ACE_OS::strcmp (fn.in (), "es"))
 264         {
 265           ++this->error_count_;
 266         }
 267
 268       CORBA::TCKind tk =
 269         ftc1->current_member_kind ();
 270
 271       if (tk != CORBA::tk_struct)
 272         {
 273           ++this->error_count_;
 274         }
 275
 276       if (this->error_count_ == 0)
 277         {
 278           ACE_DEBUG ((LM_DEBUG,
 279                       "++ OK ++\n"));
 280         }
 281
 282       ACE_DEBUG ((LM_DEBUG,
 283                   "testing: current_member_name/current_member_kind "
 284                   "with alias\n"));
 285       ftc2->seek (2);
 286
 287       DynamicAny::FieldName_var fn2 =
 288         ftc2->current_member_name ();
 289
 290       if (ACE_OS::strcmp (fn2.in (), "es"))
 291         {
 292           ++this->error_count_;
 293         }
 294
 295       CORBA::TCKind tk2 =
 296         ftc2->current_member_kind ();
 297
 298       if (tk2 != CORBA::tk_struct)
 299         {
 300           ++this->error_count_;
 301         }
 302
 303       if (this->error_count_ == 0)
 304         {
 305           ACE_DEBUG ((LM_DEBUG,
 306                      "++ OK ++\n"));
 307         }
 308
 309       ACE_DEBUG ((LM_DEBUG,
 310                   "testing: get_members/set_members\n"));
 311
 312       DynamicAny::NameValuePairSeq_var nvps =
 313         fa1->get_members ();
 314
 315       DynamicAny::DynAny_var sm_base =
 316         dynany_factory->create_dyn_any_from_type_code (
 317             DynAnyTests::_tc_test_struct);
 318
 319       DynamicAny::DynStruct_var sm =
 320         DynamicAny::DynStruct::_narrow (sm_base.in ());
 321
 322       if (CORBA::is_nil (sm.in ()))
 323         {
 324           ACE_ERROR_RETURN ((LM_ERROR,
 325                              "DynStruct::_narrow()[2] returned nil\n"),
 326                             -1);
 327         }
 328
 329       sm->set_members (nvps.in ());
 330
 331       DynamicAny::NameValuePairSeq_var gm =
 332         sm->get_members ();
 333
 334       CORBA::ULong index = 2;
 335
 336       if (ACE_OS::strcmp (gm[index].id, "es"))
 337         {
 338           ++this->error_count_;
 339         }
 340
 341       fa1->destroy ();
 342
 343       ftc1->destroy ();
 344
 345       sm->destroy ();
 346
 347       ACE_DEBUG ((LM_DEBUG,
 348                 "++ OK ++\n"));
 349
 350       ACE_DEBUG ((LM_DEBUG,
 351                  "testing: struct_with_long_double destroy\n"));
 352
 353       // Test fix for bug on destroy when struct contains long_double value.
 354       DynAnyTests::test_struct_with_long_double l_long_double_in_struct;
 355
 356       CORBA::Any corba_long_double;
 357       corba_long_double <<= l_long_double_in_struct;
 358
 359       DynamicAny::DynAny_var l_dynany = dynany_factory->create_dyn_any (corba_long_double);
 360       try
 361       {
 362         l_dynany->destroy ();
 363         ACE_DEBUG ((LM_DEBUG,
 364           "++ OK ++\n"));
 365       }
 366       catch (...)
 367       {
 368         ++this->error_count_;
 369       }
 370     }
 371   catch (const CORBA::Exception& ex)
 372     {
 373       ex._tao_print_exception ("test_dynstruct::run_test");
 374       ++this->error_count_;
 375     }
 376
 377   ACE_DEBUG ((LM_DEBUG,
 378               "\n%d errors\n",
 379               this->error_count_));
 380
 381   return !!error_count_;
 382 }