TAO/tests/Sequence_Unit_Tests/string_sequence_element_ut.cpp

   1 /**
   2  * @file
   3  *
   4  * @brief Unit test for string_sequence_element, this is the type
   5  *        returned by operator[] from a string sequence.
   6  *
   7  * @author Carlos O'Ryan
   8  */
   9 #include "testing_string_traits.hpp"
  10 #include "tao/String_Sequence_Element_T.h"
  11 #include "tao/String_Manager_T.h"
  12 #include "tao/CORBA_String.h"
  13 #include "tao/SystemException.h"
  14
  15 #include "ace/OS_NS_string.h"
  16
  17 #include "test_macros.h"
  18
  19 using namespace TAO_VERSIONED_NAMESPACE_NAME::TAO::details;
  20
  21
  22 template<typename charT>
  23 struct helper
  24 {
  25 };
  26
  27 template<>
  28 struct helper <char>
  29 {
  30   static char const *
  31   empty ()
  32   {
  33     return "";
  34   }
  35   static char const *
  36   sample0 ()
  37   {
  38     return "Hello";
  39   }
  40   static char const *
  41   sample1 ()
  42   {
  43     return "World";
  44   }
  45   static char *
  46   dup_sample0 ()
  47   {
  48     return string_traits <char, true>::duplicate (sample0 ());
  49   }
  50   static char *
  51   dup_sample1 ()
  52   {
  53     return string_traits <char, true>::duplicate (sample1 ());
  54   }
  55   static bool
  56   equal (char const *lhs, char const *rhs)
  57   {
  58     return ACE_OS::strcmp (lhs, rhs) == 0;
  59   }
  60 };
  61
  62 #if defined(ACE_HAS_WCHAR)
  63 template<>
  64 struct helper <CORBA::WChar>
  65 {
  66   static CORBA::WChar const *
  67   empty ()
  68   {
  69     return L"";
  70   }
  71   static CORBA::WChar const *
  72   sample0 ()
  73   {
  74     return L"Hello";
  75   }
  76   static CORBA::WChar const *
  77   sample1 ()
  78   {
  79     return L"World";
  80   }
  81   static CORBA::WChar *
  82   dup_sample0 ()
  83   {
  84     return string_traits <CORBA::WChar, true>::duplicate (sample0 ());
  85   }
  86   static CORBA::WChar *
  87   dup_sample1 ()
  88   {
  89     return string_traits <CORBA::WChar, true>::duplicate (sample1 ());
  90   }
  91   static bool
  92   equal (CORBA::WChar const *lhs, CORBA::WChar const *rhs)
  93   {
  94     return ACE_OS::strcmp (lhs, rhs) == 0;
  95   }
  96 };
  97 #endif
  98
  99 template<class charT>
 100 struct Tester
 101 {
 102   typedef string_traits <charT, true> tested_element_traits;
 103   typedef string_sequence_element <tested_element_traits> tested_element;
 104   typedef charT *string_type;
 105   typedef charT const *const_string_type;
 106   typedef typename tested_element_traits::string_var string_var;
 107   typedef typename tested_element_traits::string_mgr string_mgr;
 108
 109   int
 110   test_assignment_from_const_string ()
 111   {
 112     expected_calls d (tested_element_traits::duplicate_calls);
 113     expected_calls r (tested_element_traits::release_calls);
 114
 115     {
 116       string_type xe = helper <charT>::dup_sample0 ();
 117       const_string_type y = helper <charT>::sample1 ();
 118       d.reset ();
 119       r.reset ();
 120
 121       tested_element x(xe, true);
 122       FAIL_RETURN_IF_NOT(d.expect(0), d);
 123       FAIL_RETURN_IF_NOT(r.expect(0), r);
 124
 125       x = y;
 126
 127       FAIL_RETURN_IF_NOT(d.expect(0), d);
 128       FAIL_RETURN_IF_NOT(r.expect(1), r);
 129
 130       FAIL_RETURN_IF_NOT(
 131     helper<charT>::equal(helper<charT>::sample1(), xe),
 132     "Mismatch after assignment from const. expected="
 133     << helper<charT>::sample0()
 134     << ", got=" << x);
 135       tested_element_traits::release (xe);
 136       FAIL_RETURN_IF_NOT(r.expect(1), r);
 137     }
 138     FAIL_RETURN_IF_NOT(d.expect(0), d);
 139     FAIL_RETURN_IF_NOT(r.expect(0), r);
 140     return 0;
 141   }
 142
 143   int
 144   test_assignment_from_element ()
 145   {
 146     expected_calls d (tested_element_traits::duplicate_calls);
 147     expected_calls r (tested_element_traits::release_calls);
 148     {
 149       string_type xe = helper <charT>::dup_sample0 ();
 150       tested_element x(xe, true);
 151
 152       string_type ye = helper <charT>::dup_sample1 ();
 153       tested_element y(ye, true);
 154
 155       d.reset ();
 156       r.reset ();
 157
 158       x = y;
 159
 160       FAIL_RETURN_IF_NOT(d.expect(0), d);
 161       FAIL_RETURN_IF_NOT(r.expect(1), r);
 162
 163       FAIL_RETURN_IF_NOT(
 164     helper<charT>::equal(helper<charT>::sample1(), xe),
 165     "Mismatch after assignment from element. expected="
 166     << helper<charT>::sample1()
 167     << ", got=" << xe);
 168
 169       tested_element_traits::release (xe);
 170       tested_element_traits::release (ye);
 171       FAIL_RETURN_IF_NOT(r.expect(2), r);
 172     }
 173     FAIL_RETURN_IF_NOT(d.expect(0), d);
 174     FAIL_RETURN_IF_NOT(r.expect(0), r);
 175     return 0;
 176   }
 177
 178   int
 179   test_self_assignment ()
 180   {
 181     expected_calls d (tested_element_traits::duplicate_calls);
 182     expected_calls r (tested_element_traits::release_calls);
 183     {
 184       string_type xe = helper <charT>::dup_sample0 ();
 185
 186       tested_element x(xe, true);
 187
 188       d.reset ();
 189       r.reset ();
 190
 191       x = x;
 192
 193       FAIL_RETURN_IF_NOT(d.expect(0), d);
 194       FAIL_RETURN_IF_NOT(r.expect(1), r);
 195
 196       FAIL_RETURN_IF_NOT(
 197     helper<charT>::equal(helper<charT>::sample0(), xe),
 198     "Mismatch after self assignment. expected="
 199     << helper<charT>::sample0()
 200     << ", got=" << xe);
 201
 202       tested_element_traits::release (xe);
 203       FAIL_RETURN_IF_NOT(r.expect(1), r);
 204     }
 205     FAIL_RETURN_IF_NOT(d.expect(0), d);
 206     FAIL_RETURN_IF_NOT(r.expect(0), r);
 207     return 0;
 208   }
 209
 210   int
 211   test_assignment_from_non_const_string ()
 212   {
 213     expected_calls d (tested_element_traits::duplicate_calls);
 214     expected_calls r (tested_element_traits::release_calls);
 215
 216     {
 217       string_type xe = 0;
 218       tested_element x(xe, true);
 219
 220       string_type y =
 221         tested_element_traits::duplicate (helper <charT>::sample0 ());
 222       FAIL_RETURN_IF_NOT(d.expect(1), d);
 223       FAIL_RETURN_IF_NOT(r.expect(0), r);
 224
 225       x = y;
 226
 227       FAIL_RETURN_IF_NOT(d.expect(0), d);
 228       FAIL_RETURN_IF_NOT(r.expect(1), r);
 229
 230       FAIL_RETURN_IF_NOT(
 231     helper<charT>::equal(helper<charT>::sample0(), xe),
 232     "Mismatch after assignment from non-const. expected="
 233     << helper<charT>::sample0()
 234     << ", got=" << x);
 235       tested_element_traits::release (xe);
 236       FAIL_RETURN_IF_NOT(r.expect(1), r);
 237     }
 238     FAIL_RETURN_IF_NOT(d.expect(0), d);
 239     FAIL_RETURN_IF_NOT(r.expect(0), r);
 240     return 0;
 241   }
 242
 243   int
 244   test_copy_constructor ()
 245   {
 246     expected_calls d (tested_element_traits::duplicate_calls);
 247     expected_calls r (tested_element_traits::release_calls);
 248
 249     {
 250       string_type xe =
 251         tested_element_traits::duplicate (helper <charT>::sample0 ());
 252       tested_element x(xe, true);
 253
 254       d.reset ();
 255       r.reset ();
 256
 257       tested_element y (x);
 258
 259       FAIL_RETURN_IF_NOT(d.expect(0), d);
 260       FAIL_RETURN_IF_NOT(r.expect(0), r);
 261
 262       FAIL_RETURN_IF_NOT(
 263     helper<charT>::equal(helper<charT>::sample0(), y),
 264     "Mismatch after copy constructor. expected="
 265     << helper<charT>::sample0()
 266     << ", got=" << y);
 267
 268       tested_element_traits::release (xe);
 269       FAIL_RETURN_IF_NOT(r.expect(1), r);
 270     }
 271     FAIL_RETURN_IF_NOT(d.expect(0), d);
 272     FAIL_RETURN_IF_NOT(r.expect(0), r);
 273     return 0;
 274   }
 275
 276   int
 277   test_assignment_from_copy ()
 278   {
 279     expected_calls d (tested_element_traits::duplicate_calls);
 280     expected_calls r (tested_element_traits::release_calls);
 281     {
 282       string_type xe = helper <charT>::dup_sample0 ();
 283       tested_element x(xe, true);
 284
 285       d.reset ();
 286       r.reset ();
 287
 288       tested_element y (x);
 289
 290       x = y;
 291
 292       FAIL_RETURN_IF_NOT(r.expect(1), r);
 293
 294       FAIL_RETURN_IF_NOT(
 295     helper<charT>::equal(helper<charT>::sample0(), xe),
 296     "Mismatch after assignment. expected="
 297     << helper<charT>::sample0()
 298     << ", got=" << xe);
 299
 300       FAIL_RETURN_IF_NOT(
 301     helper<charT>::equal(helper<charT>::sample0(), y),
 302     "Mismatch after assignment. expected="
 303     << helper<charT>::sample0()
 304     << ", got=" << y);
 305
 306       tested_element_traits::release (xe);
 307       FAIL_RETURN_IF_NOT(r.expect(1), r);
 308     }
 309     FAIL_RETURN_IF_NOT(d.expect(0), d);
 310     FAIL_RETURN_IF_NOT(r.expect(0), r);
 311     return 0;
 312   }
 313
 314   int
 315   test_assignment_from_var ()
 316   {
 317     expected_calls d (tested_element_traits::duplicate_calls);
 318     expected_calls r (tested_element_traits::release_calls);
 319
 320     {
 321       string_type xe = helper <charT>::dup_sample1 ();
 322       tested_element x(xe, true);
 323       FAIL_RETURN_IF_NOT(d.expect(1), d);
 324
 325       string_var y (helper <charT>::sample0());
 326
 327       FAIL_RETURN_IF_NOT(d.expect(0), d);
 328       FAIL_RETURN_IF_NOT(r.expect(0), r);
 329
 330       x = y;
 331
 332       FAIL_RETURN_IF_NOT(r.expect(1), r);
 333
 334       FAIL_RETURN_IF_NOT(
 335     helper<charT>::equal(helper<charT>::sample0(), xe),
 336     "Mismatch after assignment from var. expected="
 337     << helper<charT>::sample0()
 338     << ", got=" << x);
 339
 340       tested_element_traits::release (xe);
 341       FAIL_RETURN_IF_NOT(r.expect(1), r);
 342     }
 343     FAIL_RETURN_IF_NOT(d.expect(0), d);
 344     FAIL_RETURN_IF_NOT(r.expect(0), r);
 345     return 0;
 346   }
 347
 348   int
 349   test_assignment_from_mgr ()
 350   {
 351     expected_calls d (tested_element_traits::duplicate_calls);
 352     expected_calls r (tested_element_traits::release_calls);
 353
 354     {
 355       string_type xe = helper <charT>::dup_sample1 ();
 356       tested_element x(xe, true);
 357       FAIL_RETURN_IF_NOT(d.expect(1), d);
 358
 359       string_mgr y;
 360       y = helper <charT>::sample0 ();
 361
 362       FAIL_RETURN_IF_NOT(d.expect(0), d);
 363       FAIL_RETURN_IF_NOT(r.expect(0), r);
 364
 365       x = y;
 366
 367       FAIL_RETURN_IF_NOT(r.expect(1), r);
 368
 369       FAIL_RETURN_IF_NOT(
 370     helper<charT>::equal(helper<charT>::sample0(), xe),
 371     "Mismatch after assignment from mgr. expected="
 372     << helper<charT>::sample0()
 373     << ", got=" << x);
 374
 375       tested_element_traits::release (xe);
 376       FAIL_RETURN_IF_NOT(r.expect(1), r);
 377     }
 378     FAIL_RETURN_IF_NOT(d.expect(0), d);
 379     FAIL_RETURN_IF_NOT(r.expect(0), r);
 380     return 0;
 381   }
 382   int
 383   test_all ()
 384   {
 385     int status = 0;
 386     status += this->test_assignment_from_const_string ();
 387     status += this->test_assignment_from_element ();
 388     status += this->test_self_assignment ();
 389     status += this->test_assignment_from_non_const_string ();
 390     status += this->test_copy_constructor ();
 391     status += this->test_assignment_from_copy ();
 392     status += this->test_assignment_from_var ();
 393     status += this->test_assignment_from_mgr ();
 394     return status;
 395   }
 396 };
 397
 398 int ACE_TMAIN (int, ACE_TCHAR*[])
 399 {
 400   int status = 0;
 401
 402   try
 403     {
 404       Tester <char> char_tester;
 405       status += char_tester.test_all ();
 406       Tester <char> wchar_tester;
 407       status += wchar_tester.test_all ();
 408     }
 409   catch (const ::CORBA::Exception& ex)
 410     {
 411       ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
 412       ++status;
 413     }
 414
 415   return status;
 416 }
 417