TAO/tests/Sequence_Unit_Tests/testing_allocation_traits_ut.cpp

   1 /**
   2  * @file
   3  *
   4  * @brief Unit test for the testing_allocation_traits.
   5  *
   6  * @author Carlos O'Ryan
   7  */
   8 #include "testing_allocation_traits.hpp"
   9 #include "test_macros.h"
  10
  11 #include "tao/SystemException.h"
  12
  13 #define CHECK_NO_THROW(statement) \
  14 try { statement; } catch(...) { \
  15   return 1; }
  16
  17 using namespace TAO_VERSIONED_NAMESPACE_NAME::TAO::details;
  18
  19
  20
  21 CORBA::ULong const MAXIMUM = 32;
  22
  23 template<class value_type>
  24 struct Tester
  25 {
  26   typedef unbounded_value_allocation_traits<value_type,true> unbounded;
  27   typedef bounded_value_allocation_traits<value_type,MAXIMUM,true> bounded;
  28
  29   template<class aspect>
  30   int test_allocbuf()
  31   {
  32     expected_calls c(aspect::allocbuf_calls);
  33
  34     aspect::allocbuf_calls.failure_countdown(2);
  35     value_type * s = 0;
  36     CHECK_NO_THROW(s = aspect::allocbuf(4));
  37     aspect::freebuf(s);
  38     CHECK_THROW(s = aspect::allocbuf(4), testing_exception);
  39     CHECK_NO_THROW(s = aspect::allocbuf(4));
  40     aspect::freebuf(s);
  41
  42     FAIL_RETURN_IF_NOT(c.expect(3), c);
  43     return 0;
  44   }
  45
  46   template<class aspect>
  47   int test_freebuf()
  48   {
  49     expected_calls c(aspect::freebuf_calls);
  50
  51     aspect::freebuf_calls.failure_countdown(2);
  52     value_type * s = aspect::allocbuf(4);
  53     CHECK_NO_THROW(aspect::freebuf(s));
  54     s = aspect::allocbuf(4);
  55     CHECK_THROW(aspect::freebuf(s), testing_exception);
  56     aspect::freebuf(s);
  57     s = aspect::allocbuf(4);
  58     CHECK_NO_THROW(aspect::freebuf(s));
  59
  60     FAIL_RETURN_IF_NOT(c.expect(4), c);
  61     return 0;
  62   }
  63
  64   int test_default_buffer_allocation_value()
  65   {
  66     expected_calls u(unbounded::default_buffer_allocation_calls);
  67     expected_calls b(bounded::default_buffer_allocation_calls);
  68
  69     value_type * s = unbounded::default_buffer_allocation();
  70     FAIL_RETURN_IF_NOT(u.expect(1), u);
  71     FAIL_RETURN_IF_NOT(b.expect(0), b);
  72     CHECK_EQUAL(static_cast<value_type*>(0), s);
  73     bounded::freebuf(s);
  74
  75     s = bounded::default_buffer_allocation();
  76     FAIL_RETURN_IF_NOT(u.expect(0), u);
  77     FAIL_RETURN_IF_NOT(b.expect(1), b);
  78     // default_buffer_allocation doesn't allocate a buffer for
  79     // bounded sequences (see bug 3042).
  80     CHECK_EQUAL(static_cast<value_type*>(0), s);
  81     bounded::freebuf(s);
  82     return 0;
  83   }
  84
  85   template<class aspect>
  86   int test_default_buffer_allocation()
  87   {
  88     expected_calls c(aspect::default_buffer_allocation_calls);
  89
  90     aspect::default_buffer_allocation_calls.failure_countdown(2);
  91     value_type * s = 0;
  92     CHECK_NO_THROW(
  93         s = aspect::default_buffer_allocation());
  94     aspect::freebuf(s);
  95     CHECK_THROW(
  96         s = aspect::default_buffer_allocation(), testing_exception);
  97     CHECK_NO_THROW(
  98         s = aspect::default_buffer_allocation());
  99     aspect::freebuf(s);
 100
 101     FAIL_RETURN_IF_NOT(c.expect(3), c);
 102     return 0;
 103   }
 104
 105   int test_default_buffer_allocation_unbounded()
 106   {
 107     return test_default_buffer_allocation<unbounded>();
 108   }
 109
 110   int test_default_buffer_allocation_bounded()
 111   {
 112     return test_default_buffer_allocation<bounded>();
 113   }
 114
 115   int test_allocbuf_unbounded()
 116   {
 117     return test_allocbuf<unbounded>();
 118   }
 119
 120   int test_allocbuf_bounded()
 121   {
 122     return test_allocbuf<bounded>();
 123   }
 124
 125   int test_freebuf_unbounded()
 126   {
 127     return test_freebuf<unbounded>();
 128   }
 129
 130   int test_freebuf_bounded()
 131   {
 132     return test_freebuf<bounded>();
 133   }
 134
 135   int test_all()
 136   {
 137     int status = 0;
 138     status += this->test_default_buffer_allocation_value();
 139     status += this->test_default_buffer_allocation_unbounded();
 140     status += this->test_default_buffer_allocation_bounded();
 141     status += this->test_allocbuf_unbounded();
 142     status += this->test_allocbuf_bounded();
 143     status += this->test_freebuf_unbounded();
 144     status += this->test_freebuf_bounded();
 145      return status;
 146   }
 147   Tester() {}
 148 };
 149
 150 struct Foo { int y; };
 151
 152 int ACE_TMAIN(int,ACE_TCHAR*[])
 153 {
 154   int status = 0;
 155
 156   try
 157     {
 158       {
 159         Tester<int>  tester;
 160         status += tester.test_all ();
 161       }
 162
 163       {
 164         Tester<Foo> tester;
 165         status += tester.test_all ();
 166       }
 167
 168       {
 169         Tester<char*>  tester;
 170         status += tester.test_all ();
 171       }
 172     }
 173   catch (const ::CORBA::Exception &ex)
 174     {
 175       ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
 176       ++status;
 177     }
 178
 179   return status;
 180 }