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