TAO/tests/Sequence_Unit_Tests/bounded_value_sequence_ut.cpp

   1 /**
   2  * @file
   3  *
   4  * @brief Unit test for bounded 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/Bounded_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 CORBA::ULong const MAXIMUM = 32;
  22
  23 typedef bounded_value_sequence<int,MAXIMUM> tested_sequence;
  24 typedef tested_sequence::element_traits tested_element_traits;
  25 typedef tested_sequence::allocation_traits tested_allocation_traits;
  26 typedef details::range_checking<int,true> range;
  27
  28 struct Tester
  29 {
  30   typedef tested_sequence::value_type value_type;
  31
  32   int test_set_length_less_than_maximum()
  33   {
  34     expected_calls a(tested_allocation_traits::allocbuf_calls);
  35     expected_calls f(tested_allocation_traits::freebuf_calls);
  36     {
  37       tested_sequence x;
  38
  39       x.length(8);
  40       CHECK_EQUAL(CORBA::ULong(MAXIMUM), x.maximum());
  41       CHECK_EQUAL(CORBA::ULong(8), x.length());
  42       CHECK_EQUAL(true, x.release());
  43     }
  44     // Naturally buffer in x is allocated after length() was called.
  45     FAIL_RETURN_IF_NOT(a.expect(1), a);
  46     FAIL_RETURN_IF_NOT(f.expect(1), f);
  47     return 0;
  48   }
  49
  50   int test_set_length_more_than_maximum()
  51   {
  52     tested_sequence x;
  53
  54     CHECK_THROW(x.length(64), std::runtime_error);
  55     return 0;
  56   }
  57
  58   value_type * alloc_and_init_buffer()
  59   {
  60     value_type * buf = tested_sequence::allocbuf();
  61     buf[0] = 1; buf[1] = 4; buf[2] = 9; buf[3] = 16;
  62
  63     return buf;
  64   }
  65
  66   int test_regression_2201 ()
  67   {
  68     value_type * buffer = alloc_and_init_buffer();
  69
  70     expected_calls a(tested_allocation_traits::allocbuf_calls);
  71     expected_calls f(tested_allocation_traits::freebuf_calls);
  72     {
  73       tested_sequence x(32, buffer, true);
  74       CHECK_EQUAL(CORBA::ULong(32), x.maximum());
  75       CHECK_EQUAL(CORBA::ULong(32), x.length());
  76       CHECK_EQUAL(buffer, x.get_buffer());
  77       CHECK_EQUAL(int( 1), x[0]);
  78       CHECK_EQUAL(int( 4), x[1]);
  79       CHECK_EQUAL(int( 9), x[2]);
  80       CHECK_EQUAL(int(16), x[3]);
  81       CHECK_EQUAL(true, x.release());
  82       x.length (3);
  83       CHECK_EQUAL(CORBA::ULong(32), x.maximum());
  84       CHECK_EQUAL(CORBA::ULong(3), x.length());
  85       x.length (4);
  86       CHECK_EQUAL(CORBA::ULong(32), x.maximum());
  87       CHECK_EQUAL(CORBA::ULong(4), x.length());
  88       CHECK_EQUAL(int( 0), x[3]);
  89     }
  90     FAIL_RETURN_IF_NOT(a.expect(0), a);
  91     FAIL_RETURN_IF_NOT(f.expect(1), f);
  92     return 0;
  93   }
  94
  95   int test_buffer_constructor_default()
  96   {
  97     value_type * buffer = alloc_and_init_buffer();
  98
  99     expected_calls a(tested_allocation_traits::allocbuf_calls);
 100     expected_calls f(tested_allocation_traits::freebuf_calls);
 101     {
 102       tested_sequence a(4, buffer);
 103       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 104       CHECK_EQUAL(CORBA::ULong(4), a.length());
 105       CHECK_EQUAL(buffer, a.get_buffer());
 106       CHECK_EQUAL(int( 1), a[0]);
 107       CHECK_EQUAL(int( 4), a[1]);
 108       CHECK_EQUAL(int( 9), a[2]);
 109       CHECK_EQUAL(int(16), a[3]);
 110       CHECK_EQUAL(false, a.release());
 111     }
 112     FAIL_RETURN_IF_NOT(a.expect(0), a);
 113     FAIL_RETURN_IF_NOT(f.expect(0), f);
 114     tested_sequence::freebuf(buffer);
 115     return 0;
 116   }
 117
 118   int test_buffer_constructor_false()
 119   {
 120     value_type * buffer = alloc_and_init_buffer();
 121     expected_calls a(tested_allocation_traits::allocbuf_calls);
 122     expected_calls f(tested_allocation_traits::freebuf_calls);
 123     {
 124       tested_sequence a(4, buffer, false);
 125       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 126       CHECK_EQUAL(CORBA::ULong(4), a.length());
 127       CHECK_EQUAL(buffer, a.get_buffer());
 128       CHECK_EQUAL(int( 1), a[0]);
 129       CHECK_EQUAL(int( 4), a[1]);
 130       CHECK_EQUAL(int( 9), a[2]);
 131       CHECK_EQUAL(int(16), a[3]);
 132       CHECK_EQUAL(false, a.release());
 133     }
 134     FAIL_RETURN_IF_NOT(a.expect(0), a);
 135     FAIL_RETURN_IF_NOT(f.expect(0), f);
 136     tested_sequence::freebuf(buffer);
 137     return 0;
 138   }
 139
 140   int test_buffer_constructor_true()
 141   {
 142     value_type * buffer = alloc_and_init_buffer();
 143     expected_calls a(tested_allocation_traits::allocbuf_calls);
 144     expected_calls f(tested_allocation_traits::freebuf_calls);
 145     {
 146       tested_sequence a(4, buffer, true);
 147       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 148       CHECK_EQUAL(CORBA::ULong(4), a.length());
 149       CHECK_EQUAL(buffer, a.get_buffer());
 150       CHECK_EQUAL(int( 1), a[0]);
 151       CHECK_EQUAL(int( 4), a[1]);
 152       CHECK_EQUAL(int( 9), a[2]);
 153       CHECK_EQUAL(int(16), a[3]);
 154       CHECK_EQUAL(true, a.release());
 155     }
 156     FAIL_RETURN_IF_NOT(a.expect(0), a);
 157     FAIL_RETURN_IF_NOT(f.expect(1), f);
 158     return 0;
 159   }
 160
 161   int test_replace_default()
 162   {
 163     value_type * buffer = alloc_and_init_buffer();
 164
 165     expected_calls c(tested_allocation_traits::allocbuf_calls);
 166     expected_calls f(tested_allocation_traits::freebuf_calls);
 167     {
 168       tested_sequence a;
 169       a.replace(4, buffer);
 170       FAIL_RETURN_IF_NOT(c.expect(0), c);
 171       // Default constructed sequence doesn't allocate a buffer.
 172       FAIL_RETURN_IF_NOT(f.expect(0), f);
 173
 174       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 175       CHECK_EQUAL(CORBA::ULong(4), a.length());
 176       CHECK_EQUAL(buffer, a.get_buffer());
 177       CHECK_EQUAL(int( 1), a[0]);
 178       CHECK_EQUAL(int( 4), a[1]);
 179       CHECK_EQUAL(int( 9), a[2]);
 180       CHECK_EQUAL(int(16), a[3]);
 181       CHECK_EQUAL(false, a.release());
 182     }
 183     FAIL_RETURN_IF_NOT(c.expect(0), c);
 184     FAIL_RETURN_IF_NOT(f.expect(0), f);
 185     tested_sequence::freebuf(buffer);
 186     return 0;
 187   }
 188
 189   int test_replace_false()
 190   {
 191     value_type * buffer = alloc_and_init_buffer();
 192     expected_calls c(tested_allocation_traits::allocbuf_calls);
 193     expected_calls f(tested_allocation_traits::freebuf_calls);
 194
 195     {
 196       tested_sequence a;
 197       a.replace(4, buffer, false);
 198       FAIL_RETURN_IF_NOT(c.expect(0), c);
 199       // Default constructed sequence doesn't allocate a buffer.
 200       FAIL_RETURN_IF_NOT(f.expect(0), f);
 201
 202       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 203       CHECK_EQUAL(CORBA::ULong(4), a.length());
 204       CHECK_EQUAL(buffer, a.get_buffer());
 205       CHECK_EQUAL(int( 1), a[0]);
 206       CHECK_EQUAL(int( 4), a[1]);
 207       CHECK_EQUAL(int( 9), a[2]);
 208       CHECK_EQUAL(int(16), a[3]);
 209       CHECK_EQUAL(false, a.release());
 210     }
 211     FAIL_RETURN_IF_NOT(c.expect(0), c);
 212     FAIL_RETURN_IF_NOT(f.expect(0), f);
 213     tested_sequence::freebuf(buffer);
 214     return 0;
 215   }
 216
 217   int test_replace_true()
 218   {
 219     value_type * buffer = alloc_and_init_buffer();
 220     expected_calls c(tested_allocation_traits::allocbuf_calls);
 221     expected_calls f(tested_allocation_traits::freebuf_calls);
 222
 223     {
 224       tested_sequence a;
 225       a.replace(4, buffer, true);
 226       FAIL_RETURN_IF_NOT(c.expect(0), c);
 227       // Default constructed sequence doesn't allocate a buffer.
 228       FAIL_RETURN_IF_NOT(f.expect(0), f);
 229
 230       CHECK_EQUAL(CORBA::ULong(32), a.maximum());
 231       CHECK_EQUAL(CORBA::ULong(4), a.length());
 232       CHECK_EQUAL(buffer, a.get_buffer());
 233       CHECK_EQUAL(int( 1), a[0]);
 234       CHECK_EQUAL(int( 4), a[1]);
 235       CHECK_EQUAL(int( 9), a[2]);
 236       CHECK_EQUAL(int(16), a[3]);
 237       CHECK_EQUAL(true, a.release());
 238     }
 239     FAIL_RETURN_IF_NOT(c.expect(0), c);
 240     FAIL_RETURN_IF_NOT(f.expect(1), f);
 241     return 0;
 242   }
 243
 244   int test_get_buffer_default()
 245   {
 246     value_type * buffer = alloc_and_init_buffer();
 247     tested_sequence a(4, buffer, true);
 248     CHECK_EQUAL(a.get_buffer(), buffer);
 249     return 0;
 250   }
 251
 252   int test_get_buffer_false()
 253   {
 254     value_type * buffer = alloc_and_init_buffer();
 255     tested_sequence a(4, buffer, true);
 256     CHECK_EQUAL(a.get_buffer(), buffer);
 257     return 0;
 258   }
 259
 260   int test_get_buffer_true_with_release_false()
 261   {
 262     value_type * buffer = alloc_and_init_buffer();
 263     tested_sequence a(4, buffer, false);
 264     CHECK(0 == a.get_buffer(true));
 265     tested_sequence::freebuf(buffer);
 266     return 0;
 267   }
 268
 269   int test_get_buffer_true_with_release_true()
 270   {
 271     value_type * buffer = alloc_and_init_buffer();
 272     expected_calls c(tested_allocation_traits::default_buffer_allocation_calls);
 273     expected_calls f(tested_allocation_traits::freebuf_calls);
 274     {
 275       tested_sequence a(4, buffer, true);
 276       CHECK_EQUAL(buffer, a.get_buffer(true));
 277
 278       tested_sequence const & b = a;
 279       CHECK_EQUAL(MAXIMUM, b.maximum());
 280       CHECK_EQUAL(0UL, b.length());
 281       CHECK(0 != b.get_buffer());
 282       CHECK_EQUAL(true, b.release());
 283
 284       FAIL_RETURN_IF_NOT(c.expect(1), c);
 285
 286       CHECK(buffer != b.get_buffer());
 287     }
 288     FAIL_RETURN_IF_NOT(c.expect(0), c);
 289     FAIL_RETURN_IF_NOT(f.expect(1), c);
 290     tested_sequence::freebuf(buffer);
 291     return 0;
 292   }
 293
 294   int test_all()
 295   {
 296     int status = 0;
 297     status += this->test_set_length_less_than_maximum();
 298     status += this->test_set_length_more_than_maximum();
 299     status += this->test_regression_2201();
 300     status += this->test_buffer_constructor_default();
 301     status += this->test_buffer_constructor_false();
 302     status += this->test_buffer_constructor_true();
 303     status += this->test_replace_default();
 304     status += this->test_replace_false();
 305     status += this->test_replace_true();
 306     status += this->test_get_buffer_false();
 307     status += this->test_get_buffer_true_with_release_false();
 308     status += this->test_get_buffer_true_with_release_true();
 309     return status;
 310   }
 311   Tester() {}
 312 };
 313
 314 int ACE_TMAIN(int,ACE_TCHAR*[])
 315 {
 316   int status = 0;
 317   try
 318     {
 319       {
 320         Tester tester;
 321         status += tester.test_all ();
 322       }
 323
 324       {
 325         typedef value_sequence_tester<tested_sequence,tested_allocation_traits> common;
 326         common tester;
 327         status += tester.test_all ();
 328       }
 329     }
 330   catch (const ::CORBA::Exception &ex)
 331     {
 332       ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
 333       ++status;
 334     }
 335
 336   return status;
 337 }