ACE/tests/Compiler_Features_10_Test.cpp

   1 /**
   2  * @file
   3  *
   4  * This program checks if the compiler / platform supports exceptions,
   5  * in particular, if raising exceptions in constructors work.  The
   6  * motivation for this test was a discussion on the development
   7  * mailing list, and the documentation was captured in:
   8  *
   9  *   http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=3715
  10  */
  11
  12 #include "test_config.h"
  13
  14 // The first part of the test is to compile this line.  If the program
  15 // does not compile the platform is just too broken.
  16 #include <memory>
  17
  18 // ... using exceptions with C++ also implies using the standard
  19 // exceptions ...
  20 #include <stdexcept>
  21
  22 // For extra challenge, we use the anonymous namespace
  23 namespace
  24 {
  25   int constructors = 0;
  26   int destructors = 0;
  27   int allocs = 0;
  28   int deallocs = 0;
  29   bool had_failure = false;
  30
  31   void check_constructor_count(int expected,
  32                                char const * filename,
  33                                int lineno);
  34   void check_destructor_count(int expected,
  35                               char const * filename,
  36                               int lineno);
  37   void check_alloc_count(int expected,
  38                          char const * filename,
  39                          int lineno);
  40   void reset_counts();
  41   void never_reached(char const * filename,
  42                      int lineno);
  43   int status();
  44
  45   /**
  46    * @class Base
  47    */
  48   class Base
  49   {
  50   public:
  51     Base()
  52     {
  53       ++constructors;
  54     }
  55     Base(Base const & )
  56     {
  57       ++constructors;
  58     }
  59     ~Base()
  60     {
  61       ++destructors;
  62     }
  63
  64     void * operator new(size_t n)
  65     {
  66       ++allocs;
  67       return ::operator new(n);
  68     }
  69     void operator delete(void * x)
  70     {
  71       ++deallocs;
  72       return ::operator delete(x);
  73     }
  74   };
  75
  76   /**
  77    * @class May_Pop
  78    *
  79    * Create a class that can raise exceptions in its constructor
  80    *
  81    */
  82   class May_Pop : public Base
  83   {
  84   public:
  85     explicit May_Pop(bool do_raise)
  86       // Even if an exception is raised, the base object is fully
  87       // constructed and must be fully destructed ...
  88       : Base()
  89     {
  90       if (do_raise)
  91         {
  92           throw std::runtime_error("requested exception");
  93         }
  94       // ... if an exception is raised this object is never
  95       // initialized and no constructor / destructor calls should take
  96       // place ...
  97       Base tmp;
  98     }
  99   };
 100
 101   /**
 102    * @class Aggregate
 103    */
 104   class Aggregate : public Base
 105   {
 106   private:
 107     May_Pop m1;
 108     May_Pop m2;
 109     May_Pop m3;
 110
 111   public:
 112     /**
 113      * Constructor.  Element m1 is fully initialized, its constructors
 114      * and destructors should run, m2 is partially initialized, its
 115      * destructor never runs, m3 is never initialized, neither its
 116      * constructor nor destructor runs.
 117      */
 118     Aggregate()
 119       : Base()
 120       , m1(false)
 121       , m2(true)
 122       , m3(false)
 123     {}
 124   };
 125 }
 126
 127
 128 int
 129 run_main (int, ACE_TCHAR *[])
 130 {
 131   ACE_START_TEST (ACE_TEXT("Compiler_Features_10_Test"));
 132   try
 133     {
 134       // ... start the test fresh ...
 135       reset_counts();
 136       // Let's try to build a simple object and destroy it, without any
 137       // exceptions raised ...
 138       May_Pop m1(false);
 139       // ... two instances of the base class should be created ...
 140       check_constructor_count(2, __FILE__, __LINE__);
 141       // ... but only one instance is destroyed at this point ...
 142       check_destructor_count(1, __FILE__, __LINE__);
 143     }
 144   catch (...)
 145     {
 146       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Unexpected exception caught\n")));
 147     }
 148   // ... now both instances are gone ...
 149   check_destructor_count(2, __FILE__, __LINE__);
 150
 151   try
 152     {
 153       // ... start the test fresh ...
 154       reset_counts();
 155       // ... now raise an exception ...
 156       May_Pop m1(true);
 157       never_reached(__FILE__, __LINE__);
 158     }
 159   catch(...)
 160     {
 161       // ... only one instance gets created ...
 162       check_constructor_count(1, __FILE__, __LINE__);
 163       // ... and it is gone ...
 164       check_destructor_count(1, __FILE__, __LINE__);
 165     }
 166
 167   try
 168     {
 169       // ... start the test fresh ...
 170       reset_counts();
 171       // ... now build a complex object with a failure in the middle ...
 172       Aggregate a;
 173       never_reached(__FILE__, __LINE__);
 174     }
 175   catch(...)
 176     {
 177       // ... check the expectations ...
 178       check_constructor_count(4, __FILE__, __LINE__);
 179       check_destructor_count(4, __FILE__, __LINE__);
 180     }
 181
 182   try
 183     {
 184       // ... start the test fresh ...
 185       reset_counts();
 186       std::unique_ptr<Aggregate> b(new Aggregate);
 187       never_reached(__FILE__, __LINE__);
 188     }
 189   catch(...)
 190     {
 191       // ... check the expectations ...
 192       check_constructor_count(4, __FILE__, __LINE__);
 193       check_destructor_count(4, __FILE__, __LINE__);
 194       check_alloc_count(1, __FILE__, __LINE__);
 195     }
 196
 197   ACE_END_TEST;
 198   return status();
 199 }
 200
 201 namespace
 202 {
 203 void
 204 check_constructor_count(int expected,
 205                         char const * filename,
 206                         int lineno)
 207 {
 208   if (constructors == expected)
 209     {
 210       return;
 211     }
 212   had_failure = true;
 213   ACE_ERROR ((LM_ERROR,
 214               ACE_TEXT("Expected %d constructor calls, had %d -- (%s:%d)\n"),
 215               expected, constructors, filename, lineno));
 216 }
 217
 218 void
 219 check_destructor_count(int expected,
 220                        char const * filename,
 221                        int lineno)
 222 {
 223   if (destructors == expected)
 224     {
 225       return;
 226     }
 227   had_failure = true;
 228   ACE_ERROR ((LM_ERROR,
 229               ACE_TEXT("Expected %d destructor calls, had %d -- (%s:%d)\n"),
 230               expected, destructors, filename, lineno));
 231 }
 232
 233 void
 234 check_alloc_count(int expected,
 235                   char const * filename,
 236                   int lineno)
 237 {
 238   if (allocs == expected && deallocs == expected)
 239     {
 240       return;
 241     }
 242   had_failure = true;
 243   if (allocs != expected)
 244     {
 245       ACE_ERROR ((LM_ERROR,
 246                   ACE_TEXT("Expected %d alloc calls, had %d -- (%s:%d)\n"),
 247                   expected, allocs, filename, lineno));
 248     }
 249   if (deallocs != expected)
 250     {
 251       ACE_ERROR ((LM_ERROR,
 252                   ACE_TEXT("Expected %d dealloc calls, had %d -- (%s:%d)\n"),
 253                   expected, deallocs, filename, lineno));
 254     }
 255 }
 256
 257 void
 258 never_reached(char const * filename,
 259               int lineno)
 260 {
 261   had_failure = true;
 262   ACE_ERROR ((LM_ERROR,
 263               ACE_TEXT("Code should not have reached (%s:%d)\n"),
 264               filename, lineno));
 265 }
 266
 267 void
 268 reset_counts()
 269 {
 270   constructors = 0;
 271   destructors = 0;
 272   allocs = 0;
 273   deallocs = 0;
 274 }
 275
 276 int
 277 status()
 278 {
 279   if (had_failure)
 280     {
 281       return 1;
 282     }
 283   return 0;
 284 }
 285
 286 }