ACE/tests/Compiler_Features_13_Test.cpp

   1 /**
   2  * This program checks if the compiler / platform supports the
   3  * standard cast operators template parameters.  The motivation for
   4  * this test was a discussion on the development mailing list, and the
   5  * documentation was captured in:
   6  *
   7  *   http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=3715
   8  */
   9
  10 #include "test_config.h"
  11
  12 #include <stdexcept>
  13 #include <typeinfo>
  14
  15 namespace
  16 {
  17   /**
  18    * Helper class for test
  19    */
  20   struct Base
  21   {
  22     virtual ~Base()
  23     {}
  24   };
  25
  26   /**
  27    * Helper class for test
  28    */
  29   struct Derived : public Base
  30   {
  31     int value;
  32   };
  33
  34   /**
  35    * Helper class for test
  36    */
  37   struct Another : public Base
  38   {
  39     int x;
  40     int y;
  41   };
  42 }
  43
  44 int
  45 run_main (int, ACE_TCHAR *[])
  46 {
  47   ACE_START_TEST (ACE_TEXT("Compiler_Features_13_Test"));
  48
  49   // As usual, the exit status from the test is 0 on success, 1 on
  50   // failure
  51   int status = 0;
  52
  53   {
  54     // Make sure const cast works.  Compilation is interesting, the
  55     // functionality test here is just to make sure the compiler does
  56     // not optimize things away ...
  57     int x = 5;
  58     int const & y = x;
  59     const_cast<int&>(y) = 3;
  60
  61     if (x != 3)
  62       {
  63         status = 1;
  64         ACE_ERROR((LM_ERROR,
  65                    ACE_TEXT("Wrong value after const_cast,")
  66                    ACE_TEXT(" expected %d, got %d\n"),
  67                    3, x));
  68       }
  69   }
  70
  71   // Make sure dynamic cast through pointers work ...
  72   Derived d;
  73   d.value = 24;
  74   Base * b1 = &d;
  75   Derived * d1 = dynamic_cast<Derived*>(b1);
  76   if (d1 == 0)
  77     {
  78       status = 1;
  79       ACE_ERROR((LM_ERROR,
  80                  ACE_TEXT("dynamic_cast returns null, expected value\n")));
  81     }
  82   else
  83     {
  84       d1->value = 42;
  85       if (d.value != 42)
  86         {
  87           ACE_ERROR((LM_ERROR,
  88                     ACE_TEXT("Wrong value after dynamic_cast, expected %d, got %d\n"),
  89                     42, d.value));
  90         }
  91     }
  92
  93   // Make sure dynamic cast detects invalid casts
  94   Another a;
  95   Base * b2 = &a;
  96   Derived * d2 = dynamic_cast<Derived*>(b2);
  97   if (d2 != 0)
  98     {
  99       status = 1;
 100       ACE_ERROR((LM_ERROR,
 101                  ACE_TEXT("dynamic_cast should return null\n")));
 102     }
 103
 104   // Make sure dynamic cast raises a bad_cast exception
 105   Base & b3 = a;
 106   try
 107     {
 108       (void) dynamic_cast<Derived&>(b3);
 109
 110       status = 1;
 111       ACE_ERROR((LM_ERROR,
 112                  ACE_TEXT("dynamic_cast should have raised std::bad_cast\n")));
 113     }
 114   catch(std::bad_cast const &)
 115     {
 116     }
 117   catch(...)
 118     {
 119       status = 1;
 120       ACE_ERROR((LM_ERROR,
 121                  ACE_TEXT("dynamic_cast should have raised std::bad_cast\n")));
 122     }
 123
 124   {
 125     // Just test these compile ...
 126     double x = 42.0;
 127     int y = static_cast<int>(x);
 128     void * z = reinterpret_cast<void*>(y);
 129
 130     if (z == 0)
 131       {
 132         ACE_ERROR((LM_ERROR,
 133                    ACE_TEXT("My hack to make sure the code is not ")
 134                    ACE_TEXT("optimized away backfired!\n")));
 135       }
 136   }
 137
 138   ACE_END_TEST;
 139   return status;
 140 }