ndk/tests/device/test-stlport/unit/num_put_get_test.cpp

   1 #include <limits>
   2
   3 #if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
   4 #  include <iomanip>
   5 #  include <string>
   6 #  include <sstream>
   7 #  include <cstdio>
   8 /*
   9 #  include <iostream>
  10 #  include <ieee754.h>
  11 */
  12
  13 #  include "complete_digits.h"
  14 #  include "cppunit/cppunit_proxy.h"
  15
  16 #  if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
  17 using namespace std;
  18 #  endif
  19
  20 //
  21 // TestCase class
  22 //
  23 class NumPutGetTest : public CPPUNIT_NS::TestCase
  24 {
  25   CPPUNIT_TEST_SUITE(NumPutGetTest);
  26 #  if defined (__BORLANDC__)
  27   /* Ignore FPU exceptions, set FPU precision to 64 bits */
  28   unsigned int _float_control_word = _control87(0, 0);
  29   _control87(PC_64|MCW_EM|IC_AFFINE, MCW_PC|MCW_EM|MCW_IC);
  30 #  endif
  31   CPPUNIT_TEST(num_put_float);
  32   CPPUNIT_TEST(num_put_integer);
  33   CPPUNIT_TEST(num_get_float);
  34   CPPUNIT_TEST(num_get_integer);
  35   CPPUNIT_TEST(inhex);
  36   CPPUNIT_TEST(pointer);
  37   CPPUNIT_TEST(fix_float_long);
  38   CPPUNIT_TEST(custom_numpunct);
  39 #  if defined (__BORLANDC__)
  40   /* Reset floating point control word */
  41   _clear87();
  42   _control87(_float_control_word, MCW_PC|MCW_EM|MCW_IC);
  43 #  endif
  44   CPPUNIT_TEST_SUITE_END();
  45
  46 private:
  47   void num_put_float();
  48   void num_put_integer();
  49   void num_get_float();
  50   void num_get_integer();
  51   void inhex();
  52   void pointer();
  53   void fix_float_long();
  54   void custom_numpunct();
  55
  56   static bool check_float(float val, float ref)
  57   {
  58     float epsilon = numeric_limits<float>::epsilon();
  59     return val <= ref + epsilon && val >= ref - epsilon;
  60   }
  61
  62   static bool check_double(double val, double ref)
  63   {
  64     double epsilon = numeric_limits<double>::epsilon();
  65     return val <= ref + epsilon && val >= ref - epsilon;
  66   }
  67
  68   static string reset_stream(ostringstream &ostr)
  69   {
  70     string tmp = ostr.str();
  71     ostr.str("");
  72     return tmp;
  73   }
  74
  75 #if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
  76   template <class F>
  77   void check_get_float( F v )
  78   {
  79     F in_val_d = v;
  80     typedef numeric_limits<F> limits;
  81     {
  82       stringstream str;
  83
  84       str << "1E+" << limits::max_exponent10;
  85
  86       str >> in_val_d;
  87       CPPUNIT_ASSERT(!str.fail());
  88       CPPUNIT_ASSERT(str.eof());
  89       CPPUNIT_CHECK( in_val_d == in_val_d );
  90       CPPUNIT_CHECK( in_val_d != limits::infinity() );
  91     }
  92     {
  93       stringstream str;
  94
  95       str << "-1E+" << limits::max_exponent10;
  96
  97       str >> in_val_d;
  98       CPPUNIT_ASSERT(!str.fail());
  99       CPPUNIT_ASSERT(str.eof());
 100       CPPUNIT_CHECK( in_val_d == in_val_d );
 101       CPPUNIT_CHECK( in_val_d != -limits::infinity() );
 102     }
 103     {
 104       stringstream str;
 105
 106       str << "1E" << limits::min_exponent10;
 107
 108       str >> in_val_d;
 109       CPPUNIT_ASSERT(!str.fail());
 110       CPPUNIT_ASSERT(str.eof());
 111       CPPUNIT_CHECK( in_val_d == in_val_d );
 112       CPPUNIT_CHECK( in_val_d != F(0.0) );
 113     }
 114     {
 115       stringstream str;
 116
 117       str << "1E+" << (limits::max_exponent10 + 1);
 118
 119       str >> in_val_d;
 120       CPPUNIT_ASSERT(!str.fail());
 121       CPPUNIT_ASSERT(str.eof());
 122       CPPUNIT_CHECK( in_val_d == in_val_d );
 123       CPPUNIT_CHECK( in_val_d == limits::infinity() );
 124     }
 125     {
 126       stringstream str;
 127
 128       str << "-1E+" << (limits::max_exponent10 + 1);
 129
 130       str >> in_val_d;
 131       CPPUNIT_ASSERT(!str.fail());
 132       CPPUNIT_ASSERT(str.eof());
 133       CPPUNIT_CHECK( in_val_d == in_val_d );
 134       CPPUNIT_CHECK( in_val_d == -limits::infinity() );
 135     }
 136     {
 137       stringstream str;
 138
 139       str << "1E" << (limits::min_exponent10 - 1);
 140
 141       str >> in_val_d;
 142       CPPUNIT_ASSERT(!str.fail());
 143       CPPUNIT_ASSERT(str.eof());
 144       CPPUNIT_CHECK( in_val_d == in_val_d );
 145       CPPUNIT_CHECK( in_val_d >= F(0.0) && in_val_d <= limits::min() );
 146     }
 147 #if !defined (__MINGW32__)
 148     {
 149       stringstream str;
 150
 151       str << limits::max();
 152
 153       CPPUNIT_ASSERT(!str.fail());
 154       CPPUNIT_CHECK( str.str() != "inf" && str.str() != "Inf" );
 155       CPPUNIT_CHECK( str.str() != "-inf" && str.str() != "-Inf" );
 156       CPPUNIT_CHECK( str.str() != "nan" && str.str() != "NaN" );
 157       CPPUNIT_CHECK( str.str() != "-nan" && str.str() != "-NaN" );
 158       //CPPUNIT_MESSAGE( str.str().c_str() );
 159
 160       //str.str("");
 161       //str << limits::max_exponent10;
 162       //CPPUNIT_MESSAGE( str.str().c_str() );
 163
 164       str >> in_val_d;
 165
 166       CPPUNIT_ASSERT(!str.fail());
 167       CPPUNIT_ASSERT(str.eof());
 168       CPPUNIT_CHECK( in_val_d == in_val_d );
 169       CPPUNIT_CHECK( in_val_d != limits::infinity() );
 170     }
 171     {
 172       stringstream str;
 173
 174       str << fixed << limits::max();
 175
 176       CPPUNIT_ASSERT(!str.fail());
 177       CPPUNIT_CHECK( str.str() != "inf" && str.str() != "Inf" );
 178       CPPUNIT_CHECK( str.str() != "-inf" && str.str() != "-Inf" );
 179       CPPUNIT_CHECK( str.str() != "nan" && str.str() != "NaN" );
 180       CPPUNIT_CHECK( str.str() != "-nan" && str.str() != "-NaN" );
 181       //CPPUNIT_MESSAGE( str.str().c_str() );
 182
 183       //str.str("");
 184       //str << limits::max_exponent10;
 185       //CPPUNIT_MESSAGE( str.str().c_str() );
 186
 187       str >> in_val_d;
 188
 189       CPPUNIT_ASSERT(!str.fail());
 190       CPPUNIT_ASSERT(str.eof());
 191       CPPUNIT_CHECK( in_val_d == in_val_d );
 192       CPPUNIT_CHECK( in_val_d != limits::infinity() );
 193     }
 194     {
 195       stringstream str;
 196
 197       str << scientific << setprecision(50) << limits::max();
 198
 199       CPPUNIT_ASSERT(!str.fail());
 200       CPPUNIT_CHECK( str.str() != "inf" && str.str() != "Inf" );
 201       CPPUNIT_CHECK( str.str() != "-inf" && str.str() != "-Inf" );
 202       CPPUNIT_CHECK( str.str() != "nan" && str.str() != "NaN" );
 203       CPPUNIT_CHECK( str.str() != "-nan" && str.str() != "-NaN" );
 204       //CPPUNIT_MESSAGE( str.str().c_str() );
 205
 206       //str.str("");
 207       //str << limits::max_exponent10;
 208       //CPPUNIT_MESSAGE( str.str().c_str() );
 209
 210       str >> in_val_d;
 211
 212       CPPUNIT_ASSERT(!str.fail());
 213       CPPUNIT_ASSERT(str.eof());
 214       CPPUNIT_CHECK( in_val_d == in_val_d );
 215       CPPUNIT_CHECK( in_val_d != limits::infinity() );
 216     }
 217 #endif
 218     {
 219       stringstream str;
 220
 221       str << limits::infinity();
 222
 223       CPPUNIT_ASSERT( !str.fail() );
 224       CPPUNIT_ASSERT( !limits::has_infinity || str.str() == "inf" || str.str() == "Inf" );
 225     }
 226     {
 227       stringstream str;
 228
 229       str << -limits::infinity();
 230
 231       CPPUNIT_ASSERT( !str.fail() );
 232       CPPUNIT_ASSERT( !limits::has_infinity || str.str() == "-inf" || str.str() == "-Inf" );
 233     }
 234     {
 235       stringstream str;
 236
 237       str << limits::quiet_NaN();
 238
 239       CPPUNIT_ASSERT( !str.fail() );
 240       CPPUNIT_ASSERT( !limits::has_quiet_NaN || str.str() == "nan" || str.str() == "NaN" );
 241     }
 242     {
 243       stringstream str;
 244
 245       str << "0." << string(limits::max_exponent10, '0') << "1e" << (limits::max_exponent10 + 1);
 246       CPPUNIT_ASSERT( !str.fail() );
 247
 248       str >> in_val_d;
 249       CPPUNIT_ASSERT( !str.fail() );
 250       CPPUNIT_ASSERT( str.eof() );
 251       CPPUNIT_CHECK( in_val_d == 1 );
 252     }
 253     {
 254       stringstream str;
 255
 256       str << "1" << string(-(limits::min_exponent10 - 1), '0') << "e" << (limits::min_exponent10 - 1);
 257       CPPUNIT_ASSERT( !str.fail() );
 258
 259       str >> in_val_d;
 260       CPPUNIT_ASSERT( !str.fail() );
 261       CPPUNIT_ASSERT( str.eof() );
 262       CPPUNIT_CHECK( in_val_d == 1 );
 263     }
 264 #  if defined (_STLPORT_VERSION) && (_STLPORT_VERSION >= 0x530)
 265     // The following tests are showing that simply changing stream
 266     // precision lead to different result. Do not seems to be a real
 267     // problem, simply rounding approximation but additional study should
 268     // be done after 5.2 release.
 269     {
 270       stringstream str;
 271       str << setprecision(limits::digits10 + 2) << limits::max();
 272
 273       CPPUNIT_MESSAGE(str.str().c_str());
 274       CPPUNIT_ASSERT( !str.fail() );
 275
 276       F val;
 277       str >> val;
 278
 279       CPPUNIT_ASSERT( !str.fail() );
 280       CPPUNIT_ASSERT( limits::infinity() > val );
 281     }
 282     {
 283       stringstream str;
 284       str << setprecision(limits::digits10 + 1) << limits::max();
 285
 286       CPPUNIT_MESSAGE(str.str().c_str());
 287       CPPUNIT_ASSERT( !str.fail() );
 288
 289       F val;
 290       str >> val;
 291
 292       CPPUNIT_ASSERT( !str.fail() );
 293       CPPUNIT_ASSERT( limits::infinity() > val );
 294     }
 295 #  endif
 296   }
 297 #else
 298 #  define __check_get_float( F ) \
 299   void check_get_float( F v ) \
 300   { \
 301     F in_val_d = v; \
 302     { \
 303       stringstream str; \
 304  \
 305       str << "1E+" << numeric_limits<F>::max_exponent10; \
 306  \
 307       str >> in_val_d; \
 308       CPPUNIT_ASSERT(!str.fail()); \
 309       CPPUNIT_ASSERT(str.eof()); \
 310       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 311       CPPUNIT_CHECK( in_val_d != numeric_limits<F>::infinity() ); \
 312     } \
 313     { \
 314       stringstream str; \
 315  \
 316       str << "-1E+" << numeric_limits<F>::max_exponent10; \
 317  \
 318       str >> in_val_d; \
 319       CPPUNIT_ASSERT(!str.fail()); \
 320       CPPUNIT_ASSERT(str.eof()); \
 321       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 322       CPPUNIT_CHECK( in_val_d != -numeric_limits<F>::infinity() ); \
 323     } \
 324     { \
 325       stringstream str; \
 326  \
 327       str << "1E" << numeric_limits<F>::min_exponent10; \
 328  \
 329       str >> in_val_d; \
 330       CPPUNIT_ASSERT(!str.fail()); \
 331       CPPUNIT_ASSERT(str.eof()); \
 332       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 333       CPPUNIT_CHECK( in_val_d != F(0.0) ); \
 334     } \
 335     { \
 336       stringstream str; \
 337  \
 338       str << "1E+" << (numeric_limits<F>::max_exponent10 + 1); \
 339  \
 340       str >> in_val_d; \
 341       CPPUNIT_ASSERT(!str.fail()); \
 342       CPPUNIT_ASSERT(str.eof()); \
 343       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 344       CPPUNIT_CHECK( in_val_d == numeric_limits<F>::infinity() ); \
 345     } \
 346     { \
 347       stringstream str; \
 348  \
 349       str << "-1E+" << (numeric_limits<F>::max_exponent10 + 1); \
 350  \
 351       str >> in_val_d; \
 352       CPPUNIT_ASSERT(!str.fail()); \
 353       CPPUNIT_ASSERT(str.eof()); \
 354       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 355       CPPUNIT_CHECK( in_val_d == -numeric_limits<F>::infinity() ); \
 356     } \
 357     { \
 358       stringstream str; \
 359  \
 360       str << "1E" << (numeric_limits<F>::min_exponent10 - 1); \
 361  \
 362       str >> in_val_d; \
 363       CPPUNIT_ASSERT(!str.fail()); \
 364       CPPUNIT_ASSERT(str.eof()); \
 365       CPPUNIT_CHECK( in_val_d == in_val_d ); \
 366       CPPUNIT_CHECK( in_val_d >= F(0.0) && in_val_d <= numeric_limits<F>::min() ); \
 367     } \
 368   }
 369
 370   __check_get_float( float )
 371   __check_get_float( double )
 372 #  if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
 373   __check_get_float( long double )
 374 #  endif
 375 #  undef __check_get_float
 376 #endif // _STLP_NO_MEMBER_TEMPLATES
 377 };
 378
 379 CPPUNIT_TEST_SUITE_REGISTRATION(NumPutGetTest);
 380
 381 #if defined (_MSC_VER)
 382 #  pragma warning (disable : 4056)
 383 #  pragma warning (disable : 4756)
 384 #endif
 385
 386 //
 387 // tests implementation
 388 //
 389 void NumPutGetTest::num_put_float()
 390 {
 391   {
 392     string output, digits;
 393
 394     {
 395       ostringstream ostr;
 396       ostr << 1.23457e+17f;
 397       CPPUNIT_ASSERT(ostr.good());
 398       output = reset_stream(ostr);
 399       digits = "17";
 400       complete_digits(digits);
 401       CPPUNIT_CHECK(output == string("1.23457e+") + digits );
 402     }
 403
 404     {
 405       ostringstream ostr;
 406       ostr << setprecision(200) << 1.23457e+17f;
 407       CPPUNIT_ASSERT(ostr.good());
 408       output = reset_stream(ostr);
 409       CPPUNIT_CHECK( output.size() < 200 );
 410     }
 411
 412     {
 413       ostringstream ostr;
 414       ostr << setprecision(200) << numeric_limits<float>::min();
 415       CPPUNIT_ASSERT(ostr.good());
 416       output = reset_stream(ostr);
 417       CPPUNIT_CHECK( output.size() < 200 );
 418     }
 419
 420     {
 421       ostringstream ostr;
 422       ostr << fixed << 1.23457e+17f;
 423       CPPUNIT_ASSERT(ostr.good());
 424       output = reset_stream(ostr);
 425       CPPUNIT_CHECK(output.size() == 25);
 426       CPPUNIT_CHECK(output.substr(0, 5) == "12345");
 427       CPPUNIT_CHECK(output.substr(18) == ".000000");
 428     }
 429
 430     {
 431       ostringstream ostr;
 432       ostr << fixed << showpos << 1.23457e+17f;
 433       CPPUNIT_ASSERT(ostr.good());
 434       output = reset_stream(ostr);
 435       CPPUNIT_CHECK(output.size() == 26);
 436       CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
 437       CPPUNIT_CHECK(output.substr(19) == ".000000");
 438     }
 439
 440     {
 441       ostringstream ostr;
 442       ostr << fixed << showpos << setprecision(100) << 1.23457e+17f;
 443       CPPUNIT_ASSERT(ostr.good());
 444       output = reset_stream(ostr);
 445       CPPUNIT_CHECK(output.size() == 120);
 446       CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
 447       CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
 448     }
 449
 450     {
 451       ostringstream ostr;
 452       ostr << scientific << setprecision(8) <<  0.12345678; // float doesn't have enough precision, 0.12345678f ended up 0.1234567836..
 453       CPPUNIT_ASSERT(ostr.good());
 454       output = reset_stream(ostr);
 455       digits = "1";
 456       complete_digits(digits);
 457       CPPUNIT_CHECK(output == string("1.23456780e-") + digits );
 458     }
 459
 460     {
 461       ostringstream ostr;
 462       ostr << fixed << setprecision(8) << setw(30) << setfill('0') << 0.12345678f;
 463       CPPUNIT_ASSERT(ostr.good());
 464       output = reset_stream(ostr);
 465       CPPUNIT_CHECK(output == "000000000000000000000.12345678");
 466     }
 467
 468     {
 469       ostringstream ostr;
 470       ostr << fixed << showpos << setprecision(8) << setw(30) << setfill('0') << 0.12345678f;
 471       CPPUNIT_ASSERT(ostr.good());
 472       output = reset_stream(ostr);
 473       CPPUNIT_CHECK(output == "0000000000000000000+0.12345678");
 474     }
 475
 476     {
 477       ostringstream ostr;
 478       ostr << fixed << showpos << setprecision(8) << setw(30) << left << setfill('0') << 0.12345678f;
 479       CPPUNIT_ASSERT(ostr.good());
 480       output = reset_stream(ostr);
 481       CPPUNIT_CHECK(output == "+0.123456780000000000000000000");
 482     }
 483
 484     {
 485       ostringstream ostr;
 486       ostr << fixed << showpos << setprecision(8) << setw(30) << internal << setfill('0') << 0.12345678f;
 487       CPPUNIT_ASSERT(ostr.good());
 488       output = reset_stream(ostr);
 489       CPPUNIT_CHECK(output == "+00000000000000000000.12345678");
 490     }
 491
 492     {
 493       ostringstream ostr;
 494       ostr << fixed << showpos << setprecision(100) << 1.234567e+17;
 495       CPPUNIT_ASSERT(ostr.good());
 496       output = reset_stream(ostr);
 497       CPPUNIT_CHECK(output.size() == 120);
 498       CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
 499       CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
 500     }
 501
 502 #if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
 503     {
 504       ostringstream ostr;
 505       ostr << fixed << showpos << setprecision(100) << 1.234567e+17l;
 506       CPPUNIT_ASSERT(ostr.good());
 507       output = reset_stream(ostr);
 508       CPPUNIT_CHECK(output.size() == 120);
 509       CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
 510       CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
 511     }
 512 #endif
 513
 514     {
 515       ostringstream ostr;
 516       ostr << scientific << setprecision(50) << 0.0;
 517       CPPUNIT_ASSERT(ostr.good());
 518       output = reset_stream(ostr);
 519       CPPUNIT_CHECK( output == "0.00000000000000000000000000000000000000000000000000e+00" );
 520     }
 521     {
 522       ostringstream ostr;
 523       ostr << fixed << setprecision(100) << numeric_limits<float>::max();
 524       CPPUNIT_ASSERT(ostr.good());
 525       output = reset_stream(ostr);
 526       //CPPUNIT_MESSAGE( output.c_str() );
 527     }
 528
 529     {
 530       ostringstream ostr;
 531       ostr << setprecision(100) << numeric_limits<double>::max();
 532       CPPUNIT_ASSERT(ostr.good());
 533       output = reset_stream(ostr);
 534       //CPPUNIT_MESSAGE( output.c_str() );
 535     }
 536
 537 #if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
 538     {
 539       ostringstream ostr;
 540       ostr << setprecision(100) << numeric_limits<long double>::max();
 541       CPPUNIT_ASSERT(ostr.good());
 542       output = reset_stream(ostr);
 543       //CPPUNIT_MESSAGE( output.c_str() );
 544     }
 545 #endif
 546
 547     //{
 548     //  ostringstream ostr;
 549     //  ostr << setprecision(-numeric_limits<float>::min_exponent10 + numeric_limits<float>::digits10 + 9) << numeric_limits<float>::min();
 550     //  CPPUNIT_ASSERT(ostr.good());
 551     //  output = reset_stream(ostr);
 552     //  //CPPUNIT_MESSAGE( output.c_str() );
 553     //}
 554
 555     //{
 556     //  ostringstream ostr;
 557     //  ostr << setprecision(-numeric_limits<double>::min_exponent10 + numeric_limits<double>::digits10) << numeric_limits<double>::min();
 558     //  CPPUNIT_ASSERT(ostr.good());
 559     //  output = reset_stream(ostr);
 560     //  //CPPUNIT_MESSAGE( output.c_str() );
 561     //}
 562
 563 //#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
 564 //    {
 565 //      ostringstream ostr;
 566 //      ostr << setprecision(-numeric_limits<long double>::min_exponent10 + numeric_limits<long double>::digits10) << numeric_limits<long double>::min();
 567 //      CPPUNIT_ASSERT(ostr.good());
 568 //      output = reset_stream(ostr);
 569 //      CPPUNIT_MESSAGE( output.c_str() );
 570 //    }
 571 //#endif
 572   }
 573
 574   {
 575     ostringstream str;
 576
 577     str.setf(ios::fixed, ios::floatfield);
 578     str << 1.0e+5;
 579     // cerr << str.str() << endl;
 580     CPPUNIT_CHECK( str.str() == "100000.000000" );
 581
 582     reset_stream(str);
 583     str.precision(0);
 584     str << 1.0e+5;
 585     CPPUNIT_CHECK( str.str() == "100000" );
 586
 587     reset_stream(str);
 588     str.precision(4);
 589     str << 1.0e+5;
 590     CPPUNIT_CHECK( str.str() == "100000.0000" );
 591
 592     reset_stream(str);
 593     str.precision(0);
 594     str << 1.0e+83;
 595     CPPUNIT_CHECK( str.str().size() == 84 );
 596     //printf("\nC result: %.0f\n", 1.0e+83);
 597     //CPPUNIT_MESSAGE( str.str().c_str() );
 598     //CPPUNIT_CHECK( str.str() == "100000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
 599
 600     // cerr.setf(ios::fixed, ios::floatfield);
 601     // cerr << DBL_MAX << endl;
 602     // cerr << 1.0e+37 << endl;
 603   }
 604 }
 605
 606 #define CHECK_COMPLETE(type, val, base, showbase, showpos, casing, width, adjust, expected) \
 607 { \
 608   type tmp = val; \
 609   ostringstream ostr; \
 610   ostr << base << showbase << showpos << casing << setw(width) << adjust << tmp; \
 611   CPPUNIT_CHECK( ostr.str() == expected ); \
 612 }
 613
 614 #define CHECK(type, val, base, expected) \
 615   CHECK_COMPLETE(type, val, base, noshowbase, noshowpos, nouppercase, 0, right, expected)
 616
 617 void NumPutGetTest::num_put_integer()
 618 {
 619   //octal outputs
 620   {
 621     CHECK(short, 0, oct, "0")
 622     CHECK(short, 1, oct, "1")
 623     CHECK(short, 12345, oct, "30071")
 624     if (sizeof(short) == 2) {
 625       CHECK(short, -1, oct, "177777")
 626       CHECK(short, -12345, oct, "147707")
 627     }
 628
 629     CHECK(unsigned short, 0, oct, "0")
 630     CHECK(unsigned short, 12345, oct, "30071")
 631
 632     CHECK(int, 0, oct, "0")
 633     CHECK(int, 12345678, oct, "57060516")
 634     if (sizeof(int) == 4) {
 635       CHECK(int, -1, oct, "37777777777")
 636       CHECK(int, -12345678, oct, "37720717262")
 637     }
 638
 639     CHECK(unsigned int, 0, oct, "0")
 640     CHECK(unsigned int, 12345678, oct, "57060516")
 641
 642     CHECK(long, 0, oct, "0")
 643     CHECK(long, 12345678, oct, "57060516")
 644     if (sizeof(long) == 4) {
 645       CHECK(long, -1, oct, "37777777777")
 646       CHECK(long, -12345678, oct, "37720717262")
 647     }
 648
 649     CHECK(unsigned long, 0, oct, "0")
 650     CHECK(unsigned long, 12345678, oct, "57060516")
 651
 652 #if defined (STLPORT) && defined (_STLP_LONG_LONG)
 653     CHECK(_STLP_LONG_LONG, 0, oct, "0")
 654     CHECK(_STLP_LONG_LONG, 12345678, oct, "57060516")
 655     if (sizeof(_STLP_LONG_LONG) == 8) {
 656       CHECK(_STLP_LONG_LONG, -1, oct, "1777777777777777777777")
 657       CHECK(_STLP_LONG_LONG, -12345678, oct, "1777777777777720717262")
 658     }
 659
 660     CHECK(unsigned _STLP_LONG_LONG, 0, oct, "0")
 661     CHECK(unsigned _STLP_LONG_LONG, 12345678, oct, "57060516")
 662 #endif
 663
 664     //Even with showbase, 0 value gives "0" (see printf documentation)
 665     CHECK_COMPLETE(short, 0, oct, showbase, noshowpos, nouppercase, 0, right, "0")
 666     CHECK_COMPLETE(short, 0, oct, showbase, showpos, nouppercase, 6, right, "     0")
 667
 668     CHECK_COMPLETE(short, 1, oct, showbase, noshowpos, nouppercase, 6, right, "    01")
 669     CHECK_COMPLETE(short, 1, oct, showbase, noshowpos, nouppercase, 6, left, "01    ")
 670     CHECK_COMPLETE(short, 1, oct, showbase, showpos, nouppercase, 6, internal, "    01")
 671   }
 672
 673   //decimal outputs
 674   {
 675     CHECK(short, 0, dec, "0")
 676     CHECK(short, -1, dec, "-1")
 677     CHECK(short, 12345, dec, "12345")
 678     CHECK(short, -12345, dec, "-12345")
 679
 680     CHECK(unsigned short, 0, dec, "0")
 681     CHECK(unsigned short, 12345, dec, "12345")
 682
 683     CHECK(int, 0, dec, "0")
 684     CHECK(int, -1, dec, "-1")
 685     CHECK(int, 12345678, dec, "12345678")
 686     CHECK(int, -12345678, dec, "-12345678")
 687
 688     CHECK(unsigned int, 0, dec, "0")
 689     CHECK(unsigned int, 12345678, dec, "12345678")
 690
 691     CHECK(long, 0, dec, "0")
 692     CHECK(long, -1, dec, "-1")
 693     CHECK(long, 12345678, dec, "12345678")
 694     CHECK(long, -12345678, dec, "-12345678")
 695
 696     CHECK(unsigned long, 0, dec, "0")
 697     CHECK(unsigned long, 12345678, dec, "12345678")
 698 #if defined (STLPORT) && defined (_STLP_LONG_LONG)
 699     CHECK(_STLP_LONG_LONG, 0, dec, "0")
 700     CHECK(_STLP_LONG_LONG, -1, dec, "-1")
 701     CHECK(_STLP_LONG_LONG, 12345678, dec, "12345678")
 702     CHECK(_STLP_LONG_LONG, -12345678, dec, "-12345678")
 703
 704     CHECK(unsigned _STLP_LONG_LONG, 0, dec, "0")
 705     CHECK(unsigned _STLP_LONG_LONG, 12345678, dec, "12345678")
 706 #endif
 707
 708     CHECK_COMPLETE(short, 0, dec, showbase, showpos, nouppercase, 0, right, "+0")
 709     CHECK_COMPLETE(short, 0, dec, showbase, showpos, nouppercase, 6, right, "    +0")
 710     CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, right, "    +1")
 711     CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, left, "+1    ")
 712     CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, internal, "+    1")
 713   }
 714
 715   //hexadecimal outputs
 716   {
 717     CHECK(short, 0, hex, "0")
 718     CHECK(short, 12345, hex, "3039")
 719     if (sizeof(short) == 2) {
 720       CHECK(short, -1, hex, "ffff")
 721       CHECK(short, -12345, hex, "cfc7")
 722     }
 723
 724     CHECK(unsigned short, 0, hex, "0")
 725     CHECK(unsigned short, 12345, hex, "3039")
 726
 727     CHECK(int, 0, hex, "0")
 728     CHECK(int, 12345678, hex, "bc614e")
 729     if (sizeof(int) == 4) {
 730       CHECK(int, -1, hex, "ffffffff")
 731       CHECK(int, -12345678, hex, "ff439eb2")
 732     }
 733
 734     CHECK(unsigned int, 0, hex, "0")
 735     CHECK(unsigned int, 12345678, hex, "bc614e")
 736
 737     CHECK(long, 0, hex, "0")
 738     CHECK(long, 12345678, hex, "bc614e")
 739     if (sizeof(long) == 4) {
 740       CHECK(long, -1, hex, "ffffffff")
 741       CHECK(long, -12345678, hex, "ff439eb2")
 742     }
 743
 744     CHECK(unsigned long, 0, hex, "0")
 745     CHECK(unsigned long, 12345678, hex, "bc614e")
 746 #if defined (STLPORT) && defined (_STLP_LONG_LONG)
 747     CHECK(_STLP_LONG_LONG, 0, hex, "0")
 748     CHECK(_STLP_LONG_LONG, 12345678, hex, "bc614e")
 749     if (sizeof(_STLP_LONG_LONG) == 8) {
 750       CHECK(_STLP_LONG_LONG, -1, hex, "ffffffffffffffff")
 751       CHECK(_STLP_LONG_LONG, -12345678, hex, "ffffffffff439eb2")
 752     }
 753
 754     CHECK(unsigned _STLP_LONG_LONG, 0, hex, "0")
 755     CHECK(unsigned _STLP_LONG_LONG, 12345678, hex, "bc614e")
 756 #endif
 757
 758     //Even with showbase, 0 value gives "0" output (see printf documentation)
 759     CHECK_COMPLETE(short, 0, hex, showbase, showpos, nouppercase, 0, right, "0")
 760     CHECK_COMPLETE(short, 0, hex, showbase, noshowpos, nouppercase, 6, right, "     0")
 761     CHECK_COMPLETE(short, 0, hex, showbase, noshowpos, nouppercase, 6, internal, "     0")
 762
 763     CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, right, "   0x1")
 764     CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, left, "0x1   ")
 765     CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, internal, "0x   1")
 766     CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, uppercase, 6, left, "0X1   ")
 767     CHECK_COMPLETE(short, 1, hex, showbase, showpos, uppercase, 6, internal, "0X   1")
 768   }
 769 }
 770
 771 void NumPutGetTest::num_get_float()
 772 {
 773   float in_val;
 774
 775   istringstream istr;
 776
 777   istr.str("1.2345");
 778   istr >> in_val;
 779   CPPUNIT_ASSERT(!istr.fail());
 780   CPPUNIT_ASSERT(istr.eof());
 781   CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
 782   istr.clear();
 783
 784   istr.str("-1.2345");
 785   istr >> in_val;
 786   CPPUNIT_ASSERT(!istr.fail());
 787   CPPUNIT_ASSERT(istr.eof());
 788   CPPUNIT_ASSERT(check_float(in_val, -1.2345f));
 789   istr.clear();
 790
 791   istr.str("+1.2345");
 792   istr >> in_val;
 793   CPPUNIT_ASSERT(!istr.fail());
 794   CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
 795   istr.clear();
 796
 797   istr.str("000000000000001.234500000000");
 798   istr >> in_val;
 799   CPPUNIT_ASSERT(!istr.fail());
 800   CPPUNIT_ASSERT(istr.eof());
 801   CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
 802   istr.clear();
 803
 804   istr.str("1.2345e+04");
 805   istr >> in_val;
 806   CPPUNIT_ASSERT(!istr.fail());
 807   CPPUNIT_ASSERT(istr.eof());
 808   CPPUNIT_ASSERT(check_float(in_val, 12345.0f));
 809   istr.clear();
 810
 811   CPPUNIT_MESSAGE( "float" );
 812   check_get_float( 0.0F );
 813   CPPUNIT_MESSAGE( "double" );
 814   check_get_float( 0.0 );
 815 #if (!defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)) && !defined(__ANDROID__)
 816   CPPUNIT_MESSAGE( "long double" );
 817   check_get_float( 0.0L );
 818 #endif
 819   {
 820     stringstream str;
 821
 822     str << "1e" << numeric_limits<double>::max_exponent10;
 823     CPPUNIT_ASSERT(!str.fail());
 824
 825     float val;
 826     str >> val;
 827     CPPUNIT_ASSERT(!str.fail());
 828     CPPUNIT_ASSERT(str.eof());
 829     CPPUNIT_ASSERT( numeric_limits<double>::max_exponent10 <= numeric_limits<float>::max_exponent10 ||
 830                     val == numeric_limits<float>::infinity() );
 831   }
 832   {
 833     stringstream str;
 834
 835     str << "1e" << numeric_limits<double>::min_exponent10;
 836     CPPUNIT_ASSERT(!str.fail());
 837
 838     float val;
 839     str >> val;
 840     CPPUNIT_ASSERT(!str.fail());
 841     CPPUNIT_ASSERT(str.eof());
 842     CPPUNIT_ASSERT( numeric_limits<double>::min_exponent10 >= numeric_limits<float>::min_exponent10 ||
 843                     val == 0.0f );
 844   }
 845 #if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
 846   {
 847     stringstream str;
 848
 849     str << "1e" << numeric_limits<long double>::max_exponent10;
 850     CPPUNIT_ASSERT(!str.fail());
 851
 852     double val;
 853     str >> val;
 854     CPPUNIT_ASSERT(!str.fail());
 855     CPPUNIT_ASSERT(str.eof());
 856     CPPUNIT_ASSERT( numeric_limits<long double>::max_exponent10 <= numeric_limits<double>::max_exponent10 ||
 857                     val == numeric_limits<double>::infinity() );
 858   }
 859   {
 860     stringstream str;
 861
 862     str << "1e" << numeric_limits<long double>::min_exponent10;
 863     CPPUNIT_ASSERT(!str.fail());
 864
 865     double val;
 866     str >> val;
 867     CPPUNIT_ASSERT(!str.fail());
 868     CPPUNIT_ASSERT(str.eof());
 869     CPPUNIT_ASSERT( numeric_limits<long double>::min_exponent10 >= numeric_limits<double>::min_exponent10 ||
 870                     val == 0.0 );
 871   }
 872 #if !defined(__ANDROID__) // "long double" in Android is still a distinct type but size is the same as "double"
 873   {
 874     const char* p = "2.718281828459045235360287471352662497757247093e0";
 875     std::stringstream s;
 876     s << p;
 877     long double x;
 878     s >> x;
 879     CPPUNIT_ASSERT( x > 2.70l && x < 2.72l );
 880   }
 881 #endif
 882 #endif
 883 }
 884
 885 void NumPutGetTest::num_get_integer()
 886 {
 887   //octal input
 888   {
 889     istringstream istr;
 890     istr.str("30071");
 891     short val;
 892     istr >> oct >> val;
 893     CPPUNIT_ASSERT( !istr.fail() );
 894     CPPUNIT_ASSERT( istr.eof() );
 895     CPPUNIT_ASSERT( val == 12345 );
 896     istr.clear();
 897
 898     if (sizeof(short) == 2) {
 899       istr.str("177777");
 900       istr >> oct >> val;
 901       CPPUNIT_ASSERT( !istr.fail() );
 902       CPPUNIT_ASSERT( istr.eof() );
 903       CPPUNIT_ASSERT( val == -1 );
 904       istr.clear();
 905     }
 906   }
 907
 908   //decimal input
 909   {
 910     istringstream istr;
 911     istr.str("10000");
 912     short val = -1;
 913     istr >> val;
 914     CPPUNIT_ASSERT( !istr.fail() );
 915     CPPUNIT_ASSERT( istr.eof() );
 916     CPPUNIT_ASSERT( val == 10000 );
 917     istr.clear();
 918
 919     istr.str("+10000");
 920     val = -1;
 921     istr >> val;
 922     CPPUNIT_ASSERT( !istr.fail() );
 923     CPPUNIT_ASSERT( istr.eof() );
 924     CPPUNIT_ASSERT( val == 10000 );
 925     istr.clear();
 926
 927     if (sizeof(short) == 2) {
 928       val = -1;
 929       istr.str("10000000");
 930       istr >> val;
 931       CPPUNIT_ASSERT( istr.fail() );
 932       CPPUNIT_ASSERT( istr.eof() );
 933       CPPUNIT_ASSERT( val == -1 );
 934       istr.clear();
 935     }
 936
 937     val = -1;
 938     istr.str("0x0");
 939     istr >> val;
 940     CPPUNIT_ASSERT( !istr.fail() );
 941     CPPUNIT_ASSERT( !istr.eof() );
 942     CPPUNIT_ASSERT( val == 0 );
 943     istr.clear();
 944
 945     val = -1;
 946     istr.str("000001");
 947     istr >> val;
 948     CPPUNIT_ASSERT( !istr.fail() );
 949     CPPUNIT_ASSERT( istr.eof() );
 950     CPPUNIT_ASSERT( val == 1 );
 951     istr.clear();
 952   }
 953
 954   //hexadecimal input
 955   {
 956     istringstream istr;
 957     istr.str("3039");
 958     short val = -1;
 959     istr >> hex >> val;
 960     CPPUNIT_ASSERT( !istr.fail() );
 961     CPPUNIT_ASSERT( istr.eof() );
 962     CPPUNIT_ASSERT( val == 12345 );
 963     istr.clear();
 964
 965     istr.str("x3039");
 966     val = -1;
 967     istr >> hex >> val;
 968     CPPUNIT_ASSERT( istr.fail() );
 969     CPPUNIT_ASSERT( !istr.eof() );
 970     CPPUNIT_ASSERT( val == -1 );
 971     istr.clear();
 972
 973     istr.str("03039");
 974     val = -1;
 975     istr >> hex >> val;
 976     CPPUNIT_ASSERT( !istr.fail() );
 977     CPPUNIT_ASSERT( istr.eof() );
 978     CPPUNIT_ASSERT( val == 12345 );
 979     istr.clear();
 980
 981     istr.str("0x3039");
 982     istr >> hex >> val;
 983     CPPUNIT_ASSERT( !istr.fail() );
 984     CPPUNIT_ASSERT( istr.eof() );
 985     CPPUNIT_ASSERT( val == 12345 );
 986     istr.clear();
 987
 988     if (sizeof(short) == 2) {
 989       val = -1;
 990       istr.str("cfc7");
 991       istr >> hex >> val;
 992       CPPUNIT_ASSERT( !istr.fail() );
 993       CPPUNIT_ASSERT( istr.eof() );
 994       CPPUNIT_ASSERT( val == -12345 );
 995       istr.clear();
 996     }
 997   }
 998 }
 999
