ACE/tests/CDR_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    CDR_Test.cpp
   5  *
   6  *  Checks the functionality of the ACE CDR streams.
   7  *
   8  *  @author Istvan Buki <istvan.buki@euronet.be> and Jeff Parsons <parsons@cs.wustl.edu> and Carlos O'Ryan <coryan@cs.wustl.edu>
   9  */
  10 //=============================================================================
  11
  12
  13 #include "test_config.h"
  14 #include "ace/Get_Opt.h"
  15 #include "ace/Auto_Ptr.h"
  16 #include "ace/CDR_Stream.h"
  17 #include "ace/CDR_Size.h"
  18 #include "ace/SString.h"
  19 #include "ace/ACE.h"
  20 #include "ace/OS_NS_stdlib.h"
  21 #include "ace/OS_NS_string.h"
  22 #include "ace/OS_NS_wchar.h"
  23
  24
  25
  26 static int n = 4096;
  27 static int nloops = 100;
  28
  29 struct CDR_Test_Types
  30 {
  31   CDR_Test_Types ();
  32
  33   ACE_CDR::Octet o;
  34   ACE_CDR::Short s;
  35   ACE_CDR::Long l;
  36   const ACE_CDR::Char *str;
  37   const ACE_CDR::WChar *wstr;
  38   const std::string std_str;
  39 #if !defined(ACE_LACKS_STD_WSTRING)
  40   const std::wstring std_wstr;
  41 #endif
  42   ACE_CDR::Double d;
  43   ACE_CDR::Short reps;
  44   ACE_CDR::UShort repus;
  45   ACE_CDR::Long repl;
  46   ACE_CDR::ULong repul;
  47   ACE_CDR::Boolean repb;
  48   const ACE_CDR::Char repc;
  49   ACE_CDR::LongLong repll;
  50   ACE_CDR::ULongLong repull;
  51   ACE_CDR::Octet repo;
  52   ACE_CDR::Float repf;
  53   ACE_CDR::Double repd;
  54
  55   int test_put (ACE_OutputCDR& cdr);
  56   int test_get (ACE_InputCDR& cdr) const;
  57   int test_put_placeholder (ACE_OutputCDR& cdr);
  58   int test_get_placeholder (ACE_InputCDR& cdr) const;
  59
  60   enum
  61   {
  62     ARRAY_SIZE = 10
  63   };
  64
  65   ACE_CDR::Short a[ARRAY_SIZE];
  66 };
  67
  68 CDR_Test_Types::CDR_Test_Types ()
  69   : o (1),
  70     s (2),
  71     l (4),
  72     str ("abc"),
  73     wstr (0),
  74     std_str ("xyz"),
  75 #if !defined(ACE_LACKS_STD_WSTRING)
  76     std_wstr (L"xyz"),
  77 #endif
  78     d (8),
  79     reps (-123),
  80     repus (456),
  81     repl (-65800L),
  82     repul (65800L),
  83     repb (false),
  84     repc ('d'),
  85     repll (-5000000000LL),
  86     repull (5000000000LL),
  87     repo (05),
  88     repf (3.14F),
  89     repd (6.00)
  90 {
  91   for (int i = 0;
  92        i < CDR_Test_Types::ARRAY_SIZE;
  93        ++i)
  94     a[i] = i;
  95 }
  96
  97 static int
  98 short_stream ()
  99 {
 100   // counter
 101   u_int i;
 102
 103   // Build an output stream
 104   ACE_OutputCDR os;
 105   ACE_SizeCDR ss;
 106
 107   // Basic types for output
 108   ACE_CDR::Char ch = 'A';
 109   ACE_CDR::Char wchtmp[] = {'\xF3'};
 110   ACE_CDR::WChar wch = *wchtmp;
 111   ACE_CDR::WChar wchar2[] = {'\x00'};    // empty wide string
 112   ACE_CDR::WChar *wstr = wchar2;
 113   ACE_CString str ("Test String");
 114   std::string std_str ("std string");
 115 #if !defined(ACE_LACKS_STD_WSTRING)
 116   std::wstring std_wstr (L"std wstring");
 117 #endif
 118   ACE_CDR::Short s = -123;
 119   ACE_CDR::UShort us =  123;
 120   ACE_CDR::Long l = -65800L;
 121   ACE_CDR::ULong ul =  65800UL;
 122   ACE_CDR::Float f =  1.23f;
 123   ACE_CDR::Double d =  123.456789;
 124   ACE_CDR::Fixed fx = ACE_CDR::Fixed::from_string ("8158901571290874");
 125
 126   // Arrays for output
 127   ACE_CDR::Short s_array[3] = { -1, 0, 1 };
 128   ACE_CDR::Long l_array[3] = { -345678, 0, 345678 };
 129   ACE_CDR::Float f_array[3] = { -1.23f, 0.0f, 1.23f };
 130   ACE_CDR::Double d_array[3] = { -123.456789, 0.0, 123.456789 };
 131   ACE_CDR::Boolean b_array[3] = { false, true, false };
 132
 133   ACE_OutputCDR::from_char fc (ch);
 134   ACE_OutputCDR::from_wchar fwc (wch);
 135   os << fc;
 136   os << fwc;
 137   os << str;
 138   os << wstr;
 139   os << std_str;
 140 #if !defined(ACE_LACKS_STD_WSTRING)
 141   os << std_wstr;
 142 #endif
 143   os << s;
 144   os << us;
 145   os << l;
 146   os << ul;
 147   os << f;
 148   os << d;
 149   os << fx;
 150   os.write_short_array (s_array, 3);
 151   os.write_long_array (l_array, 3);
 152   os.write_float_array (f_array, 3);
 153   os.write_double_array (d_array, 3);
 154   os.write_boolean_array (b_array, 3);
 155
 156   // Do the same for size stream.
 157   ss << fc;
 158   ss << fwc;
 159   ss << str;
 160   ss << wstr;
 161   ss << std_str;
 162 #if !defined(ACE_LACKS_STD_WSTRING)
 163   ss << std_wstr;
 164 #endif
 165   ss << s;
 166   ss << us;
 167   ss << l;
 168   ss << ul;
 169   ss << f;
 170   ss << d;
 171   ss << fx;
 172   ss.write_short_array (s_array, 3);
 173   ss.write_long_array (l_array, 3);
 174   ss.write_float_array (f_array, 3);
 175   ss.write_double_array (d_array, 3);
 176   ss.write_boolean_array (b_array, 3);
 177
 178   // Check the size.
 179   if (ss.total_length () != os.total_length ())
 180     ACE_ERROR_RETURN ((LM_ERROR,
 181                        ACE_TEXT ("%p\n"),
 182                        ACE_TEXT ("representation length does not match")),
 183                       1);
 184
 185   const ACE_Message_Block *out_mb = os.begin ();
 186   size_t len = out_mb->length ();
 187
 188   // Create an input stream (copy constructor)
 189   ACE_InputCDR is (os);
 190   const ACE_Message_Block *in_mb = is.start ();
 191
 192   if (in_mb->length () != len)
 193     ACE_ERROR_RETURN ((LM_ERROR,
 194                        ACE_TEXT ("%p\n"),
 195                        ACE_TEXT ("buffer length not preserved")),
 196                       1);
 197
 198   for (i = 0; i < len; i++)
 199     {
 200       unsigned long const in_chunk =
 201         static_cast<unsigned long> (* (in_mb->rd_ptr () + i));
 202
 203       unsigned long const out_chunk =
 204         static_cast<unsigned long> (* (out_mb->rd_ptr () + i));
 205
 206       if (in_chunk != out_chunk)
 207         ACE_ERROR_RETURN ((LM_ERROR,
 208                            ACE_TEXT ("%p\n"),
 209                            ACE_TEXT ("buffer contents not preserved")),
 210                           1);
 211     }
 212
 213   // Basic types for input
 214   ACE_CDR::Char ch1 = '\0';
 215   ACE_CDR::WChar wch1 = '\x00';
 216   ACE_CDR::WChar *wstr1 = 0;
 217   ACE_CString str1;
 218   std::string std_str1;
 219 #if !defined(ACE_LACKS_STD_WSTRING)
 220   std::wstring std_wstr1;
 221 #endif
 222   ACE_CDR::Short s1 = 0;
 223   ACE_CDR::UShort us1 = 0;
 224   ACE_CDR::Long l1 = 0L;
 225   ACE_CDR::ULong ul1 = 0UL;
 226   ACE_CDR::Float f1 = 0.0f;
 227   ACE_CDR::Double d1 = 0.0;
 228   ACE_CDR::Fixed fx1 = ACE_CDR::Fixed::from_string ("0");
 229
 230   // Arrays for input
 231   ACE_CDR::Short s_array1[3];
 232   ACE_CDR::Long l_array1[3];
 233   ACE_CDR::Float f_array1[3];
 234   ACE_CDR::Double d_array1[3];
 235
 236   ACE_DEBUG ((LM_DEBUG,
 237               ACE_TEXT ("Checking operators and arrays\n\n")));
 238
 239   ACE_InputCDR::to_char tc (ch1);
 240   is >> tc;
 241   ACE_InputCDR::to_wchar twc (wch1);
 242   is >> twc;
 243   is >> str1;
 244   ACE_InputCDR::to_wstring twstr (wstr1, 0);
 245   is >> twstr;
 246   // @todo Lose the ACE_Auto_Array_Ptr.  We should be using a
 247   //       std::string, or the like.
 248   ACE_Auto_Array_Ptr<ACE_CDR::WChar> safe_wstr (wstr1);
 249   is >> std_str1;
 250 #if !defined(ACE_LACKS_STD_WSTRING)
 251   is >> std_wstr1;
 252 #endif
 253   is >> s1;
 254   is >> us1;
 255   is >> l1;
 256   is >> ul1;
 257   is >> f1;
 258   is >> d1;
 259   is >> fx1;
 260   is.read_short_array (s_array1, 3);
 261   is.read_long_array (l_array1, 3);
 262   is.read_float_array (f_array1, 3);
 263   is.read_double_array (d_array1, 3);
 264
 265   if (ch1 != ch)
 266     ACE_ERROR_RETURN ((LM_ERROR,
 267                        ACE_TEXT ("%p\n"),
 268                        ACE_TEXT ("char transfer error")),
 269                       1);
 270
 271   if (wch1 != wch)
 272     ACE_ERROR_RETURN ((LM_ERROR,
 273                        ACE_TEXT ("%p\n"),
 274                        ACE_TEXT ("wchar transfer error")),
 275                       1);
 276
 277   if (str1 != str)
 278     ACE_ERROR_RETURN ((LM_ERROR,
 279                        ACE_TEXT ("%p\n"),
 280                        ACE_TEXT ("string transfer error")),
 281                       1);
 282
 283   if (ACE_OS::wscmp (wstr1, wstr))
 284      ACE_ERROR_RETURN ((LM_ERROR,
 285                         ACE_TEXT ("%p\n"),
 286                         ACE_TEXT ("wide string transfer error")),
 287                        1);
 288
 289   if (std_str1 != std_str)
 290     ACE_ERROR_RETURN ((LM_ERROR,
 291                        ACE_TEXT ("%p\n"),
 292                        ACE_TEXT ("std::string transfer error")),
 293                       1);
 294
 295 #if !defined(ACE_LACKS_STD_WSTRING)
 296   if (std_wstr1 != std_wstr)
 297     ACE_ERROR_RETURN ((LM_ERROR,
 298                        ACE_TEXT ("%p\n"),
 299                        ACE_TEXT ("std::wstring transfer error")),
 300                       1);
 301 #endif
 302
 303   if (s1 != s)
 304     ACE_ERROR_RETURN ((LM_ERROR,
 305                        ACE_TEXT ("%p\n"),
 306                        ACE_TEXT ("short transfer error")),
 307                       1);
 308
 309   if (us1 != us)
 310     ACE_ERROR_RETURN ((LM_ERROR,
 311                        ACE_TEXT ("%p\n"),
 312                        ACE_TEXT ("ushort transfer error")),
 313                       1);
 314
 315   if (l1 != l)
 316     ACE_ERROR_RETURN ((LM_ERROR,
 317                        ACE_TEXT ("%p\n"),
 318                        ACE_TEXT ("long transfer error")),
 319                       1);
 320
 321   if (ul1 != ul)
 322     ACE_ERROR_RETURN ((LM_ERROR,
 323                        ACE_TEXT ("%p\n"),
 324                        ACE_TEXT ("ulong transfer error")),
 325                       1);
 326
 327   if (!ACE::is_equal (f1, f))
 328     ACE_ERROR_RETURN ((LM_ERROR,
 329                        ACE_TEXT ("%p\n"),
 330                        ACE_TEXT ("float transfer error")),
 331                       1);
 332
 333   if (!ACE::is_equal (d1, d))
 334     ACE_ERROR_RETURN ((LM_ERROR,
 335                        ACE_TEXT ("%p\n"),
 336                        ACE_TEXT ("double transfer error")),
 337                       1);
 338
 339   if (fx1 != fx)
 340     ACE_ERROR_RETURN ((LM_ERROR,
 341                        ACE_TEXT ("%p\n"),
 342                        ACE_TEXT ("fixed transfer error")),
 343                       1);
 344
 345   for (i = 0 ; i < 3; i++)
 346     if (s_array1[i] != s_array[i])
 347       ACE_ERROR_RETURN ((LM_ERROR,
 348                          ACE_TEXT ("%p\n"),
 349                          ACE_TEXT ("short array transfer error")),
 350                         1);
 351
 352   for (i = 0 ; i < 3; i++)
 353     if (l_array1[i] != l_array[i])
 354       ACE_ERROR_RETURN ((LM_ERROR,
 355                          ACE_TEXT ("%p\n"),
 356                          ACE_TEXT ("long array transfer error")),
 357                         1);
 358
 359   for (i = 0 ; i < 3; i++)
 360     if (!ACE::is_equal (f_array1[i], f_array[i]))
 361       ACE_ERROR_RETURN ((LM_ERROR,
 362                          ACE_TEXT ("%p\n"),
 363                          ACE_TEXT ("float array transfer error")),
 364                         1);
 365
 366   for (i = 0 ; i < 3; i++)
 367     if (!ACE::is_equal (d_array1[i], d_array[i]))
 368       ACE_ERROR_RETURN ((LM_ERROR,
 369                          ACE_TEXT ("%p\n"),
 370                          ACE_TEXT ("double array transfer error")),
 371                         1);
 372
 373   return 0;
 374 }
 375
 376 int
 377 CDR_Test_Types::test_put (ACE_OutputCDR &cdr)
 378 {
 379   for (int i = 0; i < n; ++i)
 380     {
 381       if (cdr.write_octet (this->o) == 0)
 382         ACE_ERROR_RETURN ((LM_ERROR,
 383                            ACE_TEXT ("write_octet[%d] failed\n"),
 384                            i),
 385                           1);
 386       if (cdr.write_short (this->s) == 0)
 387         ACE_ERROR_RETURN ((LM_ERROR,
 388                            ACE_TEXT ("write_short[%d] failed\n"),
 389                            i),
 390                           1);
 391       if (cdr.write_octet (this->o) == 0)
 392         ACE_ERROR_RETURN ((LM_ERROR,
 393                            ACE_TEXT ("write_octet-2[%d] failed\n"),
 394                            i),
 395                           1);
 396       if (cdr.write_long (this->l) == 0)
 397         ACE_ERROR_RETURN ((LM_ERROR,
 398                            ACE_TEXT ("write_long[%d] failed\n"),
 399                            i),
 400                           1);
 401       if (cdr.write_long (this->l) == 0)
 402         ACE_ERROR_RETURN ((LM_ERROR,
 403                            ACE_TEXT ("write_long-2[%d] failed\n"),
 404                            i),
 405                           1);
 406
 407       if (cdr.write_string (this->str) == 0)
 408         ACE_ERROR_RETURN ((LM_ERROR,
 409                            ACE_TEXT ("write_string[%d] failed\n"),
 410                            i),
 411                           1);
 412
 413       if (cdr.write_wstring (this->wstr) == 0)
 414         ACE_ERROR_RETURN ((LM_ERROR,
 415                            ACE_TEXT ("write_wstring[%d] failed\n"),
 416                            i),
 417                           1);
 418
 419       if (cdr.write_string (this->std_str) == 0)
 420         ACE_ERROR_RETURN ((LM_ERROR,
 421                            ACE_TEXT ("write_string(std)[%d] failed\n"),
 422                            i),
 423                           1);
 424
 425 #if !defined(ACE_LACKS_STD_WSTRING)
 426       if (cdr.write_wstring (this->std_wstr) == 0)
 427         ACE_ERROR_RETURN ((LM_ERROR,
 428                            ACE_TEXT ("write_wstring(std)[%d] failed\n"),
 429                            i),
 430                           1);
 431 #endif
 432     }
 433
 434   return 0;
 435 }
 436
 437 int
 438 CDR_Test_Types::test_get (ACE_InputCDR &cdr) const
 439 {
 440   ACE_CDR::Octet xo;
 441   ACE_CDR::Short xs;
 442   ACE_CDR::Long xl;
 443
 444   for (int i = 0; i < n; ++i)
 445     {
 446       if (cdr.read_octet (xo) == 0)
 447         ACE_ERROR_RETURN ((LM_ERROR,
 448                            ACE_TEXT ("read_octet[%d] failed\n"),
 449                            i),
 450                           1);
 451       if (xo != this->o)
 452         ACE_ERROR_RETURN ((LM_ERROR,
 453                            ACE_TEXT ("octet[%d] differs\n"),
 454                            i),
 455                           1);
 456       if (cdr.read_short (xs) == 0)
 457         ACE_ERROR_RETURN ((LM_ERROR,
 458                            ACE_TEXT ("read_short[%d] failed\n"),
 459                            i), 1);
 460       if (xs != this->s)
 461         ACE_ERROR_RETURN ((LM_ERROR,
 462                            ACE_TEXT ("short[%d] differs\n"),
 463                            i),
 464                           1);
 465       if (cdr.read_octet (xo) == 0)
 466         ACE_ERROR_RETURN ((LM_ERROR,
 467                            ACE_TEXT ("read_octet-2[%d] failed\n"),
 468                            i),
 469                           1);
 470       if (xo != this->o)
 471         ACE_ERROR_RETURN ((LM_ERROR,
 472                            ACE_TEXT ("octet-2[%d] differs\n"),
 473                            i),
 474                           1);
 475       if (cdr.read_long (xl) == 0)
 476         ACE_ERROR_RETURN ((LM_ERROR,
 477                            ACE_TEXT ("read_long[%d] failed\n"),
 478                            i),
 479                           1);
 480       if (xl != this->l)
 481         ACE_ERROR_RETURN ((LM_ERROR,
 482                            ACE_TEXT ("long[%d] differs\n"),
 483                            i),
 484                           1);
 485       if (cdr.read_long (xl) == 0)
 486         ACE_ERROR_RETURN ((LM_ERROR,
 487                            ACE_TEXT ("read_long-2[%d] failed\n"),
 488                            i),
 489                           1);
 490       if (xl != this->l)
 491         ACE_ERROR_RETURN ((LM_ERROR,
 492                            ACE_TEXT ("long-2[%d] differs\n"),
 493                            i),
 494                           1);
 495
 496       ACE_CDR::Char *xstr;
 497       if (cdr.read_string (xstr) == 0)
 498         ACE_ERROR_RETURN ((LM_ERROR,
 499                            ACE_TEXT ("read_string2[%d] failed\n"),
 500                            i),
 501                           1);
 502       ACE_Auto_Basic_Array_Ptr<ACE_CDR::Char> auto_xstr (xstr);
 503       if (ACE_OS::strcmp (auto_xstr.get (), this->str) != 0)
 504         ACE_ERROR_RETURN ((LM_ERROR,
 505                            ACE_TEXT ("string[%d] differs\n"),
 506                            i),
 507                           1);
 508
 509       ACE_CDR::WChar *wstr1;
 510       if (cdr.read_wstring (wstr1) == 0)
 511         ACE_ERROR_RETURN ((LM_ERROR,
 512                             ACE_TEXT ("read_wstring2[%d] failed\n"),
 513                             i),
 514                            1);
 515       // zero length
 516       ACE_Auto_Basic_Array_Ptr<ACE_CDR::WChar> auto_xwstr (wstr1);
 517        if (ACE_OS::wslen(auto_xwstr.get () ))
 518          ACE_ERROR_RETURN ((LM_ERROR,
 519                             ACE_TEXT ("wstring[%d] differs\n"),
 520                              i),
 521                             1);
 522
 523        std::string std_xstr;
 524        if (cdr.read_string (std_xstr) == 0)
 525          ACE_ERROR_RETURN ((LM_ERROR,
 526                             ACE_TEXT ("read_string(std)[%d] failed\n"),
 527                             i),
 528                            1);
 529        if (std_xstr != this->std_str)
 530          ACE_ERROR_RETURN ((LM_ERROR,
 531                             ACE_TEXT ("std::string[%d] differs\n"),
 532                             i),
 533                            1);
 534
 535 #if !defined(ACE_LACKS_STD_WSTRING)
 536        std::wstring std_xwstr;
 537        if (cdr.read_wstring (std_xwstr) == 0)
 538          ACE_ERROR_RETURN ((LM_ERROR,
 539                             ACE_TEXT ("read_wstring(std)[%d] failed\n"),
 540                             i),
 541                            1);
 542        if (std_xwstr != this->std_wstr)
 543          ACE_ERROR_RETURN ((LM_ERROR,
 544                             ACE_TEXT ("std::wstring[%d] differs\n"),
 545                             i),
 546                            1);
 547 #endif
 548     }
 549   return 0;
 550 }
 551
 552 int
 553 CDR_Test_Types::test_put_placeholder (ACE_OutputCDR &cdr)
 554 {
 555   // Write a placeholder then a bunch of other stuff, then replace.
 556   // Long
 557   char *pos = cdr.write_long_placeholder ();
 558   if (test_put (cdr) != 0)
 559     ACE_ERROR_RETURN ((LM_ERROR,
 560                        ACE_TEXT ("test_put (long placeholder) failed\n")),
 561                       1);
 562   if (!cdr.replace (this->repl, pos))
 563     ACE_ERROR_RETURN ((LM_ERROR,
 564                        ACE_TEXT ("replace(long) failed\n")),
 565                       1);
 566
 567   // ULong
 568   pos = cdr.write_long_placeholder ();
 569   if (test_put (cdr) != 0)
 570     ACE_ERROR_RETURN ((LM_ERROR,
 571                        ACE_TEXT ("test_put (long placeholder) failed\n")),
 572                       1);
 573   if (!cdr.replace (this->repul, pos))
 574     ACE_ERROR_RETURN ((LM_ERROR,
 575                        ACE_TEXT ("replace(ulong) failed\n")),
 576                       1);
 577
 578   // Short
 579   pos = cdr.write_short_placeholder ();
 580   if (test_put (cdr) != 0)
 581    ACE_ERROR_RETURN ((LM_ERROR,
 582                       ACE_TEXT ("test_put (short placeholder) failed\n")),
 583                      1);
 584   if (!cdr.replace (this->reps, pos))
 585    ACE_ERROR_RETURN ((LM_ERROR,
 586                       ACE_TEXT ("replace(short) failed\n")),
 587                      1);
 588
 589   // UShort
 590   pos = cdr.write_short_placeholder ();
 591   if (test_put (cdr) != 0)
 592    ACE_ERROR_RETURN ((LM_ERROR,
 593                       ACE_TEXT ("test_put (short placeholder) failed\n")),
 594                      1);
 595   if (!cdr.replace (this->repus, pos))
 596    ACE_ERROR_RETURN ((LM_ERROR,
 597                       ACE_TEXT ("replace(ushort) failed\n")),
 598                      1);
 599
 600   // Boolean
 601   pos = cdr.write_boolean_placeholder ();
 602   if (test_put (cdr) != 0)
 603    ACE_ERROR_RETURN ((LM_ERROR,
 604                       ACE_TEXT ("test_put (boolean placeholder) failed\n")),
 605                      1);
 606   if (!cdr.replace (this->repb, pos))
 607    ACE_ERROR_RETURN ((LM_ERROR,
 608                       ACE_TEXT ("replace(boolean) failed\n")),
 609                      1);
 610
 611   // Char
 612   pos = cdr.write_char_placeholder ();
 613   if (test_put (cdr) != 0)
 614    ACE_ERROR_RETURN ((LM_ERROR,
 615                       ACE_TEXT ("test_put (char placeholder) failed\n")),
 616                      1);
 617   if (!cdr.replace (this->repc, pos))
 618    ACE_ERROR_RETURN ((LM_ERROR,
 619                       ACE_TEXT ("replace(char) failed\n")),
 620                      1);
 621
 622   // LongLong
 623   pos = cdr.write_longlong_placeholder ();
 624   if (test_put (cdr) != 0)
 625    ACE_ERROR_RETURN ((LM_ERROR,
 626                       ACE_TEXT ("test_put (longlong placeholder) failed\n")),
 627                      1);
 628   if (!cdr.replace (this->repll, pos))
 629    ACE_ERROR_RETURN ((LM_ERROR,
 630                       ACE_TEXT ("replace(longlong) failed\n")),
 631                      1);
 632
 633   // ULongLong
 634   pos = cdr.write_longlong_placeholder ();
 635   if (test_put (cdr) != 0)
 636    ACE_ERROR_RETURN ((LM_ERROR,
 637                       ACE_TEXT ("test_put (longlong placeholder) failed\n")),
 638                      1);
 639   if (!cdr.replace (this->repull, pos))
 640    ACE_ERROR_RETURN ((LM_ERROR,
 641                       ACE_TEXT ("replace(ulonglong) failed\n")),
 642                      1);
 643
 644   // Octet
 645   pos = cdr.write_octet_placeholder ();
 646   if (test_put (cdr) != 0)
 647    ACE_ERROR_RETURN ((LM_ERROR,
 648                       ACE_TEXT ("test_put (octet placeholder) failed\n")),
 649                      1);
 650   if (!cdr.replace (this->repo, pos))
 651    ACE_ERROR_RETURN ((LM_ERROR,
 652                       ACE_TEXT ("replace(octet) failed\n")),
 653                      1);
 654
 655   // Float
 656   pos = cdr.write_float_placeholder ();
 657   if (test_put (cdr) != 0)
 658    ACE_ERROR_RETURN ((LM_ERROR,
 659                       ACE_TEXT ("test_put (float placeholder) failed\n")),
 660                      1);
 661   if (!cdr.replace (this->repf, pos))
 662    ACE_ERROR_RETURN ((LM_ERROR,
 663                       ACE_TEXT ("replace(float) failed\n")),
 664                      1);
 665
 666   // Double
 667   pos = cdr.write_double_placeholder ();
 668   if (test_put (cdr) != 0)
 669    ACE_ERROR_RETURN ((LM_ERROR,
 670                       ACE_TEXT ("test_put (double placeholder) failed\n")),
 671                      1);
 672   if (!cdr.replace (this->repd, pos))
 673    ACE_ERROR_RETURN ((LM_ERROR,
 674                       ACE_TEXT ("replace(double) failed\n")),
 675                      1);
 676
 677   return 0;
 678 }
 679
 680 int
 681 CDR_Test_Types::test_get_placeholder (ACE_InputCDR &cdr) const
 682 {
 683   ACE_CDR::Short xs;
 684   ACE_CDR::UShort xus;
 685   ACE_CDR::Long xl;
 686   ACE_CDR::ULong xul;
 687   ACE_CDR::Boolean xb;
 688   ACE_CDR::Char xc;
 689   ACE_CDR::LongLong xll;
 690   ACE_CDR::ULongLong xull;
 691   ACE_CDR::Octet xo;
 692   ACE_CDR::Float xf;
 693   ACE_CDR::Double xd;
 694
 695   if (cdr.read_long (xl) == 0)
 696     ACE_ERROR_RETURN ((LM_ERROR,
 697                        ACE_TEXT ("read_long failed\n")),
 698                       1);
 699   if (xl != this->repl)
 700     ACE_ERROR_RETURN ((LM_ERROR,
 701                        ACE_TEXT ("replaced long differs\n")),
 702                       1);
 703
 704   // The bunch of stuff written after the placeholder by test_put_placeholder
 705   // should still be valid; check that it is.
 706   if (test_get (cdr) != 0)
 707     ACE_ERROR_RETURN ((LM_ERROR,
 708                        ACE_TEXT ("test_get (long) failed\n")),
 709                       1);
 710
 711   if (cdr.read_ulong (xul) == 0)
 712     ACE_ERROR_RETURN ((LM_ERROR,
 713                        ACE_TEXT ("read_ulong failed\n")), 1);
 714   if (xul != this->repul)
 715     ACE_ERROR_RETURN ((LM_ERROR,
 716                        ACE_TEXT ("replaced ulong differs\n")),
 717                       1);
 718
 719   if (test_get (cdr) != 0)
 720     ACE_ERROR_RETURN ((LM_ERROR,
 721                        ACE_TEXT ("test_get (ulong) failed\n")),
 722                       1);
 723
 724   if (cdr.read_short (xs) == 0)
 725     ACE_ERROR_RETURN ((LM_ERROR,
 726                        ACE_TEXT ("read_short failed\n")), 1);
 727   if (xs != this->reps)
 728     ACE_ERROR_RETURN ((LM_ERROR,
 729                        ACE_TEXT ("replaced short differs\n")),
 730                       1);
 731
 732   if (test_get (cdr) != 0)
 733     ACE_ERROR_RETURN ((LM_ERROR,
 734                        ACE_TEXT ("test_get (short) failed\n")),
 735                       1);
 736
 737   if (cdr.read_ushort (xus) == 0)
 738     ACE_ERROR_RETURN ((LM_ERROR,
 739                        ACE_TEXT ("read_ushort failed\n")), 1);
 740   if (xus != this->repus)
 741     ACE_ERROR_RETURN ((LM_ERROR,
 742                        ACE_TEXT ("replaced ushort differs\n")),
 743                       1);
 744
 745   if (test_get (cdr) != 0)
 746     ACE_ERROR_RETURN ((LM_ERROR,
 747                        ACE_TEXT ("test_get (ushort) failed\n")),
 748                       1);
 749
 750   if (cdr.read_boolean (xb) == 0)
 751     ACE_ERROR_RETURN ((LM_ERROR,
 752                        ACE_TEXT ("read_boolean failed\n")), 1);
 753   if (xb != this->repb)
 754     ACE_ERROR_RETURN ((LM_ERROR,
 755                        ACE_TEXT ("replaced boolean differs\n")),
 756                       1);
 757
 758   if (test_get (cdr) != 0)
 759     ACE_ERROR_RETURN ((LM_ERROR,
 760                        ACE_TEXT ("test_get (boolean) failed\n")),
 761                       1);
 762
 763   if (cdr.read_char (xc) == 0)
 764     ACE_ERROR_RETURN ((LM_ERROR,
 765                        ACE_TEXT ("read_char failed\n")), 1);
 766   if (xc != this->repc)
 767     ACE_ERROR_RETURN ((LM_ERROR,
 768                        ACE_TEXT ("replaced char differs\n")),
 769                       1);
 770
 771   if (test_get (cdr) != 0)
 772     ACE_ERROR_RETURN ((LM_ERROR,
 773                        ACE_TEXT ("test_get (char) failed\n")),
 774                       1);
 775
 776
 777   if (cdr.read_longlong (xll) == 0)
 778     ACE_ERROR_RETURN ((LM_ERROR,
 779                        ACE_TEXT ("read_longlong failed\n")), 1);
 780   if (xll != this->repll)
 781     ACE_ERROR_RETURN ((LM_ERROR,
 782                        ACE_TEXT ("replaced longlong differs\n")),
 783                       1);
 784
 785   if (test_get (cdr) != 0)
 786     ACE_ERROR_RETURN ((LM_ERROR,
 787                        ACE_TEXT ("test_get (longlong) failed\n")),
 788                       1);
 789
 790   if (cdr.read_ulonglong (xull) == 0)
 791     ACE_ERROR_RETURN ((LM_ERROR,
 792                        ACE_TEXT ("read_ulonglong failed\n")), 1);
 793   if (xull != this->repull)
 794     ACE_ERROR_RETURN ((LM_ERROR,
 795                        ACE_TEXT ("replaced ulonglong differs\n")),
 796                       1);
 797
 798   if (test_get (cdr) != 0)
 799     ACE_ERROR_RETURN ((LM_ERROR,
 800                        ACE_TEXT ("test_get (ulonglong) failed\n")),
 801                       1);
 802
 803   if (cdr.read_octet (xo) == 0)
 804     ACE_ERROR_RETURN ((LM_ERROR,
 805                        ACE_TEXT ("read_octet failed\n")), 1);
 806   if (xo != this->repo)
 807     ACE_ERROR_RETURN ((LM_ERROR,
 808                        ACE_TEXT ("replaced octet differs\n")),
 809                       1);
 810
 811   if (test_get (cdr) != 0)
 812     ACE_ERROR_RETURN ((LM_ERROR,
 813                        ACE_TEXT ("test_get (octet) failed\n")),
 814                       1);
 815
 816   if (cdr.read_float (xf) == 0)
 817     ACE_ERROR_RETURN ((LM_ERROR,
 818                        ACE_TEXT ("read_float failed\n")), 1);
 819   if (xf != this->repf)
 820     ACE_ERROR_RETURN ((LM_ERROR,
 821                        ACE_TEXT ("replaced float differs\n")),
 822                       1);
 823
 824   if (test_get (cdr) != 0)
 825     ACE_ERROR_RETURN ((LM_ERROR,
 826                        ACE_TEXT ("test_get (float) failed\n")),
 827                       1);
 828
 829   if (cdr.read_double (xd) == 0)
 830     ACE_ERROR_RETURN ((LM_ERROR,
 831                        ACE_TEXT ("read_double failed\n")), 1);
 832   if (xd != this->repd)
 833     ACE_ERROR_RETURN ((LM_ERROR,
 834                        ACE_TEXT ("replaced double differs\n")),
 835                       1);
 836
 837   if (test_get (cdr) != 0)
 838     ACE_ERROR_RETURN ((LM_ERROR,
 839                        ACE_TEXT ("test_get (double) failed\n")),
 840                       1);
 841
 842   return 0;
 843 }
 844
 845
 846 int
 847 run_main (int argc, ACE_TCHAR *argv[])
 848 {
 849   ACE_START_TEST (ACE_TEXT ("CDR_Test"));
 850
 851   ACE_DEBUG ((LM_DEBUG,
 852               ACE_TEXT ("This is ACE Version %u.%u.%u\n\n"),
 853               ACE::major_version (),
 854               ACE::minor_version(),
 855               ACE::micro_version()));
 856
 857   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("dn:l:"));
 858   int opt;
 859   int debug = 0;
 860
 861   while ((opt = get_opt ()) != EOF)
 862     {
 863       switch (opt)
 864         {
 865           case 'd':
 866             debug++;
 867             break;
 868           case 'n':
 869             n = ACE_OS::atoi (get_opt.opt_arg ());
 870             break;
 871           case 'l':
 872             nloops = ACE_OS::atoi (get_opt.opt_arg ());
 873             break;
 874           case '?':
 875           default:
 876             ACE_DEBUG ((LM_DEBUG,
 877                         ACE_TEXT ("Usage: %s ")
 878                         ACE_TEXT ("-d debug")
 879                         ACE_TEXT ("-n <num> ")
 880                         ACE_TEXT ("-l <loops> ")
 881                         ACE_TEXT ("\n"),
 882                         ACE_TEXT ("CDR_Test")));
 883             return -1;
 884         }
 885     }
 886
 887   // Sanity checks.
 888   ACE_TEST_ASSERT (sizeof (ACE_CDR::Boolean)    >= 1);
 889   ACE_TEST_ASSERT (sizeof (ACE_CDR::Octet)      == 1);
 890   ACE_TEST_ASSERT (sizeof (ACE_CDR::WChar)      >= 2);
 891   ACE_TEST_ASSERT (sizeof (ACE_CDR::Short)      == 2);
 892   ACE_TEST_ASSERT (sizeof (ACE_CDR::Long)       == 4);
 893   ACE_TEST_ASSERT (sizeof (ACE_CDR::LongLong)   == 8);
 894   ACE_TEST_ASSERT (sizeof (ACE_CDR::Float)      == 4);
 895   ACE_TEST_ASSERT (sizeof (ACE_CDR::Double)     == 8);
 896   ACE_TEST_ASSERT (sizeof (ACE_CDR::LongDouble) == 16);
 897
 898   ACE_DEBUG ((LM_DEBUG,
 899               ACE_TEXT ("Testing ACE CDR functions - short stream\n\n")));
 900
 901   if (short_stream () != 0 )
 902     return 1;
 903
 904   ACE_DEBUG ((LM_DEBUG,
 905               ACE_TEXT ("Short stream - no errors\n\n")
 906               ACE_TEXT ("Testing basic types - long stream\n\n")));
 907
 908   for (int i = 0; i < nloops; ++i)
 909     {
 910       ACE_OutputCDR output;
 911       CDR_Test_Types test_types;
 912
 913       if (test_types.test_put (output) != 0)
 914         return 1;
 915
 916       ACE_InputCDR input (output);
 917       if (debug > 0)
 918         {
 919           ACE_DEBUG ((LM_DEBUG,
 920                       ACE_TEXT ("Output CDR:\n")));
 921           ACE_HEX_DUMP ((LM_DEBUG,
 922                          input.rd_ptr(),
 923                          64));
 924           ACE_DEBUG ((LM_DEBUG,
 925                       ACE_TEXT ("Input CDR:\n")));
 926           ACE_HEX_DUMP ((LM_DEBUG,
 927                          input.rd_ptr(),
 928                          64));
 929         }
 930
 931       if (test_types.test_get (input) != 0)
 932         return 1;
 933     }
 934
 935   ACE_DEBUG ((LM_DEBUG,
 936               ACE_TEXT ("Long stream - no errors\n\n")
 937               ACE_TEXT ("Testing basic types - long stream[2]\n\n")));
 938
 939   for (int j = 0; j < nloops; ++j)
 940     {
 941       ACE_OutputCDR output;
 942       CDR_Test_Types test_types;
 943
 944       if (test_types.test_put (output) != 0)
 945         return 1;
 946
 947       ACE_InputCDR input (output.begin ());
 948       if (debug > 0)
 949         {
 950           ACE_DEBUG ((LM_DEBUG,
 951                       ACE_TEXT ("Output CDR:\n")));
 952           ACE_HEX_DUMP ((LM_DEBUG,
 953                          input.rd_ptr(),
 954                          64));
 955           ACE_DEBUG ((LM_DEBUG,
 956                       ACE_TEXT ("Input CDR:\n")));
 957           ACE_HEX_DUMP ((LM_DEBUG,
 958                          input.rd_ptr(),
 959                          64));
 960         }
 961
 962       if (test_types.test_get (input) != 0)
 963         return 1;
 964     }
 965
 966   ACE_DEBUG ((LM_DEBUG,
 967               ACE_TEXT ("Long stream[2] - no errors\n\n")
 968               ACE_TEXT ("Testing consolidation\n\n")));
 969
 970   ACE_OutputCDR output (30);
 971   CDR_Test_Types test_types;
 972
 973   if (test_types.test_put (output) != 0)
 974     return 1;
 975
 976   if (output.begin () == output.end ())
 977     ACE_DEBUG ((LM_WARNING,
 978                 ACE_TEXT ("Only one block needed; test no effective.\n")));
 979   else
 980     {
 981       if (output.consolidate () != 0)
 982         ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("consolidate")));
 983     }
 984
 985   ACE_InputCDR input (output);
 986   if (debug > 0)
 987     {
 988       ACE_DEBUG ((LM_DEBUG,
 989                   ACE_TEXT ("Output CDR:\n")));
 990       ACE_HEX_DUMP ((LM_DEBUG,
 991                      input.rd_ptr(),
 992                      64));
 993       ACE_DEBUG ((LM_DEBUG,
 994                   ACE_TEXT ("Input CDR:\n")));
 995       ACE_HEX_DUMP ((LM_DEBUG,
 996                      input.rd_ptr(),
 997                      64));
 998     }
 999
