TAO/tests/Sequence_Unit_Tests/unbounded_string_sequence_ut.cpp

   1 /**
   2  * @file
   3  *
   4  * @brief Unit test for unbounded string sequences.
   5  *
   6  * @author Carlos O'Ryan
   7  */
   8 #include "testing_string_traits.hpp"
   9 #include "tao/String_Traits_T.h"
  10 #include "testing_allocation_traits.hpp"
  11 #include "testing_range_checking.hpp"
  12
  13 #include "tao/Unbounded_Basic_String_Sequence_T.h"
  14 #include "tao/CORBA_String.h"
  15
  16 #include "string_sequence_tester.hpp"
  17
  18 #include "test_macros.h"
  19
  20
  21 using namespace TAO_VERSIONED_NAMESPACE_NAME::TAO;
  22
  23 template<class tested_sequence>
  24 struct Tester
  25 {
  26   typedef typename tested_sequence::character_type char_type;
  27   typedef string_sequence_test_helpers<char_type> helper;
  28   typedef typename tested_sequence::value_type value_type;
  29   typedef typename tested_sequence::const_value_type const_value_type;
  30
  31   typedef typename tested_sequence::element_traits tested_element_traits;
  32   typedef typename tested_sequence::allocation_traits tested_allocation_traits;
  33   typedef TAO::details::range_checking<value_type,true> range;
  34
  35   int test_ulong_constructor()
  36   {
  37     expected_calls a(tested_allocation_traits::allocbuf_calls);
  38     expected_calls f(tested_allocation_traits::freebuf_calls);
  39     expected_calls i(tested_element_traits::default_initializer_calls);
  40     {
  41       tested_sequence x(16);
  42
  43       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
  44       CHECK_EQUAL(CORBA::ULong(0), x.length());
  45       CHECK_EQUAL(true, x.release());
  46     }
  47     FAIL_RETURN_IF_NOT(a.expect(1), a);
  48     FAIL_RETURN_IF_NOT(f.expect(1), f);
  49     // ulong constructor calls allocbuf and thus there must be
  50     // maximum() default initilized elements.
  51     FAIL_RETURN_IF_NOT(i.expect(16), i);
  52     return 0;
  53   }
  54
  55   int test_copy_constructor_from_ulong()
  56   {
  57     expected_calls a(tested_allocation_traits::allocbuf_calls);
  58     expected_calls f(tested_allocation_traits::freebuf_calls);
  59     expected_calls i(tested_element_traits::default_initializer_calls);
  60     expected_calls r(tested_element_traits::release_calls);
  61     expected_calls d(tested_element_traits::duplicate_calls);
  62     {
  63       tested_sequence x(16);
  64       FAIL_RETURN_IF_NOT(a.expect(1), a);
  65       // ulong constructor calls allocbuf and thus there must be
  66       // maximum() default initilized elements.
  67       FAIL_RETURN_IF_NOT(i.expect(16), i);
  68
  69       x.length(8);
  70
  71       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
  72       CHECK_EQUAL(CORBA::ULong(8), x.length());
  73       CHECK_EQUAL(true, x.release());
  74
  75       // length() doesn't default initialize anything since initialization
  76       // was done in ulong constructor.
  77       FAIL_RETURN_IF_NOT(i.expect(0), i);
  78
  79       tested_sequence y(x);
  80       FAIL_RETURN_IF_NOT(a.expect(1), a);
  81       CHECK_EQUAL(CORBA::ULong(16), y.maximum());
  82       CHECK_EQUAL(CORBA::ULong(8), y.length());
  83       CHECK_EQUAL(true, y.release());
  84
  85       FAIL_RETURN_IF_NOT(d.expect(8), d);
  86       // Copy constructor must duplicate length() elements and default
  87       // initilize rest maximum()-length().
  88       FAIL_RETURN_IF_NOT(i.expect(8), d);
  89     }
  90     FAIL_RETURN_IF_NOT(f.expect(2), f);
  91     // There must be 32 elements released since maximum() is 16.
  92     FAIL_RETURN_IF_NOT(r.expect(32), i);
  93     return 0;
  94   }
  95
  96   int test_set_length_less_than_maximum()
  97   {
  98     expected_calls a(tested_allocation_traits::allocbuf_calls);
  99     expected_calls f(tested_allocation_traits::freebuf_calls);
 100     expected_calls i(tested_element_traits::default_initializer_calls);
 101     {
 102       tested_sequence x(16);
 103
 104       x.length(8);
 105       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
 106       CHECK_EQUAL(CORBA::ULong(8), x.length());
 107       CHECK_EQUAL(true, x.release());
 108
 109       // ulong constructor calls allocbuf and thus there must be
 110       // maximum() default initilized elements.
 111       FAIL_RETURN_IF_NOT(i.expect(16), i);
 112     }
 113     FAIL_RETURN_IF_NOT(a.expect(1), a);
 114     FAIL_RETURN_IF_NOT(f.expect(1), f);
 115     return 0;
 116   }
 117
 118   int test_set_length_more_than_maximum()
 119   {
 120     expected_calls a(tested_allocation_traits::allocbuf_calls);
 121     expected_calls f(tested_allocation_traits::freebuf_calls);
 122     expected_calls i(tested_element_traits::default_initializer_calls);
 123     {
 124       tested_sequence x(16);
 125       FAIL_RETURN_IF_NOT(a.expect(1), a);
 126
 127       x.length(32);
 128       FAIL_RETURN_IF_NOT(a.expect(1), a);
 129       FAIL_RETURN_IF_NOT(f.expect(1), f);
 130
 131       // ulong constructor calls allocbuf and thus there must be
 132       // maximum() default initilized elements + length() leads to buffer
 133       // reallocation maximum() gets set to a new value.
 134       FAIL_RETURN_IF_NOT(i.expect(48), i);
 135
 136       CHECK_EQUAL(CORBA::ULong(32), x.maximum());
 137       CHECK_EQUAL(CORBA::ULong(32), x.length());
 138       CHECK_EQUAL(true, x.release());
 139     }
 140     FAIL_RETURN_IF_NOT(f.expect(1), f);
 141     return 0;
 142   }
 143
 144   int test_exception_in_ulong_constructor()
 145   {
 146     expected_calls a(tested_allocation_traits::allocbuf_calls);
 147     expected_calls f(tested_allocation_traits::freebuf_calls);
 148     {
 149       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 150       CHECK_THROW(tested_sequence x(16), testing_exception);
 151       FAIL_RETURN_IF_NOT(a.expect(1), a);
 152     }
 153     FAIL_RETURN_IF_NOT(f.expect(0), f);
 154     return 0;
 155   }
 156
 157   int test_exception_in_length()
 158   {
 159     expected_calls f(tested_allocation_traits::freebuf_calls);
 160     expected_calls a(tested_allocation_traits::allocbuf_calls);
 161     expected_calls d(tested_element_traits::duplicate_calls);
 162     expected_calls r(tested_element_traits::release_calls);
 163     {
 164       tested_sequence y; y.length(4);
 165       for(CORBA::ULong i = 0; i != 4; ++i)
 166       {
 167         y[i] = helper::allocate_test_string();
 168       }
 169
 170       a.reset();
 171       d.reset();
 172       r.reset();
 173       f.reset();
 174       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 175       CHECK_THROW(y.length(8), testing_exception);
 176       FAIL_RETURN_IF_NOT(a.expect(1), a);
 177       FAIL_RETURN_IF_NOT(f.expect(0), f);
 178       FAIL_RETURN_IF_NOT(d.expect(0), d);
 179       FAIL_RETURN_IF_NOT(r.expect(0), r);
 180
 181       CHECK_EQUAL(CORBA::ULong(4), y.length());
 182       for(CORBA::ULong i = 0; i != 4; ++i)
 183       {
 184         FAIL_RETURN_IF_NOT(
 185             helper::compare_test_string(y[i]),
 186             "Mismatch in element " << i
 187             << ", got=" << y[i]);
 188       }
 189     }
 190     FAIL_RETURN_IF_NOT(f.expect(1), f);
 191     return 0;
 192   }
 193
 194   int test_default_initializer_exception_in_length()
 195   {
 196     expected_calls f(tested_allocation_traits::freebuf_calls);
 197     expected_calls a(tested_allocation_traits::allocbuf_calls);
 198     expected_calls d(tested_element_traits::default_initializer_calls);
 199     expected_calls r(tested_element_traits::release_calls);
 200     {
 201       tested_sequence y; y.length(4);
 202       for(CORBA::ULong i = 0; i != 4; ++i)
 203       {
 204         y[i] = helper::allocate_test_string();
 205       }
 206
 207       a.reset();
 208       d.reset();
 209       r.reset();
 210       f.reset();
 211       tested_element_traits::default_initializer_calls.failure_countdown(3);
 212       CHECK_THROW(y.length(8), testing_exception);
 213       FAIL_RETURN_IF_NOT(a.expect(1), a);
 214       FAIL_RETURN_IF_NOT(f.expect(1), f);
 215       FAIL_RETURN_IF_NOT(d.expect(3), d);
 216       FAIL_RETURN_IF_NOT(r.expect(8), r);
 217
 218       CHECK_EQUAL(CORBA::ULong(4), y.length());
 219       for(CORBA::ULong i = 0; i != 4; ++i)
 220       {
 221         FAIL_RETURN_IF_NOT(
 222             helper::compare_test_string(y[i]),
 223             "Mismatch in element " << i
 224             << ", got=" << y[i]);
 225       }
 226     }
 227     FAIL_RETURN_IF_NOT(f.expect(1), f);
 228     return 0;
 229   }
 230
 231   value_type * alloc_and_init_buffer()
 232   {
 233     value_type * buf = tested_sequence::allocbuf(8);
 234     tested_element_traits::release (buf[0]);
 235     buf[0] = helper::to_string(1);
 236     tested_element_traits::release (buf[1]);
 237     buf[1] = helper::to_string(4);
 238     tested_element_traits::release (buf[2]);
 239     buf[2] = helper::to_string(9);
 240     tested_element_traits::release (buf[3]);
 241     buf[3] = helper::to_string(16);
 242
 243     return buf;
 244   }
 245
 246   int check_values(tested_sequence const & a)
 247   {
 248     CHECK(helper::compare(1,  a[0]));
 249     CHECK(helper::compare(4,  a[1]));
 250     CHECK(helper::compare(9,  a[2]));
 251     CHECK(helper::compare(16, a[3]));
 252     return 0;
 253   }
 254
 255   int test_buffer_constructor_default()
 256   {
 257     value_type * buffer = alloc_and_init_buffer();
 258     expected_calls a(tested_allocation_traits::allocbuf_calls);
 259     expected_calls f(tested_allocation_traits::freebuf_calls);
 260     expected_calls r(tested_element_traits::release_calls);
 261     {
 262       tested_sequence a(8, 4, buffer, false);
 263       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 264       CHECK_EQUAL(CORBA::ULong(4), a.length());
 265       CHECK_EQUAL(buffer, a.get_buffer());
 266       CHECK_EQUAL(false, a.release());
 267       check_values(a);
 268     }
 269     FAIL_RETURN_IF_NOT(a.expect(0), a);
 270     FAIL_RETURN_IF_NOT(f.expect(0), f);
 271     tested_sequence::freebuf(buffer);
 272     FAIL_RETURN_IF_NOT(r.expect(8), r);
 273     return 0;
 274   }
 275
 276   int test_buffer_constructor_false()
 277   {
 278     value_type * buffer = alloc_and_init_buffer();
 279     expected_calls a(tested_allocation_traits::allocbuf_calls);
 280     expected_calls f(tested_allocation_traits::freebuf_calls);
 281     expected_calls r(tested_element_traits::release_calls);
 282     {
 283       tested_sequence a(8, 4, buffer, false);
 284       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 285       CHECK_EQUAL(CORBA::ULong(4), a.length());
 286       CHECK_EQUAL(buffer, a.get_buffer());
 287       CHECK_EQUAL(false, a.release());
 288       check_values(a);
 289     }
 290     FAIL_RETURN_IF_NOT(a.expect(0), a);
 291     FAIL_RETURN_IF_NOT(f.expect(0), f);
 292     tested_sequence::freebuf(buffer);
 293     FAIL_RETURN_IF_NOT(r.expect(8), r);
 294     return 0;
 295   }
 296
 297   int test_buffer_constructor_true()
 298   {
 299     value_type * buffer = alloc_and_init_buffer();
 300     expected_calls a(tested_allocation_traits::allocbuf_calls);
 301     expected_calls f(tested_allocation_traits::freebuf_calls);
 302     expected_calls r(tested_element_traits::release_calls);
 303     {
 304       tested_sequence a(8, 4, buffer, true);
 305       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 306       CHECK_EQUAL(CORBA::ULong(4), a.length());
 307       CHECK_EQUAL(buffer, a.get_buffer());
 308       CHECK_EQUAL(true, a.release());
 309       check_values(a);
 310     }
 311     FAIL_RETURN_IF_NOT(a.expect(0), a);
 312     FAIL_RETURN_IF_NOT(f.expect(1), f);
 313     FAIL_RETURN_IF_NOT(r.expect(8), r);
 314     return 0;
 315   }
 316
 317   int test_replace_default()
 318   {
 319     value_type * buffer = alloc_and_init_buffer();
 320
 321     expected_calls c(tested_allocation_traits::allocbuf_calls);
 322     expected_calls f(tested_allocation_traits::freebuf_calls);
 323     expected_calls r(tested_element_traits::release_calls);
 324     {
 325       tested_sequence a;
 326       a.replace(8, 4, buffer);
 327       FAIL_RETURN_IF_NOT(c.expect(0), c);
 328       FAIL_RETURN_IF_NOT(f.expect(0), f);
 329       FAIL_RETURN_IF_NOT(r.expect(0), 0);
 330
 331       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 332       CHECK_EQUAL(CORBA::ULong(4), a.length());
 333       CHECK_EQUAL(buffer, a.get_buffer());
 334       CHECK_EQUAL(false, a.release());
 335       check_values(a);
 336     }
 337     FAIL_RETURN_IF_NOT(c.expect(0), c);
 338     FAIL_RETURN_IF_NOT(f.expect(0), f);
 339     tested_sequence::freebuf(buffer);
 340     FAIL_RETURN_IF_NOT(r.expect(8), r);
 341     return 0;
 342   }
 343
 344   int test_replace_false()
 345   {
 346     value_type * buffer = alloc_and_init_buffer();
 347
 348     expected_calls c(tested_allocation_traits::allocbuf_calls);
 349     expected_calls f(tested_allocation_traits::freebuf_calls);
 350     expected_calls r(tested_element_traits::release_calls);
 351     {
 352       tested_sequence a;
 353       a.replace(8, 4, buffer, false);
 354       FAIL_RETURN_IF_NOT(c.expect(0), c);
 355       FAIL_RETURN_IF_NOT(f.expect(0), f);
 356       FAIL_RETURN_IF_NOT(r.expect(0), 0);
 357
 358       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 359       CHECK_EQUAL(CORBA::ULong(4), a.length());
 360       CHECK_EQUAL(buffer, a.get_buffer());
 361       CHECK_EQUAL(false, a.release());
 362       check_values(a);
 363     }
 364     FAIL_RETURN_IF_NOT(c.expect(0), c);
 365     FAIL_RETURN_IF_NOT(f.expect(0), f);
 366     tested_sequence::freebuf(buffer);
 367     FAIL_RETURN_IF_NOT(r.expect(8), r);
 368     return 0;
 369   }
 370
 371   int test_replace_true()
 372   {
 373     value_type * buffer = alloc_and_init_buffer();
 374
 375     expected_calls c(tested_allocation_traits::allocbuf_calls);
 376     expected_calls f(tested_allocation_traits::freebuf_calls);
 377     expected_calls r(tested_element_traits::release_calls);
 378     {
 379       tested_sequence a;
 380       a.replace(8, 4, buffer, true);
 381       FAIL_RETURN_IF_NOT(c.expect(0), c);
 382       FAIL_RETURN_IF_NOT(f.expect(0), f);
 383       FAIL_RETURN_IF_NOT(r.expect(0), r);
 384
 385       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 386       CHECK_EQUAL(CORBA::ULong(4), a.length());
 387       CHECK_EQUAL(buffer, a.get_buffer());
 388       CHECK_EQUAL(true, a.release());
 389       check_values(a);
 390     }
 391     FAIL_RETURN_IF_NOT(c.expect(0), c);
 392     // Since we've given away the ownership the buffer is deallocated by
 393     // the sequence.
 394     FAIL_RETURN_IF_NOT(f.expect(1), f);
 395     FAIL_RETURN_IF_NOT(r.expect(8), r);
 396     return 0;
 397   }
 398
 399   int test_get_buffer_default()
 400   {
 401     value_type * buffer = alloc_and_init_buffer();
 402     tested_sequence a(8, 4, buffer, true);
 403     CHECK_EQUAL(a.get_buffer(), buffer);
 404     return 0;
 405   }
 406
 407   int test_get_buffer_false()
 408   {
 409     value_type * buffer = alloc_and_init_buffer();
 410     tested_sequence a(8, 4, buffer, true);
 411     CHECK_EQUAL(a.get_buffer(), buffer);
 412     return 0;
 413   }
 414
 415   int test_get_buffer_true_with_release_false()
 416   {
 417     value_type * buffer = alloc_and_init_buffer();
 418     tested_sequence a(8, 4, buffer, false);
 419     CHECK(0 == a.get_buffer(true));
 420     tested_sequence::freebuf(buffer);
 421     return 0;
 422   }
 423
 424   int test_get_buffer_true_with_release_true()
 425   {
 426     value_type * buffer = alloc_and_init_buffer();
 427     expected_calls c(tested_allocation_traits::allocbuf_calls);
 428     expected_calls f(tested_allocation_traits::freebuf_calls);
 429     expected_calls r(tested_element_traits::release_calls);
 430     {
 431       tested_sequence a(8, 4, buffer, true);
 432       CHECK_EQUAL(buffer, a.get_buffer(true));
 433
 434       tested_sequence const & b = a;
 435       CHECK_EQUAL(0UL, b.maximum());
 436       CHECK_EQUAL(0UL, b.length());
 437       CHECK(0 != b.get_buffer());
 438       CHECK_EQUAL(true, b.release());
 439
 440       FAIL_RETURN_IF_NOT(c.expect(1), c);
 441
 442       CHECK(buffer != b.get_buffer());
 443     }
 444     FAIL_RETURN_IF_NOT(c.expect(0), c);
 445     FAIL_RETURN_IF_NOT(f.expect(1), f);
 446     tested_sequence::freebuf(buffer);
 447     FAIL_RETURN_IF_NOT(r.expect(8), r);
 448     return 0;
 449   }
 450
 451   int test_regression_2201()
 452   {
 453     value_type * buffer = alloc_and_init_buffer();
 454     expected_calls a(tested_allocation_traits::allocbuf_calls);
 455     expected_calls f(tested_allocation_traits::freebuf_calls);
 456     expected_calls r(tested_element_traits::release_calls);
 457     {
 458       tested_sequence x(8, 4, buffer, true);
 459       CHECK_EQUAL(CORBA::ULong(8), x.maximum());
 460       CHECK_EQUAL(CORBA::ULong(4), x.length());
 461       CHECK_EQUAL(buffer, x.get_buffer());
 462       CHECK_EQUAL(true, x.release());
 463       check_values(x);
 464       x.length (3);
 465       CHECK_EQUAL(CORBA::ULong(3), x.length());
 466       x.length (4);
 467       CHECK_EQUAL(CORBA::ULong(4), x.length());
 468       CHECK(helper::compare_empty(x[3]));
 469     }
 470     FAIL_RETURN_IF_NOT(a.expect(0), a);
 471     FAIL_RETURN_IF_NOT(f.expect(1), f);
 472     // 1 additional release call happens when we shrink
 473     // the sequence to length 3.
 474     FAIL_RETURN_IF_NOT(r.expect(9), r);
 475     return 0;
 476   }
 477
 478
 479   int test_all()
 480   {
 481     int status = 0;
 482     typedef string_sequence_tester<tested_sequence> common;
 483     common tester;
 484     status += tester.test_all ();
 485
 486     status += this->test_ulong_constructor();
 487     status += this->test_copy_constructor_from_ulong();
 488     status += this->test_set_length_less_than_maximum();
 489     status += this->test_set_length_more_than_maximum();
 490     status += this->test_exception_in_ulong_constructor();
 491     status += this->test_exception_in_length();
 492     status += this->test_default_initializer_exception_in_length();
 493     status += this->test_buffer_constructor_default();
 494     status += this->test_buffer_constructor_false();
 495     status += this->test_buffer_constructor_true();
 496     status += this->test_replace_default();
 497     status += this->test_replace_false();
 498     status += this->test_replace_true();
 499     status += this->test_get_buffer_default();
 500     status += this->test_get_buffer_false();
 501     status += this->test_get_buffer_true_with_release_false();
 502     status += this->test_get_buffer_true_with_release_true();
 503     status += this->test_regression_2201();
 504     return status;
 505   }
 506   Tester() {}
 507 };
 508
 509 int ACE_TMAIN(int,ACE_TCHAR*[])
 510 {
 511   int status = 0;
 512   try
 513     {
 514       {
 515         typedef Tester<unbounded_basic_string_sequence <char> > nTester;
 516         nTester ntester;
 517         status += ntester.test_all ();
 518       }
 519
 520 #if defined(ACE_HAS_WCHAR) && !defined(TAO_LACKS_WCHAR_CXX_STDLIB)
 521       {
 522         typedef Tester<unbounded_basic_string_sequence <CORBA::WChar> > wTester;
 523         wTester wtester;
 524         status += wtester.test_all ();
 525       }
 526 #endif
 527     }
 528   catch (const ::CORBA::Exception &ex)
 529     {
 530       ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
 531       ++status;
 532     }
 533
 534   return status;
 535 }