TAO/tests/Sequence_Unit_Tests/unbounded_value_sequence_ut.cpp

   1 /**
   2  * @file
   3  *
   4  * @brief Unit test for unbounded sequences of value types (integers,
   5  *        structures, etc.)
   6  *
   7  * @author Carlos O'Ryan
   8  */
   9 #include "testing_allocation_traits.hpp"
  10 #include "testing_range_checking.hpp"
  11
  12 #include "tao/Unbounded_Value_Sequence_T.h"
  13
  14 #include "value_sequence_tester.hpp"
  15
  16 #include "test_macros.h"
  17
  18
  19 using namespace TAO_VERSIONED_NAMESPACE_NAME::TAO;
  20
  21 typedef unbounded_value_sequence<int> tested_sequence;
  22 typedef tested_sequence::element_traits tested_element_traits;
  23 typedef tested_sequence::allocation_traits tested_allocation_traits;
  24 typedef details::range_checking<int,true> range;
  25
  26 struct Tester
  27 {
  28   typedef tested_sequence::value_type value_type;
  29
  30   int test_copy_constructor_from_ulong()
  31   {
  32     expected_calls a(tested_allocation_traits::allocbuf_calls);
  33     expected_calls f(tested_allocation_traits::freebuf_calls);
  34     {
  35       tested_sequence x(16);
  36       FAIL_RETURN_IF_NOT(a.expect(1), a);
  37       x.length(8);
  38
  39       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
  40       CHECK_EQUAL(CORBA::ULong(8), x.length());
  41       CHECK_EQUAL(true, x.release());
  42
  43       tested_sequence y(x);
  44       FAIL_RETURN_IF_NOT(a.expect(1), a);
  45       CHECK_EQUAL(CORBA::ULong(16), y.maximum());
  46       CHECK_EQUAL(CORBA::ULong(8), y.length());
  47       CHECK_EQUAL(true, y.release());
  48     }
  49     FAIL_RETURN_IF_NOT(f.expect(2), f);
  50     return 0;
  51   }
  52
  53   int test_assignment_from_ulong()
  54   {
  55     expected_calls a(tested_allocation_traits::allocbuf_calls);
  56     expected_calls f(tested_allocation_traits::freebuf_calls);
  57     {
  58       tested_sequence x(16);
  59       x.length(8);
  60       FAIL_RETURN_IF_NOT(a.expect(1), a);
  61       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
  62       CHECK_EQUAL(CORBA::ULong(8), x.length());
  63       CHECK_EQUAL(true, x.release());
  64
  65       tested_sequence y;
  66       FAIL_RETURN_IF_NOT(a.expect(0),  a);
  67
  68       y = x;
  69       FAIL_RETURN_IF_NOT(a.expect(1), a);
  70       FAIL_RETURN_IF_NOT(f.expect(0), f);
  71       CHECK_EQUAL(CORBA::ULong(16), y.maximum());
  72       CHECK_EQUAL(CORBA::ULong(8), y.length());
  73       CHECK_EQUAL(true, y.release());
  74     }
  75     FAIL_RETURN_IF_NOT(f.expect(2), f);
  76     return 0;
  77   }
  78
  79   int test_ulong_constructor()
  80   {
  81     expected_calls a(tested_allocation_traits::allocbuf_calls);
  82     expected_calls f(tested_allocation_traits::freebuf_calls);
  83     {
  84       tested_sequence x(16);
  85
  86       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
  87       CHECK_EQUAL(CORBA::ULong(0), x.length());
  88       CHECK_EQUAL(true, x.release());
  89     }
  90     FAIL_RETURN_IF_NOT(a.expect(1), a);
  91     FAIL_RETURN_IF_NOT(f.expect(1), f);
  92     return 0;
  93   }
  94
  95   int test_exception_in_ulong_constructor()
  96   {
  97     expected_calls a(tested_allocation_traits::allocbuf_calls);
  98     expected_calls f(tested_allocation_traits::freebuf_calls);
  99     {
 100       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 101       CHECK_THROW(tested_sequence x(16), testing_exception);
 102       FAIL_RETURN_IF_NOT(a.expect(1), a);
 103     }
 104     FAIL_RETURN_IF_NOT(f.expect(0), f);
 105     return 0;
 106   }
 107
 108   int test_set_length_less_than_maximum()
 109   {
 110     expected_calls a(tested_allocation_traits::allocbuf_calls);
 111     expected_calls f(tested_allocation_traits::freebuf_calls);
 112     {
 113       tested_sequence x(16);
 114
 115       x.length(8);
 116       CHECK_EQUAL(CORBA::ULong(16), x.maximum());
 117       CHECK_EQUAL(CORBA::ULong(8), x.length());
 118       CHECK_EQUAL(true, x.release());
 119     }
 120     FAIL_RETURN_IF_NOT(a.expect(1), a);
 121     FAIL_RETURN_IF_NOT(f.expect(1), f);
 122     return 0;
 123   }
 124
 125   int test_set_length_more_than_maximum()
 126   {
 127     expected_calls a(tested_allocation_traits::allocbuf_calls);
 128     expected_calls f(tested_allocation_traits::freebuf_calls);
 129     {
 130       tested_sequence x(16);
 131       FAIL_RETURN_IF_NOT(a.expect(1), a);
 132
 133       x.length(32);
 134       FAIL_RETURN_IF_NOT(a.expect(1), a);
 135       FAIL_RETURN_IF_NOT(f.expect(1), f);
 136
 137       CHECK_EQUAL(CORBA::ULong(32), x.maximum());
 138       CHECK_EQUAL(CORBA::ULong(32), x.length());
 139       CHECK_EQUAL(true, x.release());
 140     }
 141     FAIL_RETURN_IF_NOT(f.expect(1), f);
 142     return 0;
 143   }
 144
 145   int test_exception_in_set_length()
 146   {
 147     expected_calls f(tested_allocation_traits::freebuf_calls);
 148     {
 149       tested_sequence x;
 150
 151       expected_calls a(tested_allocation_traits::allocbuf_calls);
 152       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 153       CHECK_THROW(x.length(8), testing_exception);
 154       FAIL_RETURN_IF_NOT(a.expect(1), a);
 155     }
 156     FAIL_RETURN_IF_NOT(f.expect(0), f);
 157     return 0;
 158   }
 159
 160   value_type * alloc_and_init_buffer()
 161   {
 162     value_type * buf = tested_sequence::allocbuf(8);
 163     buf[0] = 1; buf[1] = 4; buf[2] = 9; buf[3] = 16;
 164
 165     return buf;
 166   }
 167
 168   int test_regression_2201 ()
 169   {
 170     value_type * buffer = alloc_and_init_buffer();
 171
 172     expected_calls a(tested_allocation_traits::allocbuf_calls);
 173     expected_calls f(tested_allocation_traits::freebuf_calls);
 174     {
 175       tested_sequence x(8, 4, buffer, true);
 176       CHECK_EQUAL(CORBA::ULong(8), x.maximum());
 177       CHECK_EQUAL(CORBA::ULong(4), x.length());
 178       CHECK_EQUAL(buffer, x.get_buffer());
 179       CHECK_EQUAL(int( 1), x[0]);
 180       CHECK_EQUAL(int( 4), x[1]);
 181       CHECK_EQUAL(int( 9), x[2]);
 182       CHECK_EQUAL(int(16), x[3]);
 183       CHECK_EQUAL(true, x.release());
 184       x.length (3);
 185       CHECK_EQUAL(CORBA::ULong(3), x.length());
 186       x.length (4);
 187       CHECK_EQUAL(CORBA::ULong(4), x.length());
 188       CHECK_EQUAL(int(0), x[3]);
 189     }
 190     FAIL_RETURN_IF_NOT(a.expect(0), a);
 191     FAIL_RETURN_IF_NOT(f.expect(1), f);
 192     return 0;
 193   }
 194
 195   int test_buffer_constructor_default()
 196   {
 197     value_type * buffer = alloc_and_init_buffer();
 198
 199     expected_calls a(tested_allocation_traits::allocbuf_calls);
 200     expected_calls f(tested_allocation_traits::freebuf_calls);
 201     {
 202       tested_sequence a(8, 4, buffer);
 203       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 204       CHECK_EQUAL(CORBA::ULong(4), a.length());
 205       CHECK_EQUAL(buffer, a.get_buffer());
 206       CHECK_EQUAL(int( 1), a[0]);
 207       CHECK_EQUAL(int( 4), a[1]);
 208       CHECK_EQUAL(int( 9), a[2]);
 209       CHECK_EQUAL(int(16), a[3]);
 210       CHECK_EQUAL(false, a.release());
 211     }
 212     FAIL_RETURN_IF_NOT(a.expect(0), a);
 213     FAIL_RETURN_IF_NOT(f.expect(0), f);
 214     tested_sequence::freebuf(buffer);
 215     return 0;
 216   }
 217
 218   int test_buffer_constructor_false()
 219   {
 220     value_type * buffer = alloc_and_init_buffer();
 221     expected_calls a(tested_allocation_traits::allocbuf_calls);
 222     expected_calls f(tested_allocation_traits::freebuf_calls);
 223     {
 224       tested_sequence a(8, 4, buffer, false);
 225       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 226       CHECK_EQUAL(CORBA::ULong(4), a.length());
 227       CHECK_EQUAL(buffer, a.get_buffer());
 228       CHECK_EQUAL(int( 1), a[0]);
 229       CHECK_EQUAL(int( 4), a[1]);
 230       CHECK_EQUAL(int( 9), a[2]);
 231       CHECK_EQUAL(int(16), a[3]);
 232       CHECK_EQUAL(false, a.release());
 233     }
 234     FAIL_RETURN_IF_NOT(a.expect(0), a);
 235     FAIL_RETURN_IF_NOT(f.expect(0), f);
 236     tested_sequence::freebuf(buffer);
 237     return 0;
 238   }
 239
 240   int test_buffer_constructor_true()
 241   {
 242     value_type * buffer = alloc_and_init_buffer();
 243     expected_calls a(tested_allocation_traits::allocbuf_calls);
 244     expected_calls f(tested_allocation_traits::freebuf_calls);
 245     {
 246       tested_sequence a(8, 4, buffer, true);
 247       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 248       CHECK_EQUAL(CORBA::ULong(4), a.length());
 249       CHECK_EQUAL(buffer, a.get_buffer());
 250       CHECK_EQUAL(int( 1), a[0]);
 251       CHECK_EQUAL(int( 4), a[1]);
 252       CHECK_EQUAL(int( 9), a[2]);
 253       CHECK_EQUAL(int(16), a[3]);
 254       CHECK_EQUAL(true, a.release());
 255     }
 256     FAIL_RETURN_IF_NOT(a.expect(0), a);
 257     FAIL_RETURN_IF_NOT(f.expect(1), f);
 258     return 0;
 259   }
 260
 261   int test_replace_default()
 262   {
 263     value_type * buffer = alloc_and_init_buffer();
 264
 265     expected_calls c(tested_allocation_traits::allocbuf_calls);
 266     expected_calls f(tested_allocation_traits::freebuf_calls);
 267     {
 268       tested_sequence a;
 269       a.replace(8, 4, buffer);
 270       FAIL_RETURN_IF_NOT(c.expect(0), c);
 271       FAIL_RETURN_IF_NOT(f.expect(0), f);
 272
 273       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 274       CHECK_EQUAL(CORBA::ULong(4), a.length());
 275       CHECK_EQUAL(buffer, a.get_buffer());
 276       CHECK_EQUAL(int( 1), a[0]);
 277       CHECK_EQUAL(int( 4), a[1]);
 278       CHECK_EQUAL(int( 9), a[2]);
 279       CHECK_EQUAL(int(16), a[3]);
 280       CHECK_EQUAL(false, a.release());
 281     }
 282     FAIL_RETURN_IF_NOT(c.expect(0), c);
 283     FAIL_RETURN_IF_NOT(f.expect(0), f);
 284     tested_sequence::freebuf(buffer);
 285     return 0;
 286   }
 287
 288   int test_replace_false()
 289   {
 290     value_type * buffer = alloc_and_init_buffer();
 291     expected_calls c(tested_allocation_traits::allocbuf_calls);
 292     expected_calls f(tested_allocation_traits::freebuf_calls);
 293
 294     {
 295       tested_sequence a;
 296       a.replace(8, 4, buffer, false);
 297       FAIL_RETURN_IF_NOT(c.expect(0), c);
 298       FAIL_RETURN_IF_NOT(f.expect(0), f);
 299
 300       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 301       CHECK_EQUAL(CORBA::ULong(4), a.length());
 302       CHECK_EQUAL(buffer, a.get_buffer());
 303       CHECK_EQUAL(int( 1), a[0]);
 304       CHECK_EQUAL(int( 4), a[1]);
 305       CHECK_EQUAL(int( 9), a[2]);
 306       CHECK_EQUAL(int(16), a[3]);
 307       CHECK_EQUAL(false, a.release());
 308     }
 309     FAIL_RETURN_IF_NOT(c.expect(0), c);
 310     FAIL_RETURN_IF_NOT(f.expect(0), f);
 311     tested_sequence::freebuf(buffer);
 312     return 0;
 313   }
 314
 315   int test_replace_true()
 316   {
 317     value_type * buffer = alloc_and_init_buffer();
 318     expected_calls c(tested_allocation_traits::allocbuf_calls);
 319     expected_calls f(tested_allocation_traits::freebuf_calls);
 320
 321     {
 322       tested_sequence a;
 323       a.replace(8, 4, buffer, true);
 324       FAIL_RETURN_IF_NOT(c.expect(0), c);
 325       FAIL_RETURN_IF_NOT(f.expect(0), f);
 326
 327       CHECK_EQUAL(CORBA::ULong(8), a.maximum());
 328       CHECK_EQUAL(CORBA::ULong(4), a.length());
 329       CHECK_EQUAL(buffer, a.get_buffer());
 330       CHECK_EQUAL(int( 1), a[0]);
 331       CHECK_EQUAL(int( 4), a[1]);
 332       CHECK_EQUAL(int( 9), a[2]);
 333       CHECK_EQUAL(int(16), a[3]);
 334       CHECK_EQUAL(true, a.release());
 335     }
 336     FAIL_RETURN_IF_NOT(c.expect(0), c);
 337     FAIL_RETURN_IF_NOT(f.expect(1), f);
 338     return 0;
 339   }
 340
 341   int test_get_buffer_default()
 342   {
 343     value_type * buffer = alloc_and_init_buffer();
 344     tested_sequence a(8, 4, buffer, true);
 345     CHECK_EQUAL(a.get_buffer(), buffer);
 346     return 0;
 347   }
 348
 349   int test_get_buffer_false()
 350   {
 351     value_type * buffer = alloc_and_init_buffer();
 352     tested_sequence a(8, 4, buffer, true);
 353     CHECK_EQUAL(a.get_buffer(), buffer);
 354     return 0;
 355   }
 356
 357   int test_get_buffer_true_with_release_false()
 358   {
 359     value_type * buffer = alloc_and_init_buffer();
 360     tested_sequence a(8, 4, buffer, false);
 361     CHECK(0 == a.get_buffer(true));
 362     tested_sequence::freebuf(buffer);
 363     return 0;
 364   }
 365
 366   int test_get_buffer_true_with_release_true()
 367   {
 368     value_type * buffer = alloc_and_init_buffer();
 369     expected_calls c(tested_allocation_traits::allocbuf_calls);
 370     expected_calls f(tested_allocation_traits::freebuf_calls);
 371     {
 372       tested_sequence a(8, 4, buffer, true);
 373       CHECK_EQUAL(buffer, a.get_buffer(true));
 374
 375       tested_sequence const & b = a;
 376       CHECK_EQUAL(0UL, b.maximum());
 377       CHECK_EQUAL(0UL, b.length());
 378       CHECK(0 != b.get_buffer());
 379       CHECK_EQUAL(true, b.release());
 380
 381       FAIL_RETURN_IF_NOT(c.expect(1), c);
 382
 383       CHECK(buffer != b.get_buffer());
 384     }
 385     FAIL_RETURN_IF_NOT(c.expect(0), c);
 386     FAIL_RETURN_IF_NOT(f.expect(1), f);
 387     tested_sequence::freebuf(buffer);
 388     return 0;
 389   }
 390
 391   int test_all()
 392   {
 393     int status = 0;
 394     status += this->test_ulong_constructor();
 395     status += this->test_copy_constructor_from_ulong();
 396     status += this->test_assignment_from_ulong();
 397     status += this->test_exception_in_ulong_constructor();
 398     status += this->test_set_length_less_than_maximum();
 399     status += this->test_set_length_more_than_maximum();
 400     status += this->test_exception_in_set_length();
 401     status += this->test_regression_2201 ();
 402     status += this->test_buffer_constructor_default();
 403     status += this->test_buffer_constructor_false();
 404     status += this->test_buffer_constructor_true();
 405     status += this->test_replace_default();
 406     status += this->test_replace_false();
 407     status += this->test_replace_true();
 408     status += this->test_get_buffer_false();
 409     status += this->test_get_buffer_true_with_release_false();
 410     status += this->test_get_buffer_true_with_release_true();
 411     return status;
 412   }
 413   Tester() {}
 414 };
 415
 416 int ACE_TMAIN(int,ACE_TCHAR*[])
 417 {
 418   int status = 0;
 419   try
 420     {
 421       Tester tester;
 422       status += tester.test_all ();
 423
 424       typedef value_sequence_tester<tested_sequence,tested_allocation_traits> common;
 425       common tester2;
 426       status += tester2.test_all ();
 427     }
 428   catch (const ::CORBA::Exception &ex)
 429     {
 430       ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
 431       ++status;
 432     }
 433
 434   return status;
 435 }