TAO/tests/DynAny_Test/test_dynsequence.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    test_dynsequence.cpp
   4  *
   5  *  Implementation of the simple DynSequence test
   6  *
   7  *  @author Jeff Parsons <jp4@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11
  12 #include "test_dynsequence.h"
  13 #include "da_testsC.h"
  14 #include "data.h"
  15 #include "analyzer.h"
  16 #include "tao/DynamicAny/DynamicAny.h"
  17 #include "ace/OS_NS_string.h"
  18
  19 namespace
  20 {
  21
  22 bool
  23 compare_string_sequence_elements(
  24     CORBA::ULong i,
  25     DynamicAny::DynAnySeq const & lhs,
  26     DynamicAny::DynAnySeq const & rhs)
  27 {
  28     CORBA::String_var lhs_string = lhs[i]->get_string ();
  29
  30     ACE_DEBUG ((LM_DEBUG, "elem[%d] = %C\n", i, lhs_string.in()));
  31
  32     CORBA::Boolean match =
  33         lhs[i]->equal (rhs[i]);
  34
  35     if (!match)
  36     {
  37         CORBA::String_var rhs_string =
  38             rhs[i]->get_string();
  39
  40         ACE_DEBUG ((LM_DEBUG,
  41                     "  mismatch with elements[%d] = %C\n", i,
  42                     rhs_string.in() ));
  43     }
  44
  45     return match;
  46 }
  47 }
  48
  49 Test_DynSequence::Test_DynSequence (CORBA::ORB_var orb, int debug)
  50   : orb_ (orb),
  51     test_name_ (CORBA::string_dup ("test_dynsequence")),
  52     error_count_ (0),
  53     debug_ (debug)
  54 {
  55 }
  56
  57 Test_DynSequence::~Test_DynSequence (void)
  58 {
  59   CORBA::string_free (this->test_name_);
  60   this->test_name_ = 0;
  61 }
  62
  63 const char*
  64 Test_DynSequence::test_name (void) const
  65 {
  66   return this->test_name_;
  67 }
  68
  69 int
  70 Test_DynSequence::run_test (void)
  71 {
  72   Data data (this->orb_);
  73   DynAnyTests::test_seq ts (2);
  74   ts.length (2);
  75
  76     try
  77     {
  78       ACE_DEBUG ((LM_DEBUG,
  79                  "\t*=*=*=*= %C =*=*=*=*\n",
  80                  data.labels[11]));
  81
  82       ACE_DEBUG ((LM_DEBUG,
  83                  "testing: constructor(Any)/insert/get/seek/"
  84                  "rewind/current_component\n"));
  85
  86       CORBA::Object_var factory_obj =
  87         this->orb_->resolve_initial_references ("DynAnyFactory");
  88
  89       DynamicAny::DynAnyFactory_var dynany_factory =
  90         DynamicAny::DynAnyFactory::_narrow (factory_obj.in ());
  91
  92       if (CORBA::is_nil (dynany_factory.in ()))
  93         {
  94           ACE_ERROR_RETURN ((LM_ERROR,
  95                              "Nil dynamic any factory after narrow\n"),
  96                             -1);
  97         }
  98
  99       DynAnyAnalyzer analyzer (this->orb_.in (),
 100                                dynany_factory.in (),
 101                                debug_);
 102
 103       DynAnyTests::SeqShort shortseq1;
 104
 105       shortseq1.length (2);
 106       shortseq1[0] = 2;
 107       shortseq1[1] = -2;
 108
 109       CORBA::Any any;
 110       any <<= shortseq1;
 111
 112       DynamicAny::DynAny_var shortdany =
 113         dynany_factory->create_dyn_any (any);
 114
 115       analyzer.analyze(shortdany.in ());
 116
 117       CORBA::Any_var any3;
 118       any3 = shortdany->to_any ();
 119
 120       ts[0] = data.m_string2;
 121       ts[1] = data.m_string2;
 122       CORBA::Any in_any1;
 123       in_any1 <<= ts;
 124       DynamicAny::DynAny_var dp1 =
 125         dynany_factory->create_dyn_any (in_any1);
 126
 127       DynamicAny::DynSequence_var fa1 =
 128         DynamicAny::DynSequence::_narrow (dp1.in ());
 129
 130       fa1->seek (1);
 131
 132       fa1->insert_string (data.m_string1);
 133
 134       fa1->rewind ();
 135
 136       fa1->seek (1);
 137
 138       CORBA::String_var out_str1 =
 139         fa1->get_string ();
 140
 141       if (!ACE_OS::strcmp (out_str1.in (), data.m_string1))
 142         {
 143           ACE_DEBUG ((LM_DEBUG,
 144                      "++ OK ++\n"));
 145         }
 146       else
 147         {
 148           ++this->error_count_;
 149         }
 150
 151       ACE_DEBUG ((
 152           LM_DEBUG,
 153           "testing: set_elements_as_dyn_any/get_elements_as_dyn_any/equal\n"
 154         ));
 155
 156       static const char *values[] =
 157       {
 158         "zero",
 159         "one",
 160         "two"
 161       };
 162
 163       CORBA::ULong length = 3;
 164       DynamicAny::DynAnySeq *elem_ptr = 0;
 165       ACE_NEW_RETURN (elem_ptr,
 166                       DynamicAny::DynAnySeq (length),
 167                       -1);
 168       elem_ptr->length (length);
 169       DynamicAny::DynAnySeq_var elements (elem_ptr);
 170       CORBA::ULong i;
 171
 172       for (i = 0; i < length; ++i)
 173         {
 174           CORBA::Any elem_any;
 175           elem_any <<= CORBA::Any::from_string (values[i], 8);
 176           elements[i] = dynany_factory->create_dyn_any (elem_any);
 177         }
 178
 179       fa1->set_elements_as_dyn_any (elements.in ());
 180
 181       DynamicAny::DynAnySeq_var out_elems =
 182         fa1->get_elements_as_dyn_any ();
 183
 184       if (out_elems->length () != 3)
 185         {
 186           ++this->error_count_;
 187           return -1;
 188         }
 189
 190       analyzer.analyze (fa1.in());
 191
 192       for (i = 0; i < length; ++i)
 193         {
 194           if (!compare_string_sequence_elements(i,
 195                                                 elements.in(), out_elems.in()))
 196           {
 197               error_count_++;
 198           }
 199
 200           // To show that calling destroy() on a component does
 201           // nothing, as required by the spec.
 202           out_elems[i]->destroy ();
 203         }
 204
 205       // Now verify that we can replace an element using the in/out return
 206       // type.  This illustrates the problems described in bug # 2877:
 207       //   http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=2877
 208       // notice that this code has side-effects on the out_elems sequence, so
 209       // do not move this code up or you will make the comparisons above fail.
 210       {
 211           char replacement[] = "replacement";
 212           CORBA::Any tmp;
 213           tmp <<= CORBA::Any::from_string (replacement,20);
 214           CORBA::ULong io_index = 0;
 215           // Since we directly change an element in a sequence we give
 216           // ownership for the previous element to a local temporary object.
 217           DynamicAny::DynAny_var io_owner = out_elems[io_index].inout();
 218           out_elems[io_index].inout() = dynany_factory->create_dyn_any (tmp);
 219
 220           // Compare the value of the replaced string.
 221           CORBA::String_var new_str = out_elems[io_index]->get_string();
 222           if (0 != ACE_OS::strcmp(new_str.in(), replacement))
 223           {
 224               ACE_DEBUG((LM_DEBUG,
 225                          "  Mismatch after replacing through in/out.\n"
 226                          "  expected = %C, got = %C\n",
 227                          replacement, new_str.in()));
 228               this->error_count_++;
 229           }
 230       }
 231
 232
 233
 234       if (this->error_count_ == 0)
 235         {
 236           ACE_DEBUG ((LM_DEBUG,
 237                       "++ OK ++\n"));
 238         }
 239
 240       ACE_DEBUG ((LM_DEBUG,
 241                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 242
 243       DynamicAny::DynAny_var ftc1_base =
 244         dynany_factory->create_dyn_any_from_type_code (
 245                             DynAnyTests::_tc_test_seq);
 246
 247       DynamicAny::DynSequence_var ftc1 =
 248         DynamicAny::DynSequence::_narrow (ftc1_base.in ());
 249
 250       if (CORBA::is_nil (ftc1.in ()))
 251         {
 252           ACE_ERROR_RETURN ((LM_ERROR,
 253                              "DynSequence::_narrow() returned nil\n"),
 254                             -1);
 255         }
 256
 257       ACE_DEBUG ((
 258         LM_DEBUG,
 259         ACE_TEXT ("testing: constructor(%C)/create_dyn_any_from_type_code\n"),
 260         "BooleanSeq"
 261         ));
 262
 263       DynamicAny::DynAny_var da_bool =
 264         dynany_factory->create_dyn_any_from_type_code (
 265                             DynAnyTests::_tc_SeqBoolean);
 266
 267       DynamicAny::DynSequence_var ds_bool =
 268         DynamicAny::DynSequence::_narrow (da_bool.in ());
 269
 270       if (CORBA::is_nil (ds_bool.in ()))
 271       {
 272         ACE_DEBUG ((
 273           LM_DEBUG,
 274           ACE_TEXT ("DynSequence::_narrow() returned nil\n")
 275           ));
 276         this->error_count_++;
 277       }
 278
 279       ACE_DEBUG ((
 280         LM_DEBUG,
 281         ACE_TEXT ("testing: constructor(%C)/create_dyn_any_from_type_code\n"),
 282         "ShortSeq"
 283         ));
 284
 285       DynamicAny::DynAny_var da_short =
 286         dynany_factory->create_dyn_any_from_type_code (DynAnyTests::_tc_SeqShort);
 287
 288       DynamicAny::DynSequence_var ds_short =
 289         DynamicAny::DynSequence::_narrow (da_short.in ());
 290
 291       if (CORBA::is_nil (ds_short.in ()))
 292       {
 293         ACE_DEBUG ((
 294           LM_DEBUG,
 295           ACE_TEXT ("DynSequence::_narrow() returned nil\n")
 296           ));
 297         this->error_count_++;
 298       }
 299
 300       ts[0] = CORBA::string_dup (data.m_string1);
 301       CORBA::Any in_any2;
 302       in_any2 <<= ts;
 303       ftc1->from_any (in_any2);
 304
 305       analyzer.analyze (ftc1.in());
 306
 307       CORBA::Any_var out_any1 =
 308         ftc1->to_any ();
 309
 310       const DynAnyTests::test_seq *ts_out = 0;
 311       out_any1.in () >>= ts_out;
 312
 313       if (!ACE_OS::strcmp ((*ts_out)[0U], data.m_string1))
 314         {
 315           ACE_DEBUG ((LM_DEBUG,
 316                      "++ OK ++\n"));
 317         }
 318       else
 319         {
 320           ++this->error_count_;
 321         }
 322
 323       ACE_DEBUG ((LM_DEBUG,
 324                  "testing: length/set_elements/get_elements\n"));
 325
 326       length = ftc1->get_length ();
 327
 328       if (length != 2)
 329         {
 330           ++this->error_count_;
 331         }
 332
 333       ftc1->set_length (3);
 334       DynamicAny::AnySeq as_in (3);
 335       as_in.length (3);
 336       CORBA::Any in_any3;
 337       in_any3 <<= CORBA::Any::from_string (data.m_string2, 8);
 338       as_in[0] = in_any3;
 339       as_in[1] = in_any3;
 340       in_any3 <<= CORBA::Any::from_string (data.m_string1, 8);
 341       as_in[2] = in_any3;
 342       ftc1->set_elements (as_in);
 343
 344       DynamicAny::AnySeq_var as_out =
 345         ftc1->get_elements ();
 346
 347       CORBA::ULong index = 2;
 348       CORBA::Any out_any2 = as_out[index];
 349       char* out_str2;
 350       out_any2 >>= CORBA::Any::to_string (out_str2, 8);
 351
 352       if (ACE_OS::strcmp (out_str2, data.m_string1))
 353         {
 354           ++this->error_count_;
 355         }
 356
 357       if (this->error_count_ == 0)
 358         {
 359           ACE_DEBUG ((LM_DEBUG,
 360                      "++ OK ++\n"));
 361         }
 362
 363       fa1->destroy ();
 364
 365       ftc1->destroy ();
 366     }
 367   catch (const CORBA::Exception& ex)
 368     {
 369       ex._tao_print_exception ("test_dynsequence::run_test");
 370       ++this->error_count_;
 371     }
 372
 373   ACE_DEBUG ((LM_DEBUG,
 374               "\n%d errors\n",
 375               this->error_count_));
 376
 377
 378   return !!error_count_;
 379 }