1000 void NumPutGetTest::inhex()
1001 {
1002   {
1003     ostringstream s;
1004     s << hex << 0;
1005     CPPUNIT_CHECK( s.str() == "0" );
1006   }
1007   {
1008     ostringstream s;
1009     s << hex << 0xff;
1010     CPPUNIT_CHECK( s.str() == "ff" );
1011   }
1012   {
1013     ostringstream s;
1014     s << hex << setw( 4 ) << 0xff;
1015     CPPUNIT_CHECK( s.str() == "  ff" );
1016   }
1017   {
1018     ostringstream s;
1019     s << hex << setw( 4 ) << 0;
1020     CPPUNIT_CHECK( s.str() == "   0" );
1021   }
1022   {
1023     ostringstream s;
1024     s << hex << showbase << 0;
1025     CPPUNIT_CHECK( s.str() == "0" );
1026   }
1027   {
1028     ostringstream s;
1029     s << hex << showbase << 0xff;
1030     CPPUNIT_CHECK( s.str() == "0xff" );
1031   }
1032   {
1033     ostringstream s;
1034     s << hex << showbase << setw( 4 ) << 0xff;
1035     CPPUNIT_CHECK( s.str() == "0xff" );
1036   }
1037   { // special case for regression (partially duplicate CHECK_COMPLETE above):
1038     ostringstream s;
1039     s.setf( ios_base::internal, ios_base::adjustfield );
1040     s << hex << showbase << setw(8+2) << 0;
1041     CPPUNIT_CHECK( s.str() == "         0" );
1042   }
1043 }
1044
1045 void NumPutGetTest::pointer()
1046 {
1047   // Problem with printing pointer to null
1048
1049   /*
1050    * Really C's formatting not help here, due to:
1051    *
1052    * p  The argument shall be a pointer to void. The value of
1053    *    the pointer is converted to a sequence of printable characters,
1054    *    in an implementation-defined manner.
1055    */
1056   {
1057     /*
1058     char buf[128];
1059     void *p = (void *)0xff00;
1060     sprintf( buf, "%p", p );
1061     // cerr << buf << endl;
1062     // Hmmm, I see 0xff00 on box with 32-bits address; pointer like 'unsigned hex'?
1063     if ( sizeof( p ) == 2 ) {
1064       CPPUNIT_ASSERT( strcmp( buf, "0xff00" ) == 0 );
1065     } else if ( sizeof( p ) == 4 ) {
1066       CPPUNIT_ASSERT( strcmp( buf, "0x0000ff00" ) == 0 );
1067     } else if ( sizeof( p ) == 8 ) {
1068       CPPUNIT_ASSERT( strcmp( buf, "0x000000000000ff00" ) == 0 );
1069     } else {
1070       CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
1071     }
1072     */
1073   }
1074   {
1075     /*
1076     char buf[128];
1077     void *p = 0;
1078     */
1079     // sprintf( buf, "%p", p );
1080     /* Cool. "%p" print '(nil)'; "%#x" print '0' */
1081     // sprintf( buf, "%#x", (unsigned)p );
1082     // cerr << buf << endl;
1083   }
1084   {
1085     ostringstream s;
1086     void *p = (void *)0xff00;
1087     s << p;
1088     CPPUNIT_ASSERT( s.good() );
1089     if ( sizeof( p ) == 2 ) {
1090       CPPUNIT_ASSERT( s.str() == "0xff00" );
1091     } else if ( sizeof( p ) == 4 ) {
1092       CPPUNIT_ASSERT( s.str() == "0x0000ff00" ); // this pass
1093     } else if ( sizeof( p ) == 8 ) {
1094       CPPUNIT_ASSERT( s.str() == "0x000000000000ff00" );
1095     } else {
1096       CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
1097     }
1098   }
1099   {
1100     ostringstream s;
1101     void *p = 0;
1102     s << p;
1103     CPPUNIT_ASSERT( s.good() );
1104     if ( sizeof( p ) == 2 ) {
1105       CPPUNIT_ASSERT( s.str() == "0x0000" );
1106     } else if ( sizeof( p ) == 4 ) {
1107       CPPUNIT_ASSERT( s.str() == "0x00000000" ); // but this will fail, if follow %p
1108     } else if ( sizeof( p ) == 8 ) {
1109       CPPUNIT_ASSERT( s.str() == "0x0000000000000000" );
1110     } else {
1111       CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
1112     }
1113   }
1114 }
1115
1116 void NumPutGetTest::fix_float_long()
1117 {
1118   ostringstream str;
1119
1120   str.setf(ios::fixed, ios::floatfield);
1121   str << 1.0e+5;
1122   CPPUNIT_CHECK( str.str() == "100000.000000" );
1123
1124   reset_stream(str);
1125   str.precision(0);
1126   str << 1.0e+5;
1127   CPPUNIT_CHECK( str.str() == "100000" );
1128
1129   reset_stream(str);
1130   str.precision(4);
1131   str << 1.0e+5;
1132   CPPUNIT_CHECK( str.str() == "100000.0000" );
1133
1134   reset_stream(str);
1135   str.precision(0);
1136   str << 1.0e+83;
1137   {
1138     istringstream istr( str.str() );
1139     double f;
1140     istr >> f;
1141     CPPUNIT_CHECK( !istr.fail() );
1142     if ( int(numeric_limits<double>::digits10) < 83 ) {
1143       double delta = 1.0;
1144       for ( int ee = 83 - int(numeric_limits<double>::digits10); ee > 0; --ee ) {
1145         delta *= 10.0;
1146       }
1147       // we may loss some digits here, but not more than mantissa:
1148       CPPUNIT_CHECK( (f > (1.0e+83 - delta)) && (f < (1.0e+83 + delta)) );
1149     } else {
1150       CPPUNIT_CHECK( check_double(f, 1.0e+83) );
1151     }
1152   }
1153
1154 #if 0 // #ifndef _STLP_NO_LONG_DOUBLE
1155   reset_stream(str);
1156   str.precision(0);
1157   str << 1.0e+83l;
1158   {
1159     istringstream istr( str.str() );
1160     long double f;
1161     istr >> f;
1162     CPPUNIT_CHECK( !istr.fail() );
1163     if ( int(numeric_limits<long double>::digits10) < 83 ) {
1164       long double delta = 1.0l;
1165       for ( int ee = 83 - int(numeric_limits<long double>::digits10); ee > 0; --ee ) {
1166         delta *= 10.0l;
1167       }
1168       // we may loss some digits here, but not more than mantissa:
1169       cerr << "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" << endl;
1170       cerr << str.str() << endl;
1171       cerr << delta << endl;
1172       cerr << f << endl;
1173       CPPUNIT_CHECK( (f > (1.0e+83l - delta)) && (f < (1.0e+83l + delta)) );
1174     } else {
1175       CPPUNIT_CHECK( check_double(f, 1.0e+83l) );
1176     }
1177   }
1178 #endif
1179
1180   reset_stream(str);
1181   str.precision(0);
1182   str << numeric_limits<double>::max();
1183   {
1184     istringstream istr( str.str() );
1185     double f;
1186     istr >> f;
1187     CPPUNIT_CHECK( !istr.fail() );
1188     if ( int(numeric_limits<double>::digits10) < int(numeric_limits<double>::max_exponent10) ) {
1189       double delta = 9.0;
1190       for ( int ee = int(numeric_limits<double>::max_exponent10) - int(numeric_limits<double>::digits10); ee > 0; --ee ) {
1191         delta *= 10.0;
1192       }
1193       // we may loss some digits here, but not more than mantissa:
1194       CPPUNIT_CHECK( (f > (numeric_limits<double>::max() - delta)) );
1195     }
1196   }
1197
1198 #if 0 // #ifndef _STLP_NO_LONG_DOUBLE
1199   reset_stream(str);
1200   str.precision(0);
1201   str << numeric_limits<long double>::max();
1202   {
1203     istringstream istr( str.str() );
1204     long double f;
1205     istr >> f;
1206     CPPUNIT_CHECK( !istr.fail() );
1207     if ( int(numeric_limits<long double>::digits10) < int(numeric_limits<long double>::max_exponent10) ) {
1208       long double delta = 1.0l;
1209       for ( int ee = int(numeric_limits<long double>::max_exponent10) - int(numeric_limits<long double>::digits10); ee > 0; --ee ) {
1210         delta *= 10.0l;
1211       }
1212       // we may loss some digits here, but not more than mantissa:
1213       CPPUNIT_CHECK( (f > (numeric_limits<long double>::max() - delta)) );
1214     }
1215   }
1216 #endif
1217 }
1218
1219 class CommaSepNumPunct : public numpunct<char> {
1220   char do_thousands_sep() const { return ','; }
1221   string do_grouping() const { return string("\1\2\3") + (char)CHAR_MAX; }
1222 };
1223
1224 #define CHECK2(val, expected) \
1225   os.str(""); os << fixed << setprecision(3) << showpos << val; \
1226   CPPUNIT_ASSERT( os.str() == expected )
1227
1228 // Use unadulterated os2 when expecting inf
1229 #define CHECKINF(val, expected, expected2) \
1230   os2.str(""); os2 << fixed << setprecision(4) << showpos << val; \
1231   CPPUNIT_ASSERT( os2.str() == expected || os2.str() == expected2 )
1232
1233 void NumPutGetTest::custom_numpunct()
1234 {
1235     ostringstream os, os2;
1236     locale loc(os.getloc(), new CommaSepNumPunct());
1237     os.imbue(loc);
1238
1239     CHECK2(1, "+1");
1240     CHECK2(10, "+1,0");
1241     CHECK2(100, "+10,0");
1242     CHECK2(1000, "+1,00,0");
1243
1244     CHECK2(1.234, "+1.234");
1245     CHECK2(123.456, "+12,3.456");
1246     CHECK2(1234.567, "+1,23,4.567");
1247     CHECK2(12345.678, "+12,34,5.678");
1248     CHECK2(123456.789, "+123,45,6.789");
1249     CHECK2(1234567.891, "+1,234,56,7.891");
1250     CHECK2(123456789.123, "+123,456,78,9.123");
1251     //CHECK2(100000000000000000000000000000.0, "+100000000000000000000000,000,00,0.000");
1252     CHECKINF(numeric_limits<double>::infinity(), "+inf", "+Inf");
1253
1254     CHECK2(-1.234, "-1.234");
1255     CHECK2(-123.456, "-12,3.456");
1256     CHECK2(-1234.567, "-1,23,4.567");
1257     CHECK2(-12345.678, "-12,34,5.678");
1258     CHECK2(-123456.789, "-123,45,6.789");
1259     CHECK2(-1234567.891, "-1,234,56,7.891");
1260     CHECK2(-123456789.123, "-123,456,78,9.123");
1261     //CHECK2(-100000000000000000000000000000.0, "-100000000000000000000000,000,00,0.000");
1262     CHECKINF(-numeric_limits<double>::infinity(), "-inf", "-Inf");
1263 }
1264
1265 #endif