1000   if (test_types.test_get (input) != 0)
1001     return 1;
1002
1003   ACE_DEBUG ((LM_DEBUG,
1004               ACE_TEXT ("Consolidation - no errors\n\n")
1005               ACE_TEXT ("Testing placeholder/replace\n\n")));
1006
1007   output.reset();
1008   if (test_types.test_put_placeholder (output) != 0)
1009     return 1;
1010
1011   input = ACE_InputCDR(output);
1012   if (debug > 0)
1013     {
1014       ACE_DEBUG ((LM_DEBUG,
1015                   ACE_TEXT ("Output CDR:\n")));
1016       ACE_HEX_DUMP ((LM_DEBUG,
1017                      input.rd_ptr(),
1018                      64));
1019       ACE_DEBUG ((LM_DEBUG,
1020                   ACE_TEXT ("Input CDR:\n")));
1021       ACE_HEX_DUMP ((LM_DEBUG,
1022                      input.rd_ptr(),
1023                      64));
1024     }
1025
1026   if (test_types.test_get_placeholder (input) != 0)
1027     return 1;
1028
1029   ACE_DEBUG ((LM_DEBUG,
1030               ACE_TEXT ("Placeholder/Replace - no errors\n\n")));
1031
1032   ACE_END_TEST;
1033   return 0;
1034 }
1035