TAO/tests/Sequence_Unit_Tests/string_sequence_tester.hpp

   1 #ifndef guard_string_sequence_tester_hpp
   2 #define guard_string_sequence_tester_hpp
   3 /**
   4  * @file
   5  *
   6  * @brief Helper class to implement tests for *_string_sequence
   7  *
   8  * @author Carlos O'Ryan
   9  */
  10 #include "tao/String_Traits_T.h"
  11
  12 #include "ace/OS_NS_string.h"
  13
  14 #include "test_macros.h"
  15
  16 #include <sstream>
  17
  18 template<typename charT>
  19 struct string_sequence_test_helpers
  20 {
  21 };
  22
  23 template<>
  24 struct string_sequence_test_helpers<char>
  25 {
  26   inline static char const * test_string()
  27   {
  28     return "In a hole in the ground there lived a Hobbit";
  29   }
  30
  31   inline static char * allocate_test_string()
  32   {
  33     return TAO::details::string_traits<char,true>::duplicate(
  34         test_string());
  35   }
  36
  37   static bool compare_test_string(char const * value)
  38   {
  39     return ACE_OS::strcmp(test_string(), value) == 0;
  40   }
  41
  42   inline static char * to_string(CORBA::ULong i)
  43   {
  44     std::ostringstream os;
  45     os << i;
  46     return TAO::details::string_traits<char,true>::duplicate(
  47         os.str().c_str());
  48   }
  49
  50   inline static bool compare(int i, char const * value)
  51   {
  52     std::ostringstream os;
  53     os << i;
  54     return ACE_OS::strcmp(os.str().c_str(), value) == 0;
  55   }
  56
  57   inline static bool compare_empty(char const * value)
  58   {
  59     return ACE_OS::strcmp(value, "") == 0;
  60   }
  61 };
  62
  63 #if defined(_GLIBCPP_VERSION) && !defined(_GLIBCPP_USE_WCHAR_T) && !defined(TAO_LACKS_WCHAR_CXX_STDLIB)
  64 # define TAO_LACKS_WCHAR_CXX_STDLIB
  65 #endif
  66
  67 #if defined(ACE_HAS_WCHAR) && !defined(TAO_LACKS_WCHAR_CXX_STDLIB)
  68 template<>
  69 struct string_sequence_test_helpers<CORBA::WChar>
  70 {
  71   inline static CORBA::WChar const * test_string()
  72   {
  73     return L"In a hole in the ground there lived a Hobbit";
  74   }
  75
  76   inline static CORBA::WChar * allocate_test_string()
  77   {
  78     return TAO::details::string_traits<CORBA::WChar,true>::duplicate(
  79         test_string());
  80   }
  81
  82   static bool compare_test_string(CORBA::WChar const * value)
  83   {
  84     return ACE_OS::strcmp(test_string(), value) == 0;
  85   }
  86
  87   inline static CORBA::WChar * to_string(CORBA::ULong i)
  88   {
  89     std::wostringstream os;
  90     os << i;
  91     return TAO::details::string_traits<CORBA::WChar,true>::duplicate(
  92         os.str().c_str());
  93   }
  94
  95   inline static bool compare(int i, CORBA::WChar const * value)
  96   {
  97     std::wostringstream os;
  98     os << i;
  99     return ACE_OS::strcmp(os.str().c_str(), value) == 0;
 100   }
 101
 102   inline static bool compare_empty(CORBA::WChar const * value)
 103   {
 104     return ACE_OS::strcmp(value, L"") == 0;
 105   }
 106 };
 107 #endif /* ACE_HAS_WCHAR */
 108
 109 template<class tested_sequence>
 110 struct string_sequence_tester
 111 {
 112   typedef typename tested_sequence::character_type character_type;
 113   typedef string_sequence_test_helpers<character_type> helper;
 114   typedef typename tested_sequence::value_type value_type;
 115   typedef typename tested_sequence::const_value_type const_value_type;
 116   typedef typename tested_sequence::element_traits tested_element_traits;
 117   typedef typename tested_sequence::allocation_traits tested_allocation_traits;
 118
 119   int test_default_constructor()
 120   {
 121     expected_calls a(tested_allocation_traits::allocbuf_calls);
 122     expected_calls f(tested_allocation_traits::freebuf_calls);
 123     {
 124       tested_sequence x;
 125
 126       CHECK_EQUAL(
 127           CORBA::ULong(tested_allocation_traits::default_maximum()),
 128           x.maximum());
 129       CHECK_EQUAL(CORBA::ULong(0), x.length());
 130     }
 131     FAIL_RETURN_IF_NOT(a.expect(0), a);
 132     // Nothing was allocated then there is nothing to free.
 133     FAIL_RETURN_IF_NOT(f.expect(0), f);
 134     return 0;
 135   }
 136
 137   int test_copy_constructor_from_default()
 138   {
 139     expected_calls a(tested_allocation_traits::allocbuf_calls);
 140     expected_calls f(tested_allocation_traits::freebuf_calls);
 141     expected_calls i(tested_element_traits::default_initializer_calls);
 142     expected_calls d(tested_element_traits::duplicate_calls);
 143     {
 144       tested_sequence x;
 145
 146       a.reset(); f.reset(); i.reset(); d.reset();
 147
 148       tested_sequence y(x);
 149       // Default constructed sequence doesn't have elements,
 150       // thus there is nothing to allocate/copy in copy constructor.
 151       FAIL_RETURN_IF_NOT(a.expect(0), a);
 152       FAIL_RETURN_IF_NOT(f.expect(0), f);
 153       FAIL_RETURN_IF_NOT(i.expect(0), i);
 154       FAIL_RETURN_IF_NOT(d.expect(0), d);
 155
 156       CHECK_EQUAL(x.maximum(), y.maximum());
 157       CHECK_EQUAL(x.length(), y.length());
 158       CHECK_EQUAL(x.release(), y.release());
 159     }
 160     // Nothing was allocated then there is nothing to free.
 161     FAIL_RETURN_IF_NOT(f.expect(0), f);
 162     return 0;
 163   }
 164
 165   int test_index_accessor()
 166   {
 167     tested_sequence x;
 168     x.length(8);
 169
 170     tested_sequence const & y = x;
 171     character_type const * t = y[4];
 172     FAIL_RETURN_IF_NOT(helper::compare_empty(t),
 173         "Unexpected string value " << t);
 174     return 0;
 175   }
 176
 177   int test_index_modifier()
 178   {
 179     tested_sequence x;
 180     x.length(8);
 181
 182     tested_sequence const & y = x;
 183
 184     character_type const * text = helper::test_string();
 185     x[4] = text;
 186
 187     character_type const * t = y[4];
 188
 189     FAIL_RETURN_IF_NOT(ACE_OS::strcmp(text, x[4]) == 0,
 190         "Mismatched values expected=" << text
 191         << ", got=" << x[4]);
 192     FAIL_RETURN_IF_NOT(ACE_OS::strcmp(text, y[4]) == 0,
 193         "Mismatched values expected=" << text
 194         << ", got=" << y[4]);
 195     CHECK(text != t);
 196     return 0;
 197   }
 198
 199   int test_index_checking()
 200   {
 201     tested_sequence x;
 202     x.length(8);
 203
 204     tested_sequence const & y = x;
 205     character_type const * lhs;
 206     character_type const * rhs = 0;
 207     CHECK_THROW(lhs = y[32], std::range_error);
 208     CHECK_THROW(x[32] = rhs, std::range_error);
 209     ACE_UNUSED_ARG (lhs);
 210     return 0;
 211   }
 212
 213   int test_copy_constructor_values()
 214   {
 215     tested_sequence a;
 216     a.length(16);
 217     for(CORBA::ULong i = 0; i != 16; ++i)
 218     {
 219       a[i] = helper::to_string(i);
 220     }
 221
 222     expected_calls d(tested_element_traits::duplicate_calls);
 223     expected_calls r(tested_element_traits::release_calls);
 224
 225     CORBA::ULong max = 0;
 226     {
 227       tested_sequence b(a);
 228       FAIL_RETURN_IF_NOT(d.expect(16), d);
 229       max = b.maximum();
 230
 231       CHECK_EQUAL(a.length(), b.length());
 232       for(CORBA::ULong i = 0; i != a.length(); ++i)
 233       {
 234         FAIL_RETURN_IF_NOT(ACE_OS::strcmp(a[i], b[i]) == 0,
 235             "Mismatched elements at index=" << i
 236             << ", a=" << a[i]
 237             << ", b=" << b[i]);
 238       }
 239     }
 240     FAIL_RETURN_IF_NOT(r.expect(max), r);
 241     return 0;
 242   }
 243
 244   int test_freebuf_releases_elements()
 245   {
 246     value_type * buffer = tested_sequence::allocbuf(32);
 247
 248     expected_calls r(tested_element_traits::release_calls);
 249     expected_calls f(tested_allocation_traits::freebuf_calls);
 250
 251     tested_sequence::freebuf(buffer);
 252
 253     FAIL_RETURN_IF_NOT(f.expect(1), f);
 254     FAIL_RETURN_IF_NOT(r.expect(32), r);
 255     return 0;
 256   }
 257
 258   int test_assignment_from_default()
 259   {
 260     expected_calls a(tested_allocation_traits::allocbuf_calls);
 261     expected_calls f(tested_allocation_traits::freebuf_calls);
 262
 263     {
 264       tested_sequence x;
 265       FAIL_RETURN_IF_NOT(a.expect(0), a);
 266       CHECK_EQUAL(
 267           CORBA::ULong(tested_allocation_traits::default_maximum()),
 268           x.maximum());
 269       CHECK_EQUAL(CORBA::ULong(0), x.length());
 270
 271       tested_sequence y;
 272       FAIL_RETURN_IF_NOT(a.expect(0), a);
 273
 274       y = x;
 275       // Default constructed sequence doesn't have elements,
 276       // thus there is nothing to allocate/copy in operator=.
 277       FAIL_RETURN_IF_NOT(a.expect(0), a);
 278       FAIL_RETURN_IF_NOT(f.expect(0), f);
 279       CHECK_EQUAL(x.maximum(), y.maximum());
 280       CHECK_EQUAL(x.length(), y.length());
 281       CHECK_EQUAL(x.release(), y.release());
 282     }
 283     // Nothing was allocated then there is nothing to free.
 284     FAIL_RETURN_IF_NOT(f.expect(0), f);
 285     return 0;
 286   }
 287
 288   int test_assignment_values()
 289   {
 290     tested_sequence a;
 291     a.length(16);
 292     for(CORBA::ULong i = 0; i != 16; ++i)
 293     {
 294       a[i] = helper::to_string(i);
 295     }
 296
 297     expected_calls d(tested_element_traits::duplicate_calls);
 298     expected_calls r(tested_element_traits::release_calls);
 299     CORBA::ULong max = 0;
 300     {
 301       tested_sequence b;
 302       b = a;
 303       FAIL_RETURN_IF_NOT(d.expect(16), d);
 304
 305       max = b.maximum();
 306
 307       CHECK_EQUAL(a.maximum(), b.maximum());
 308       CHECK_EQUAL(a.length(),  b.length());
 309       CHECK_EQUAL(a.release(), b.release());
 310       for(CORBA::ULong i = 0; i != a.length(); ++i)
 311       {
 312         FAIL_RETURN_IF_NOT(ACE_OS::strcmp(a[i], b[i]) == 0,
 313             "Mismatched elements at index " << i);
 314       }
 315       r.reset();
 316     }
 317     FAIL_RETURN_IF_NOT(r.expect(max), r);
 318     return 0;
 319   }
 320
 321   int test_exception_in_copy_constructor()
 322   {
 323     expected_calls f(tested_allocation_traits::freebuf_calls);
 324     {
 325       tested_sequence x; x.length(8);
 326       f.reset();
 327
 328       expected_calls a(tested_allocation_traits::allocbuf_calls);
 329       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 330       CHECK_THROW(tested_sequence y(x), testing_exception);
 331       FAIL_RETURN_IF_NOT(a.expect(1), a);
 332     }
 333     FAIL_RETURN_IF_NOT(f.expect(1), f);
 334     return 0;
 335   }
 336
 337   int test_exception_in_assignment()
 338   {
 339     expected_calls f(tested_allocation_traits::freebuf_calls);
 340     {
 341       tested_sequence x; x.length(2);
 342
 343       tested_sequence y; y.length(3);
 344
 345       expected_calls a(tested_allocation_traits::allocbuf_calls);
 346       f.reset();
 347       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 348       CHECK_THROW(y = x, testing_exception);
 349
 350       FAIL_RETURN_IF_NOT(a.expect(1), a);
 351       FAIL_RETURN_IF_NOT(f.expect(0), f);
 352
 353       CHECK_EQUAL(CORBA::ULong(3), y.length());
 354     }
 355     FAIL_RETURN_IF_NOT(f.expect(2), f);
 356     return 0;
 357   }
 358
 359   int test_duplicate_exception_in_copy_constructor()
 360   {
 361     expected_calls f(tested_allocation_traits::freebuf_calls);
 362     {
 363       tested_sequence x; x.length(8);
 364       f.reset();
 365
 366       for(CORBA::ULong i = 0; i != 8; ++i)
 367       {
 368         x[i] = helper::allocate_test_string();
 369       }
 370
 371       expected_calls a(tested_allocation_traits::allocbuf_calls);
 372       expected_calls d(tested_element_traits::duplicate_calls);
 373       expected_calls r(tested_element_traits::release_calls);
 374
 375       tested_element_traits::duplicate_calls.failure_countdown(4);
 376
 377       CHECK_THROW(tested_sequence y(x), testing_exception);
 378       FAIL_RETURN_IF_NOT(a.expect(1), a);
 379       FAIL_RETURN_IF_NOT(f.expect(1), f);
 380       FAIL_RETURN_IF_NOT(d.expect(4), d);
 381       FAIL_RETURN_IF_NOT(r.expect(x.maximum()), r);
 382     }
 383     FAIL_RETURN_IF_NOT(f.expect(1), f);
 384     return 0;
 385   }
 386
 387   int test_duplicate_exception_in_assignment()
 388   {
 389     expected_calls f(tested_allocation_traits::freebuf_calls);
 390     {
 391       tested_sequence x; x.length(4);
 392       f.reset();
 393
 394       for(CORBA::ULong i = 0; i != 4; ++i)
 395       {
 396         x[i] = helper::allocate_test_string();
 397       }
 398
 399       expected_calls a(tested_allocation_traits::allocbuf_calls);
 400       expected_calls d(tested_element_traits::duplicate_calls);
 401       expected_calls r(tested_element_traits::release_calls);
 402
 403
 404       {
 405         tested_sequence y; y.length(8);
 406         for(CORBA::ULong i = 0; i != 8; ++i)
 407         {
 408           y[i] = helper::allocate_test_string();
 409         }
 410
 411         a.reset();
 412         d.reset();
 413         r.reset();
 414         f.reset();
 415         tested_element_traits::duplicate_calls.failure_countdown(4);
 416         CHECK_THROW(x = y, testing_exception);
 417         FAIL_RETURN_IF_NOT(a.expect(1), a);
 418         FAIL_RETURN_IF_NOT(f.expect(1), f);
 419         FAIL_RETURN_IF_NOT(d.expect(4), d);
 420         FAIL_RETURN_IF_NOT(r.expect(y.maximum()), r);
 421
 422         CHECK_EQUAL(CORBA::ULong(8), y.length());
 423         for(CORBA::ULong i = 0; i != 8; ++i)
 424         {
 425           FAIL_RETURN_IF_NOT(
 426               helper::compare_test_string(y[i]),
 427               "Mismatch in element " << i
 428               << ", got=" << y[i]);
 429         }
 430       }
 431       FAIL_RETURN_IF_NOT(f.expect(1), f);
 432     }
 433     FAIL_RETURN_IF_NOT(f.expect(1), f);
 434     return 0;
 435   }
 436
 437   int test_get_buffer_const()
 438   {
 439     tested_sequence a; a.length(8);
 440     tested_sequence const & b = a;
 441
 442     const_value_type const * buffer = b.get_buffer();
 443     a[0] = helper::test_string();
 444
 445     CHECK_EQUAL(buffer, b.get_buffer());
 446     FAIL_RETURN_IF_NOT(ACE_OS::strcmp(a[0], buffer[0]) == 0,
 447         "Mismatched elements a[0]=" << a[0]
 448         << ", buffer[0]=" << buffer[0]);
 449     return 0;
 450   }
 451
 452   int test_all ()
 453   {
 454   int status=0;
 455   status += this->test_default_constructor();
 456   status += this->test_copy_constructor_from_default();
 457   status += this->test_index_accessor();
 458   status += this->test_index_modifier();
 459   status += this->test_index_checking();
 460   status += this->test_copy_constructor_values();
 461   status += this->test_freebuf_releases_elements();
 462   status += this->test_assignment_from_default();
 463   status += this->test_assignment_values();
 464   status += this->test_exception_in_copy_constructor();
 465   status += this->test_exception_in_assignment();
 466   status += this->test_duplicate_exception_in_copy_constructor();
 467   status += this->test_duplicate_exception_in_assignment();
 468   status += this->test_get_buffer_const();
 469
 470   return status;
 471   }
 472 };
 473
 474 #endif // guard_string_sequence_tester_hpp