TAO/tests/Sequence_Unit_Tests/value_sequence_tester.hpp

   1 #ifndef guard_value_sequence_tester_hpp
   2 #define guard_value_sequence_tester_hpp
   3 /**
   4  * @file
   5  *
   6  * @brief Helper class to implement tests for *_value_sequence
   7  *
   8  * @author Carlos O'Ryan
   9  */
  10 #include "tao/Basic_Types.h"
  11
  12 #include "test_macros.h"
  13 #include "tao/SystemException.h"
  14
  15 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 template<class tested_sequence,
  18     class tested_allocation_traits>
  19 struct value_sequence_tester
  20 {
  21   typedef typename tested_sequence::value_type value_type;
  22   typedef typename tested_sequence::const_value_type const_value_type;
  23
  24   int test_default_constructor()
  25   {
  26     expected_calls a(tested_allocation_traits::allocbuf_calls);
  27     expected_calls f(tested_allocation_traits::freebuf_calls);
  28     {
  29       tested_sequence x;
  30
  31       CHECK_EQUAL(
  32           CORBA::ULong(tested_allocation_traits::default_maximum()),
  33           x.maximum());
  34       CHECK_EQUAL(CORBA::ULong(0), x.length());
  35     }
  36     FAIL_RETURN_IF_NOT(a.expect(0), a);
  37     // Nothing was allocated then there is nothing to free.
  38     FAIL_RETURN_IF_NOT(f.expect(0), f);
  39     return 0;
  40   }
  41
  42
  43   int test_copy_constructor_from_default()
  44   {
  45     expected_calls a(tested_allocation_traits::allocbuf_calls);
  46     expected_calls f(tested_allocation_traits::freebuf_calls);
  47     {
  48       tested_sequence x;
  49       FAIL_RETURN_IF_NOT(a.expect(0), a);
  50       CHECK_EQUAL(
  51           CORBA::ULong(tested_allocation_traits::default_maximum()),
  52           x.maximum());
  53       CHECK_EQUAL(CORBA::ULong(0), x.length());
  54
  55       tested_sequence y(x);
  56       // Default constructed sequence doesn't have elements,
  57       // thus there is nothing to allocate/copy in copy constructor.
  58       FAIL_RETURN_IF_NOT(a.expect(0), a);
  59       CHECK_EQUAL(x.maximum(), y.maximum());
  60       CHECK_EQUAL(x.length(), y.length());
  61       CHECK_EQUAL(x.release(), y.release());
  62     }
  63     // Nothing was allocated then there is nothing to free.
  64     FAIL_RETURN_IF_NOT(f.expect(0), f);
  65     return 0;
  66   }
  67
  68   int test_index_accessor()
  69   {
  70     try
  71       {
  72         tested_sequence x;
  73         x.length(8);
  74         // Set x[4] to any value just for suppressing valgrind complains.
  75         x[4] = 1;
  76
  77         tested_sequence const & y = x;
  78         const_value_type & z = y[4];
  79         CHECK_EQUAL(z, y[4]);
  80       }
  81     catch (const ::CORBA::BAD_PARAM &)
  82       {
  83         ACE_ERROR ((LM_ERROR, "Error: test_index_accessor: BAD_PARAM exception caught\n"));
  84         return 1;
  85       }
  86     return 0;
  87   }
  88
  89   int test_index_modifier()
  90   {
  91     tested_sequence x;
  92     x.length(8);
  93
  94     tested_sequence const & y = x;
  95     const_value_type & z = y[4];
  96     x[4] = 4;
  97     CHECK_EQUAL(4, x[4]);
  98     CHECK_EQUAL(4, y[4]);
  99     CHECK_EQUAL(4, z);
 100     return 0;
 101   }
 102
 103   int test_index_checking()
 104   {
 105     tested_sequence x;
 106     x.length(8);
 107
 108     tested_sequence const & y = x;
 109     int z = 0;
 110
 111     CHECK_THROW(z = y[32], std::range_error);
 112     CHECK_THROW(x[32] = z, std::range_error);
 113     return 0;
 114   }
 115
 116   int test_copy_constructor_values()
 117   {
 118     tested_sequence a;
 119     a.length(16);
 120     for(CORBA::ULong i = 0; i != 16; ++i) a[i] = i*i;
 121
 122     tested_sequence b(a);
 123     CHECK_EQUAL(a.length(), b.length());
 124     for(CORBA::ULong i = 0; i != a.length(); ++i)
 125     {
 126       FAIL_RETURN_IF_NOT(a[i] == b[i],
 127           "Mismatched elements at index " << i);
 128     }
 129     return 0;
 130   }
 131
 132   int test_assignment_from_default()
 133   {
 134     expected_calls a(tested_allocation_traits::allocbuf_calls);
 135     expected_calls f(tested_allocation_traits::freebuf_calls);
 136     {
 137       tested_sequence x;
 138       FAIL_RETURN_IF_NOT(a.expect(0), a);
 139       CHECK_EQUAL(
 140           CORBA::ULong(tested_allocation_traits::default_maximum()),
 141           x.maximum());
 142       CHECK_EQUAL(CORBA::ULong(0), x.length());
 143
 144       tested_sequence y;
 145       FAIL_RETURN_IF_NOT(a.expect(0), a);
 146
 147       y = x;
 148       // Default constructed sequence doesn't have elements,
 149       // thus there is nothing to allocate/copy in operator=.
 150       FAIL_RETURN_IF_NOT(a.expect(0), a);
 151       FAIL_RETURN_IF_NOT(f.expect(0), f);
 152       CHECK_EQUAL(x.maximum(), y.maximum());
 153       CHECK_EQUAL(x.length(), y.length());
 154       CHECK_EQUAL(x.release(), y.release());
 155     }
 156     // Nothing was allocated then there is nothing to free.
 157     FAIL_RETURN_IF_NOT(f.expect(0), f);
 158     return 0;
 159   }
 160
 161   int test_assignment_values()
 162   {
 163     tested_sequence a;
 164     a.length(16);
 165     for(CORBA::ULong i = 0; i != 16; ++i) a[i] = i*i;
 166
 167     tested_sequence b;
 168     b = a;
 169     CHECK_EQUAL(a.maximum(), b.maximum());
 170     CHECK_EQUAL(a.length(),  b.length());
 171     CHECK_EQUAL(a.release(), b.release());
 172     for(CORBA::ULong i = 0; i != a.length(); ++i)
 173     {
 174       FAIL_RETURN_IF_NOT(a[i] == b[i],
 175           "Mismatched elements at index " << i);
 176     }
 177     return 0;
 178   }
 179
 180   int test_exception_in_copy_constructor()
 181   {
 182     expected_calls f(tested_allocation_traits::freebuf_calls);
 183     {
 184       tested_sequence x; x.length(8);
 185       f.reset();
 186
 187       expected_calls a(tested_allocation_traits::allocbuf_calls);
 188       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 189       CHECK_THROW(tested_sequence y(x), testing_exception);
 190       FAIL_RETURN_IF_NOT(a.expect(1), a);
 191     }
 192     FAIL_RETURN_IF_NOT(f.expect(1), f);
 193     return 0;
 194   }
 195
 196   int test_exception_in_assignment()
 197   {
 198     expected_calls f(tested_allocation_traits::freebuf_calls);
 199     {
 200       tested_sequence x; x.length(2);
 201
 202       tested_sequence y; y.length(3);
 203
 204       expected_calls a(tested_allocation_traits::allocbuf_calls);
 205       f.reset();
 206       tested_allocation_traits::allocbuf_calls.failure_countdown(1);
 207       CHECK_THROW(y = x, testing_exception);
 208
 209       FAIL_RETURN_IF_NOT(a.expect(1), a);
 210       FAIL_RETURN_IF_NOT(f.expect(0), f);
 211
 212       CHECK_EQUAL(CORBA::ULong(3), y.length());
 213     }
 214     FAIL_RETURN_IF_NOT(f.expect(2), f);
 215     return 0;
 216   }
 217
 218   int test_get_buffer_const()
 219   {
 220     tested_sequence a; a.length(4);
 221     tested_sequence const & b = a;
 222
 223     value_type const * buffer = b.get_buffer();
 224     a[0] = 1; a[1] = 4; a[2] = 9; a[3] = 16;
 225
 226     CHECK_EQUAL(1,  buffer[0]);
 227     CHECK_EQUAL(4,  buffer[1]);
 228     CHECK_EQUAL(9,  buffer[2]);
 229     CHECK_EQUAL(16, buffer[3]);
 230     return 0;
 231   }
 232
 233   int test_all()
 234   {
 235     int status = 0;
 236
 237     status +=this->test_default_constructor();
 238     status +=this->test_copy_constructor_from_default();
 239     status +=this->test_index_accessor();
 240     status +=this->test_index_modifier();
 241     status +=this->test_index_checking();
 242     status +=this->test_copy_constructor_values();
 243     status +=this->test_assignment_from_default();
 244     status +=this->test_assignment_values();
 245     status +=this->test_exception_in_copy_constructor();
 246     status +=this->test_exception_in_assignment();
 247     status +=this->test_get_buffer_const();
 248     return status;
 249   }
 250 };
 251
 252 TAO_END_VERSIONED_NAMESPACE_DECL
 253 #endif // guard_value_sequence_tester_hpp