ACE/tests/Integer_Truncate_Test.cpp

   1 // ============================================================================
   2 /**
   3  * @file Integer_Truncate_Test.cpp
   4  *
   5  * Test @c ACE_Utils::truncate_cast<> function template.
   6  *
   7  * @author Ossama Othman <ossama_othman at symantec dot com>
   8  */
   9 // ============================================================================
  10
  11 #include "test_config.h"
  12
  13 #include <ace/Truncate.h>
  14 #include <ace/Numeric_Limits.h>
  15
  16 #include <algorithm>
  17 #include <functional>
  18
  19 using namespace ACE_Utils;
  20
  21 // ----------------------------------------------------
  22
  23 bool
  24 sizeof_from_lt_sizeof_to ()
  25 {
  26   ACE_DEBUG ((LM_INFO,
  27               ACE_TEXT ("Running sizeof(FROM) < sizeof(TO) test\n")));
  28
  29   bool success = true;
  30
  31   // signed from_type, unsigned to_type
  32   {
  33     using from_type = signed char;
  34     using to_type = unsigned int;
  35
  36     ACE_TEST_ASSERT (sizeof (from_type) < sizeof (to_type));
  37
  38     from_type f =
  39       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
  40
  41     if (truncate_cast<to_type> (f) != static_cast<to_type> (f))
  42       {
  43         success = false;
  44
  45         ACE_ERROR ((LM_ERROR,
  46                     ACE_TEXT ("\tsigned from_type / unsigned to_type ")
  47                     ACE_TEXT ("truncation test failed")));
  48       }
  49   }
  50
  51   // unsigned from_type, signed to_type
  52   {
  53     using from_type = unsigned char;
  54     using to_type = int;
  55
  56     ACE_TEST_ASSERT (sizeof (from_type) < sizeof (to_type));
  57
  58     from_type f =
  59       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
  60
  61     if (truncate_cast<to_type> (f) != static_cast<to_type> (f))
  62       {
  63         success = false;
  64
  65         ACE_ERROR ((LM_ERROR,
  66                     ACE_TEXT ("\tunsigned from_type / signed to_type ")
  67                     ACE_TEXT ("truncation test failed")));
  68       }
  69   }
  70
  71   // signed from_type, signed to_type
  72   {
  73     using from_type = signed char;
  74     using to_type = int;
  75
  76     ACE_TEST_ASSERT (sizeof (from_type) < sizeof (to_type));
  77
  78     from_type f1 = -1;  // Should not be truncated.
  79     from_type f2 =
  80       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
  81
  82     if (truncate_cast<to_type> (f1) != f1
  83         || truncate_cast<to_type> (f2) != f2)
  84       {
  85         success = false;
  86
  87         ACE_ERROR ((LM_ERROR,
  88                     ACE_TEXT ("\tsigned from_type / signed to_type ")
  89                     ACE_TEXT ("truncation test failed")));
  90       }
  91   }
  92
  93   // unsigned from_type, unsigned to_type
  94   {
  95     using from_type = unsigned char;
  96     using to_type = unsigned int;
  97
  98     ACE_TEST_ASSERT (sizeof (from_type) < sizeof (to_type));
  99
 100     from_type f =
 101       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
 102
 103     if (truncate_cast<to_type> (f) != static_cast<to_type> (f))
 104       {
 105         success = false;
 106
 107         ACE_ERROR ((LM_ERROR,
 108                     ACE_TEXT ("\tunsigned from_type / unsigned to_type ")
 109                     ACE_TEXT ("truncation test failed")));
 110       }
 111   }
 112
 113   ACE_DEBUG ((LM_INFO,
 114               ACE_TEXT ("\t%s\n"),
 115               success
 116               ? ACE_TEXT ("PASSED")
 117               : ACE_TEXT ("FAILED")));
 118
 119   return success;
 120 }
 121
 122 bool
 123 sizeof_from_eq_sizeof_to ()
 124 {
 125   ACE_DEBUG ((LM_INFO,
 126               ACE_TEXT ("Running sizeof(FROM) == sizeof(TO) test\n")));
 127
 128   bool success = true;
 129
 130   // signed from_type, unsigned to_type
 131   {
 132     using from_type = int;
 133     using to_type = unsigned int;
 134
 135     ACE_TEST_ASSERT (sizeof (from_type) == sizeof (to_type));
 136
 137     from_type f1 = -1;  // Should not be truncated.
 138     from_type f2 =
 139       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
 140
 141     if (static_cast<from_type> (truncate_cast<to_type> (f1)) != f1
 142         || static_cast<from_type> (truncate_cast<to_type> (f2)) != f2)
 143       {
 144         success = false;
 145
 146         ACE_ERROR ((LM_ERROR,
 147                     ACE_TEXT ("\tsigned from_type / unsigned to_type ")
 148                     ACE_TEXT ("truncation test failed")));
 149       }
 150   }
 151
 152   // unsigned from_type, signed to_type
 153   {
 154     using from_type = unsigned int;
 155     using to_type = int;
 156
 157     ACE_TEST_ASSERT (sizeof (from_type) == sizeof (to_type));
 158
 159     from_type f =
 160       ACE_Numeric_Limits<from_type>::max ();  // Should be truncated.
 161
 162     if (truncate_cast<to_type> (f) != ACE_Numeric_Limits<to_type>::max ())
 163       {
 164         success = false;
 165
 166         ACE_ERROR ((LM_ERROR,
 167                     ACE_TEXT ("\tunsigned from_type / signed to_type ")
 168                     ACE_TEXT ("truncation test failed")));
 169       }
 170   }
 171
 172   // signed from_type, signed to_type
 173   {
 174     using from_type = int;
 175     using to_type = int;
 176
 177     ACE_TEST_ASSERT (sizeof (from_type) == sizeof (to_type));
 178
 179     from_type f1 = -1;  // Should not be truncated.
 180     from_type f2 =
 181       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
 182
 183     if (truncate_cast<to_type> (f1) != f1
 184         || truncate_cast<to_type> (f2) != f2)
 185       {
 186         success = false;
 187
 188         ACE_ERROR ((LM_ERROR,
 189                     ACE_TEXT ("\tsigned from_type / signed to_type ")
 190                     ACE_TEXT ("truncation test failed")));
 191       }
 192   }
 193
 194   // unsigned from_type, unsigned to_type
 195   {
 196     using from_type = unsigned int;
 197     using to_type = unsigned int;
 198
 199     ACE_TEST_ASSERT (sizeof (from_type) == sizeof (to_type));
 200
 201     from_type f =
 202       ACE_Numeric_Limits<from_type>::max ();  // Should not be truncated.
 203
 204     if (truncate_cast<to_type> (f) != f)
 205       {
 206         success = false;
 207
 208         ACE_ERROR ((LM_ERROR,
 209                     ACE_TEXT ("\tunsigned from_type / unsigned to_type ")
 210                     ACE_TEXT ("truncation test failed")));
 211       }
 212   }
 213
 214   ACE_DEBUG ((LM_INFO,
 215               ACE_TEXT ("\t%s\n"),
 216               success
 217               ? ACE_TEXT ("PASSED")
 218               : ACE_TEXT ("FAILED")));
 219
 220   return success;
 221 }
 222
 223 bool
 224 sizeof_from_gt_sizeof_to ()
 225 {
 226   ACE_DEBUG ((LM_INFO,
 227               ACE_TEXT ("Running sizeof(FROM) > sizeof(TO) test\n")));
 228
 229   bool success = true;
 230
 231   // signed from_type, unsigned to_type
 232   {
 233     using from_type = int;
 234     using to_type = unsigned char;
 235
 236     ACE_TEST_ASSERT (sizeof (from_type) > sizeof (to_type));
 237
 238     from_type f =
 239       ACE_Numeric_Limits<from_type>::max ();  // Should be truncated.
 240
 241     if (truncate_cast<to_type> (f) != ACE_Numeric_Limits<to_type>::max ())
 242       {
 243         success = false;
 244
 245         ACE_ERROR ((LM_ERROR,
 246                     ACE_TEXT ("\tsigned from_type / unsigned to_type ")
 247                     ACE_TEXT ("truncation test failed")));
 248       }
 249   }
 250
 251   // unsigned from_type, signed to_type
 252   {
 253     using from_type = unsigned int;
 254     using to_type = signed char;
 255
 256     ACE_TEST_ASSERT (sizeof (from_type) > sizeof (to_type));
 257
 258     from_type f =
 259       ACE_Numeric_Limits<from_type>::max ();  // Should be truncated.
 260
 261     if (truncate_cast<to_type> (f) != ACE_Numeric_Limits<to_type>::max ())
 262       {
 263         success = false;
 264
 265         ACE_ERROR ((LM_ERROR,
 266                     ACE_TEXT ("\tunsigned from_type / signed to_type ")
 267                     ACE_TEXT ("truncation test failed")));
 268       }
 269   }
 270
 271   // signed from_type, signed to_type
 272   {
 273     using from_type = int;
 274     using to_type = signed char;
 275
 276     ACE_TEST_ASSERT (sizeof (from_type) > sizeof (to_type));
 277
 278     from_type f1 = -1;  // Should not be truncated.
 279     from_type f2 =
 280       ACE_Numeric_Limits<from_type>::max ();  // Should be truncated.
 281
 282     if (truncate_cast<to_type> (f1) != f1
 283         || truncate_cast<to_type> (f2) != ACE_Numeric_Limits<to_type>::max ())
 284       {
 285         success = false;
 286
 287         ACE_ERROR ((LM_ERROR,
 288                     ACE_TEXT ("\tsigned from_type / signed to_type ")
 289                     ACE_TEXT ("truncation test failed")));
 290       }
 291   }
 292
 293   // unsigned from_type, unsigned to_type
 294   {
 295     using from_type = unsigned int;
 296     using to_type = unsigned char;
 297
 298     ACE_TEST_ASSERT (sizeof (from_type) > sizeof (to_type));
 299
 300     from_type f =
 301       ACE_Numeric_Limits<from_type>::max ();  // Should be truncated.
 302
 303     if (truncate_cast<to_type> (f) != ACE_Numeric_Limits<to_type>::max ())
 304       {
 305         success = false;
 306
 307         ACE_ERROR ((LM_ERROR,
 308                     ACE_TEXT ("\tunsigned from_type / unsigned to_type ")
 309                     ACE_TEXT ("truncation test failed")));
 310       }
 311   }
 312
 313   ACE_DEBUG ((LM_INFO,
 314               ACE_TEXT ("\t%s\n"),
 315               success
 316               ? ACE_TEXT ("PASSED")
 317               : ACE_TEXT ("FAILED")));
 318
 319   return success;
 320 }
 321
 322 // ----------------------------------------------------
 323
 324 /**
 325  * @struct Caller
 326  *
 327  * @brief Test method invocation functor.
 328  *
 329  * Test method invocation functor.
 330  */
 331 template <typename T>
 332 struct Caller
 333 {
 334   typedef T argument_type;
 335   typedef void result_type;
 336
 337   /// Constructor
 338   Caller () : success (true) {}
 339
 340   /// Function call operator overload.
 341   void operator() (T f)
 342   {
 343     if (!f ())
 344       success = false;
 345   }
 346
 347   /// Flag that indicates success of all tests.
 348   bool success;
 349 };
 350
 351 // ----------------------------------------------------
 352
 353 int
 354 run_main (int, ACE_TCHAR *[])
 355 {
 356   ACE_START_TEST (ACE_TEXT ("Integer_Truncate_Test"));
 357
 358   using test_func = bool (*)();
 359
 360   static test_func const tests[] =
 361     {
 362       sizeof_from_lt_sizeof_to
 363       , sizeof_from_eq_sizeof_to
 364       , sizeof_from_gt_sizeof_to
 365     };
 366
 367   static size_t const test_count = sizeof (tests) / sizeof (tests[0]);
 368
 369   // Have some fun with the STL.  :-)
 370   Caller<test_func> c =
 371     std::for_each (tests,
 372                    tests + test_count,
 373                    Caller<test_func> ());
 374
 375   ACE_END_TEST;
 376
 377   return c.success ? 0 : -1;
 378 }