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

   1 #include <string>
   2 #if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
   3 #  include <fstream>
   4 #  include <iostream>
   5 #  include <iomanip>
   6 #  include <sstream>
   7 #  include <vector>
   8 #  include <stdexcept>
   9
  10 #include <stdio.h>
  11
  12 #  include "full_streambuf.h"
  13 #  include "cppunit/cppunit_proxy.h"
  14
  15 #  if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
  16 using namespace std;
  17 #  endif
  18
  19 //The macro value gives approximately the generated file
  20 //size in Go
  21 //#define CHECK_BIG_FILE 4
  22
  23 #  if (!defined(STLPORT) && (defined (__GNUC__) && (__GNUC__ > 3))) || \
  24       (defined (STLPORT) && !defined (_STLP_NO_CUSTOM_IO) && !defined (_STLP_NO_MEMBER_TEMPLATES) && \
  25                             !((defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) || \
  26                               (defined (__GNUC__) && (__GNUC__ < 3)) || \
  27                               (defined (__SUNPRO_CC)) || \
  28                               (defined (__DMC__) && defined (_DLL))))
  29 #    define DO_CUSTOM_FACET_TEST
  30 #  endif
  31
  32 //
  33 // TestCase class
  34 //
  35 class FstreamTest : public CPPUNIT_NS::TestCase
  36 {
  37   CPPUNIT_TEST_SUITE(FstreamTest);
  38   CPPUNIT_TEST(output);
  39   CPPUNIT_TEST(input);
  40   CPPUNIT_TEST(input_char);
  41   CPPUNIT_TEST(io);
  42   CPPUNIT_TEST(err);
  43   CPPUNIT_TEST(tellg);
  44   CPPUNIT_TEST(tellp);
  45   CPPUNIT_TEST(seek);
  46   CPPUNIT_TEST(buf);
  47   CPPUNIT_TEST(rdbuf);
  48   CPPUNIT_TEST(streambuf_output);
  49   CPPUNIT_TEST(win32_file_format);
  50   CPPUNIT_TEST(null_stream);
  51 #  if defined (STLPORT) && (defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
  52   CPPUNIT_IGNORE;
  53 #  endif
  54   CPPUNIT_TEST(null_buf);
  55 #  if !defined (STLPORT) || !defined (_STLP_WIN32)
  56   CPPUNIT_TEST(offset);
  57 #  endif
  58 #  if defined (CHECK_BIG_FILE)
  59   CPPUNIT_TEST(big_file);
  60 #  endif
  61 #  if !defined (DO_CUSTOM_FACET_TEST)
  62   CPPUNIT_IGNORE;
  63 #  endif
  64   CPPUNIT_TEST(custom_facet);
  65   CPPUNIT_TEST_SUITE_END();
  66
  67   protected:
  68     void output();
  69     void input();
  70     void input_char();
  71     void io();
  72     void err();
  73     void tellg();
  74     void tellp();
  75     void seek();
  76     void buf();
  77     void rdbuf();
  78     void streambuf_output();
  79     void win32_file_format();
  80     void null_stream();
  81     void null_buf();
  82 #  if !defined (STLPORT) || !defined (_STLP_WIN32)
  83     void offset();
  84 #  endif
  85     void custom_facet();
  86 #  if defined (CHECK_BIG_FILE)
  87     void big_file();
  88 #  endif
  89 };
  90
  91 CPPUNIT_TEST_SUITE_REGISTRATION(FstreamTest);
  92
  93 //
  94 // tests implementation
  95 //
  96 void FstreamTest::output()
  97 {
  98   ofstream f( "test_file.txt" );
  99
 100 #if 1
 101   CPPUNIT_ASSERT (f.good());
 102   f << 1;
 103   CPPUNIT_ASSERT (f.good());
 104   f << '\n';
 105   CPPUNIT_ASSERT (f.good());
 106   f << 2.0;
 107   CPPUNIT_ASSERT (f.good());
 108   f << '\n';
 109   CPPUNIT_ASSERT (f.good());
 110   f << "abcd\n";
 111   CPPUNIT_ASSERT (f.good());
 112   f << "ghk lm\n";
 113   CPPUNIT_ASSERT (f.good());
 114   f << "abcd ef";
 115   CPPUNIT_ASSERT (f.good());
 116 #else
 117   f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
 118   CPPUNIT_ASSERT (f.good());
 119 #endif
 120   // CPPUNIT_ASSERT( s.str() == "1\n2\nabcd\nghk lm\nabcd ef" );
 121 }
 122
 123 void FstreamTest::input()
 124 {
 125   {
 126     ifstream f( "test_file.txt" );
 127     int i = 0;
 128     f >> i;
 129     CPPUNIT_ASSERT( f.good() );
 130     CPPUNIT_ASSERT( i == 1 );
 131     double d = 0.0;
 132     f >> d;
 133     CPPUNIT_ASSERT( f.good() );
 134     CPPUNIT_ASSERT( d == 2.0 );
 135     string str;
 136     f >> str;
 137     CPPUNIT_ASSERT( f.good() );
 138     CPPUNIT_ASSERT( str == "abcd" );
 139     char c;
 140     f.get(c); // extract newline, that not extracted by operator >>
 141     CPPUNIT_ASSERT( f.good() );
 142     CPPUNIT_ASSERT( c == '\n' );
 143     getline( f, str );
 144     CPPUNIT_ASSERT( f.good() );
 145     CPPUNIT_ASSERT( str == "ghk lm" );
 146     getline( f, str );
 147     CPPUNIT_ASSERT( f.eof() );
 148     CPPUNIT_ASSERT( str == "abcd ef" );
 149   }
 150 #if defined (STLPORT) && !defined (_STLP_USE_WIN32_IO)
 151   {
 152     ifstream in("/tmp");
 153     if (in.good()) {
 154       string s;
 155       getline(in, s);
 156       CPPUNIT_ASSERT( in.fail() );
 157     }
 158   }
 159 #endif
 160 }
 161
 162 void FstreamTest::input_char()
 163 {
 164   char buf[16] = { 0, '1', '2', '3' };
 165   ifstream s( "test_file.txt" );
 166   s >> buf;
 167
 168   CPPUNIT_ASSERT( buf[0] == '1' );
 169   CPPUNIT_ASSERT( buf[1] == 0 );
 170   CPPUNIT_ASSERT( buf[2] == '2' );
 171 }
 172
 173 void FstreamTest::io()
 174 {
 175   basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 176
 177   CPPUNIT_ASSERT( f.is_open() );
 178
 179   f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
 180
 181   // f.flush();
 182   f.seekg( 0, ios_base::beg );
 183
 184   int i = 0;
 185   f >> i;
 186   CPPUNIT_ASSERT( f.good() );
 187   CPPUNIT_ASSERT( i == 1 );
 188   double d = 0.0;
 189   f >> d;
 190   CPPUNIT_ASSERT( d == 2.0 );
 191   string s;
 192   f >> s;
 193   CPPUNIT_ASSERT( f.good() );
 194   CPPUNIT_ASSERT( s == "abcd" );
 195   char c;
 196   f.get(c); // extract newline, that not extracted by operator >>
 197   CPPUNIT_ASSERT( f.good() );
 198   CPPUNIT_ASSERT( c == '\n' );
 199   getline( f, s );
 200   CPPUNIT_ASSERT( f.good() );
 201   CPPUNIT_ASSERT( s == "ghk lm" );
 202   getline( f, s );
 203   CPPUNIT_ASSERT( !f.fail() );
 204   CPPUNIT_ASSERT( s == "abcd ef" );
 205   CPPUNIT_ASSERT( f.eof() );
 206 }
 207
 208 void FstreamTest::err()
 209 {
 210   basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 211
 212   CPPUNIT_ASSERT( f.is_open() );
 213
 214   int i = 9;
 215   f << i;
 216   CPPUNIT_ASSERT( f.good() );
 217   i = 0;
 218   f.seekg( 0, ios_base::beg );
 219   f >> i;
 220   CPPUNIT_ASSERT( !f.fail() );
 221   CPPUNIT_ASSERT( i == 9 );
 222   f >> i;
 223   CPPUNIT_ASSERT( f.fail() );
 224   CPPUNIT_ASSERT( f.eof() );
 225   CPPUNIT_ASSERT( i == 9 );
 226 }
 227
 228 void FstreamTest::tellg()
 229 {
 230   {
 231     // bogus ios_base::binary is for Wins
 232     ofstream of("test_file.txt", ios_base::out | ios_base::binary | ios_base::trunc);
 233     CPPUNIT_ASSERT( of.is_open() );
 234
 235     for (int i = 0; i < 50; ++i) {
 236       of << "line " << setiosflags(ios_base::right) << setfill('0') << setw(2) << i << "\n";
 237       CPPUNIT_ASSERT( !of.fail() );
 238     }
 239     of.close();
 240   }
 241
 242   {
 243     // bogus ios_base::binary is for Wins
 244     ifstream is("test_file.txt", ios_base::in | ios_base::binary);
 245     CPPUNIT_ASSERT( is.is_open() );
 246     char buf[64];
 247
 248     // CPPUNIT_ASSERT( is.tellg() == 0 );
 249     streampos p = 0;
 250     for (int i = 0; i < 50; ++i) {
 251       is.read(buf, 0);
 252       CPPUNIT_ASSERT( is.gcount() == 0 );
 253       CPPUNIT_ASSERT( is.tellg() == p );
 254       is.read( buf, 8 );
 255       CPPUNIT_ASSERT( !is.fail() );
 256       CPPUNIT_ASSERT( is.gcount() == 8 );
 257       p += 8;
 258     }
 259   }
 260
 261   {
 262     // bogus ios_base::binary is for Wins
 263     ifstream is("test_file.txt", ios_base::in | ios_base::binary);
 264     CPPUNIT_ASSERT( is.is_open() );
 265
 266     streampos p = 0;
 267     for (int i = 0; i < 50; ++i) {
 268       CPPUNIT_ASSERT( !is.fail() );
 269       is.tellg();
 270       CPPUNIT_ASSERT( is.tellg() == p );
 271       p += 8;
 272       is.seekg( p, ios_base::beg  );
 273       CPPUNIT_ASSERT( !is.fail() );
 274     }
 275   }
 276
 277   {
 278     // bogus ios_base::binary is for Wins
 279     ifstream is("test_file.txt", ios_base::in | ios_base::binary);
 280     CPPUNIT_ASSERT( is.is_open() );
 281
 282     streampos p = 0;
 283     for (int i = 0; i < 50; ++i) {
 284       CPPUNIT_ASSERT( is.tellg() == p );
 285       p += 8;
 286       is.seekg( 8, ios_base::cur );
 287       CPPUNIT_ASSERT( !is.fail() );
 288     }
 289   }
 290 }
 291
 292 void FstreamTest::tellp()
 293 {
 294   {
 295     ofstream o( "test_file.txt" );
 296
 297     o << "123456";
 298
 299     CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(6) );
 300     CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(6) );
 301   }
 302   {
 303     ofstream o( "test_file.txt" );
 304
 305     o << "123456789";
 306
 307     CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(9) );
 308     CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(9) );
 309   }
 310   /* According to the standard
 311      ofstream o( "test_file.txt", ios_base::app | ios_base::out )
 312      should give the same effect as fopen( "test_file.txt", "a" ).
 313      Problem is fopen( "test_file.txt", "a" ) has a bit different behaviour
 314      on different platforms, and this difference is not covered by specification.
 315      After fopen( "test_file.txt", "a" ) in this context ftell( f ) == 9 for
 316      Linux and Mac OS X (I expect the same for others POSIX-like platforms too);
 317      on Windows (independently from version?) ftell( f ) == 0, i.e. write pointer not
 318      shifted to EOF (but shifted to EOF just before write, as described in the specs).
 319
 320      It isn't specifications violation, neither for Linux and Mac OS X nor for Windows.
 321
 322      The code below is intended to demonstrate ambiguity (dependance from fopen implementation).
 323    */
 324   {
 325     #ifdef WIN32
 326     //In Windows, stlport and fopen use kernel32.CreateFile for open.
 327     //File position is at BOF after open, unless we open with ios_base::ate
 328     long expected_pos = 0;
 329     #else
 330     //On UNIX flavours, stlport and fopen use unix's open
 331     //File position is at EOF after open
 332     //
 333     //3rd possible scenario, "other platforms" - _STLP_USE_STDIO_IO
 334     //stlport uses fopen here. This case may fail this test, since the file position after
 335     //fopen is implementation-dependent
 336     long expected_pos = 9;
 337     #endif
 338     ofstream o( "test_file.txt", ios_base::app | ios_base::out );
 339     CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(expected_pos) );
 340     CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(expected_pos) );
 341   }
 342   { // for reference, to test fopen/ftell behaviour in append mode:
 343     #ifdef WIN32
 344     long expected_pos = 0;
 345     #else
 346     long expected_pos = 9;
 347     #endif
 348     FILE* f = fopen( "test_file.txt", "a" );
 349     CPPUNIT_CHECK( ftell( f ) == expected_pos );
 350     fclose( f );
 351   }
 352   {
 353     //In append mode, file is positioned at EOF just before a write.
 354     // After a write, file is at EOF. This is implementation-independent.
 355     ofstream o( "test_file.txt", ios_base::app | ios_base::out );
 356     o << "X";
 357     CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(10) );
 358     CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(10) );
 359   }
 360 }
 361
 362 void FstreamTest::buf()
 363 {
 364   fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
 365
 366   ss << "1234567\n89\n";
 367   ss.seekg( 0, ios_base::beg );
 368   char buf[10];
 369   buf[7] = 'x';
 370   ss.get( buf, 10 );
 371   CPPUNIT_ASSERT( !ss.fail() );
 372   CPPUNIT_ASSERT( buf[0] == '1' );
 373   CPPUNIT_ASSERT( buf[1] == '2' );
 374   CPPUNIT_ASSERT( buf[2] == '3' );
 375   CPPUNIT_ASSERT( buf[3] == '4' );
 376   CPPUNIT_ASSERT( buf[4] == '5' );
 377   CPPUNIT_ASSERT( buf[5] == '6' );
 378   CPPUNIT_ASSERT( buf[6] == '7' ); // 27.6.1.3 paragraph 10, paragraph 7
 379   CPPUNIT_ASSERT( buf[7] == 0 ); // 27.6.1.3 paragraph 8
 380   char c;
 381   ss.get(c);
 382   CPPUNIT_ASSERT( !ss.fail() );
 383   CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 10, paragraph 7
 384   ss.get(c);
 385   CPPUNIT_ASSERT( !ss.fail() );
 386   CPPUNIT_ASSERT( c == '8' );
 387 }
 388
 389 void FstreamTest::seek()
 390 {
 391   {
 392     // Test in binary mode:
 393     {
 394       fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
 395       CPPUNIT_ASSERT( s );
 396
 397       s << "1234567890\n";
 398       CPPUNIT_ASSERT( s );
 399     }
 400
 401     char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
 402     fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary );
 403     CPPUNIT_ASSERT( s );
 404
 405     int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
 406     CPPUNIT_CHECK( chars_read == 11 );
 407     CPPUNIT_CHECK( b1[9] == '0' );
 408     CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( 0, ios_base::cur ) == fstream::pos_type(chars_read) );
 409     CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( -chars_read, ios_base::cur ) == fstream::pos_type(0) );
 410
 411     char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
 412
 413     CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 10 ) == 10 );
 414     CPPUNIT_CHECK( b2[9] == '0' );
 415   }
 416
 417   {
 418     // Test in text mode:
 419     {
 420       fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 421       CPPUNIT_ASSERT( s );
 422
 423       s << "1234567890\n";
 424       CPPUNIT_ASSERT( s );
 425     }
 426
 427     char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
 428     fstream s( "test_file.txt", ios_base::in | ios_base::out );
 429     CPPUNIT_ASSERT( s );
 430
 431     int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
 432     CPPUNIT_CHECK( chars_read == 11 );
 433     CPPUNIT_CHECK( b1[9] == '0' );
 434
 435     fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
 436     // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
 437     streamoff offset = pos;
 438     CPPUNIT_ASSERT( offset >= chars_read );
 439     offset = s.rdbuf()->pubseekoff( -offset, ios_base::cur );
 440     CPPUNIT_ASSERT( offset == 0 );
 441
 442     char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
 443
 444     CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
 445     CPPUNIT_CHECK( b2[4] == '5' );
 446
 447     pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
 448     CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
 449     CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
 450   }
 451
 452 #if !defined (STLPORT) || \
 453     (!defined (_STLP_NO_WCHAR_T) && defined (_STLP_USE_EXCEPTIONS))
 454   {
 455     // Test with a wariable encoding:
 456     locale loc;
 457     try
 458     {
 459       locale tmp(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".UTF8"));
 460       loc = tmp;
 461     }
 462     catch (const runtime_error&)
 463     {
 464       // Localization no supported so no test:
 465       return;
 466     }
 467
 468     {
 469       wfstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 470       CPPUNIT_ASSERT( s );
 471       s.imbue(loc);
 472       CPPUNIT_ASSERT( s );
 473
 474       s << L"1234567890\n";
 475       CPPUNIT_ASSERT( s );
 476     }
 477
 478     wchar_t b1[] = { L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x' };
 479     wfstream s( "test_file.txt", ios_base::in | ios_base::out );
 480     CPPUNIT_ASSERT( s );
 481     s.imbue(loc);
 482     CPPUNIT_ASSERT( s );
 483
 484     int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) / sizeof(wchar_t) );
 485     CPPUNIT_CHECK( chars_read == 11 );
 486     CPPUNIT_CHECK( b1[9] == L'0' );
 487
 488     fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
 489     // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
 490     streamoff off = pos;
 491     CPPUNIT_ASSERT( off >= chars_read );
 492     off = s.rdbuf()->pubseekoff(-off, ios_base::cur);
 493     CPPUNIT_ASSERT( off == -1 );
 494     off = s.rdbuf()->pubseekoff(0, ios_base::beg);
 495     CPPUNIT_ASSERT( off == 0 );
 496
 497     wchar_t b2[10] = { L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y' };
 498
 499     CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
 500     CPPUNIT_CHECK( b2[4] == L'5' );
 501
 502     pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
 503     CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
 504     //CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
 505   }
 506 #endif
 507 }
 508
 509 void FstreamTest::rdbuf()
 510 {
 511   fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
 512
 513   ss << "1234567\n89\n";
 514   ss.seekg( 0, ios_base::beg );
 515
 516   ostringstream os;
 517   ss.get( *os.rdbuf(), '\n' );
 518   CPPUNIT_ASSERT( !ss.fail() );
 519   char c;
 520   ss.get(c);
 521   CPPUNIT_ASSERT( !ss.fail() );
 522   CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 12
 523   CPPUNIT_ASSERT( os.str() == "1234567" );
 524 }
 525
 526 void FstreamTest::streambuf_output()
 527 {
 528   {
 529     ofstream ofstr("test_file.txt", ios_base::binary);
 530     if (!ofstr)
 531       //No test if we cannot create the file
 532       return;
 533     ofstr << "01234567890123456789";
 534     CPPUNIT_ASSERT( ofstr );
 535   }
 536
 537   {
 538     ifstream in("test_file.txt", ios_base::binary);
 539     CPPUNIT_ASSERT( in );
 540
 541     full_streambuf full_buf(10);
 542     ostream out(&full_buf);
 543     CPPUNIT_ASSERT( out );
 544
 545     out << in.rdbuf();
 546     CPPUNIT_ASSERT( out );
 547     CPPUNIT_ASSERT( in );
 548     CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
 549
 550     out << in.rdbuf();
 551     CPPUNIT_ASSERT( out.fail() );
 552     CPPUNIT_ASSERT( in );
 553
 554     ostringstream ostr;
 555     ostr << in.rdbuf();
 556     CPPUNIT_ASSERT( ostr );
 557     CPPUNIT_ASSERT( in );
 558     CPPUNIT_ASSERT( ostr.str() == "0123456789" );
 559   }
 560
 561 #  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 562   {
 563     //If the output stream buffer throws:
 564     ifstream in("test_file.txt", ios_base::binary);
 565     CPPUNIT_ASSERT( in );
 566
 567     full_streambuf full_buf(10, true);
 568     ostream out(&full_buf);
 569     CPPUNIT_ASSERT( out );
 570
 571     out << in.rdbuf();
 572     CPPUNIT_ASSERT( out.bad() );
 573     CPPUNIT_ASSERT( in );
 574     //out is bad we have no guaranty on what has been extracted:
 575     //CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
 576
 577     out.clear();
 578     out << in.rdbuf();
 579     CPPUNIT_ASSERT( out.fail() && out.bad() );
 580     CPPUNIT_ASSERT( in );
 581
 582     ostringstream ostr;
 583     ostr << in.rdbuf();
 584     CPPUNIT_ASSERT( ostr );
 585     CPPUNIT_ASSERT( in );
 586     CPPUNIT_ASSERT( ostr.str() == "0123456789" );
 587   }
 588 #  endif
 589 }
 590
 591 void FstreamTest::win32_file_format()
 592 {
 593   const char* file_name = "win32_file_format.tmp";
 594   const size_t nb_lines = 2049;
 595   {
 596     ofstream out(file_name);
 597     CPPUNIT_ASSERT( out.good() );
 598     out << 'a';
 599     for (size_t i = 0; i < nb_lines - 1; ++i) {
 600       out << '\n';
 601     }
 602     out << '\r';
 603     CPPUNIT_ASSERT( out.good() );
 604   }
 605   {
 606     ifstream in(file_name);
 607     CPPUNIT_ASSERT( in.good() );
 608     string line, last_line;
 609     size_t nb_read_lines = 0;
 610     while (getline(in, line)) {
 611       ++nb_read_lines;
 612       last_line = line;
 613     }
 614     CPPUNIT_ASSERT( in.eof() );
 615     CPPUNIT_ASSERT( nb_read_lines == nb_lines );
 616     CPPUNIT_ASSERT( !last_line.empty() && (last_line[0] == '\r') );
 617   }
 618 }
 619
 620 #if defined (DO_CUSTOM_FACET_TEST)
 621 struct my_state {
 622   char dummy;
 623 };
 624
 625 struct my_traits : public char_traits<char> {
 626   typedef my_state state_type;
 627   typedef fpos<state_type> pos_type;
 628 };
 629
 630 #if !defined (STLPORT)
 631 //STLport grant a default implementation, other Standard libs implementation
 632 //do not necessarily do the same:
 633 namespace std {
 634   template <>
 635   class codecvt<char, char, my_state>
 636     : public locale::facet, public codecvt_base {
 637   public:
 638     typedef char intern_type;
 639     typedef char extern_type;
 640     typedef my_state state_type;
 641
 642     explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 643     result out(state_type&,
 644                const intern_type*  __from,
 645                const intern_type*,
 646                const intern_type*& __from_next,
 647                extern_type*        __to,
 648                extern_type*,
 649                extern_type*&       __to_next) const
 650     { __from_next = __from; __to_next   = __to; return noconv; }
 651
 652     result in (state_type&,
 653                const extern_type*  __from,
 654                const extern_type*,
 655                const extern_type*& __from_next,
 656                intern_type*        __to,
 657                intern_type*,
 658                intern_type*&       __to_next) const
 659     { __from_next = __from; __to_next = __to; return noconv; }
 660
 661     result unshift(state_type&,
 662                    extern_type* __to,
 663                    extern_type*,
 664                    extern_type*& __to_next) const
 665     { __to_next = __to; return noconv; }
 666
 667     int encoding() const throw()
 668     { return 1; }
 669
 670     bool always_noconv() const throw()
 671     { return true; }
 672
 673     int length(const state_type&,
 674                const extern_type* __from,
 675                const extern_type* __end,
 676                size_t __max) const
 677     { return (int)min(static_cast<size_t>(__end - __from), __max); }
 678
 679     int max_length() const throw()
 680     { return 1; }
 681
 682     static locale::id id;
 683   };
 684
 685   locale::id codecvt<char, char, my_state>::id;
 686 }
 687 #  else
 688 #    if defined (__BORLANDC__) && (__BORLANDC__ < 0x590)
 689 template <>
 690 locale::id codecvt<char, char, my_state>::id;
 691 #    endif
 692 #  endif
 693 #endif
 694
 695 void FstreamTest::custom_facet()
 696 {
 697 #if defined (DO_CUSTOM_FACET_TEST)
 698   const char* fileName = "test_file.txt";
 699   //File preparation:
 700   {
 701     ofstream ofstr(fileName, ios_base::binary);
 702     ofstr << "0123456789";
 703     CPPUNIT_ASSERT( ofstr );
 704   }
 705
 706   {
 707     typedef basic_ifstream<char, my_traits> my_ifstream;
 708     typedef basic_string<char, my_traits> my_string;
 709
 710     my_ifstream ifstr(fileName);
 711     CPPUNIT_ASSERT( ifstr );
 712
 713 #  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
 714     ifstr.imbue(locale::classic());
 715     CPPUNIT_ASSERT( ifstr.fail() && !ifstr.bad() );
 716     ifstr.clear();
 717 #  endif
 718     typedef codecvt<char, char, my_state> my_codecvt;
 719     locale my_loc(locale::classic(), new my_codecvt());
 720     // Check that my_codecvt has not replace default codecvt:
 721     CPPUNIT_ASSERT( (has_facet<my_codecvt>(my_loc)) );
 722     CPPUNIT_ASSERT( (has_facet<codecvt<char, char, mbstate_t> >(my_loc)) );
 723 #  if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
 724     CPPUNIT_ASSERT( (has_facet<codecvt<wchar_t, char, mbstate_t> >(my_loc)) );
 725 #  endif
 726     ifstr.imbue(my_loc);
 727     CPPUNIT_ASSERT( ifstr.good() );
 728     /*
 729     my_string res;
 730     ifstr >> res;
 731     CPPUNIT_ASSERT( !ifstr.fail() );
 732     CPPUNIT_ASSERT( !ifstr.bad() );
 733     CPPUNIT_ASSERT( ifstr.eof() );
 734     CPPUNIT_ASSERT( res == "0123456789" );
 735     */
 736   }
 737 #endif
 738 }
 739
 740 #  if defined (CHECK_BIG_FILE)
 741 void FstreamTest::big_file()
 742 {
 743   vector<pair<streamsize, streamoff> > file_pos;
 744
 745   //Big file creation:
 746   {
 747     ofstream out("big_file.txt");
 748     CPPUNIT_ASSERT( out );
 749
 750     //We are going to generate a file with the following schema for the content:
 751     //0(1019 times)0000  //1023 characters + 1 charater for \n (for some platforms it will be a 1 ko line)
 752     //0(1019 times)0001
 753     //...
 754     //0(1019 times)1234
 755     //...
 756
 757     //Generation of the number of loop:
 758     streamoff nb = 1;
 759     for (int i = 0; i < 20; ++i) {
 760       //This assertion check that the streamoff can at least represent the necessary integers values
 761       //for this test:
 762       CPPUNIT_ASSERT( (nb << 1) > nb );
 763       nb <<= 1;
 764     }
 765     CPPUNIT_ASSERT( nb * CHECK_BIG_FILE >= nb );
 766     nb *= CHECK_BIG_FILE;
 767
 768     //Preparation of the ouput stream state:
 769     out << setiosflags(ios_base::right) << setfill('*');
 770     for (streamoff index = 0; index < nb; ++index) {
 771       if (index % 1024 == 0) {
 772         file_pos.push_back(make_pair(out.tellp(), index));
 773         CPPUNIT_ASSERT( file_pos.back().first != streamsize(-1) );
 774         if (file_pos.size() > 1) {
 775           CPPUNIT_ASSERT( file_pos[file_pos.size() - 1].first > file_pos[file_pos.size() - 2].first );
 776         }
 777       }
 778       out << setw(1023) << index << '\n';
 779     }
 780   }
 781
 782   {
 783     ifstream in("big_file.txt");
 784     CPPUNIT_ASSERT( in );
 785
 786     string line;
 787     vector<pair<streamsize, streamsize> >::const_iterator pit(file_pos.begin()),
 788                                                           pitEnd(file_pos.end());
 789     for (; pit != pitEnd; ++pit) {
 790       in.seekg((*pit).first);
 791       CPPUNIT_ASSERT( in );
 792       in >> line;
 793       size_t lastStarPos = line.rfind('*');
 794       CPPUNIT_ASSERT( atoi(line.substr(lastStarPos + 1).c_str()) == (*pit).second );
 795     }
 796   }
 797
 798   /*
 799   The following test has been used to check that STLport do not generate
 800   an infinite loop when the file size is larger than the streamsize and
 801   streamoff representation (32 bits or 64 bits).
 802   {
 803     ifstream in("big_file.txt");
 804     CPPUNIT_ASSERT( in );
 805     char tmp[4096];
 806     streamsize nb_reads = 0;
 807     while ((!in.eof()) && in.good()){
 808       in.read(tmp, 4096);
 809       nb_reads += in.gcount();
 810     }
 811   }
 812   */
 813 }
 814 #  endif
 815
 816 void FstreamTest::null_stream()
 817 {
 818 #  if (defined (STLPORT) && defined (_STLP_USE_WIN32_IO)) || \
 819       (!defined (STLPORT) && (defined (WIN32) || defined (_WIN32)))
 820   const char* nullStreamName = "NUL";
 821 #  else
 822   const char* nullStreamName = "/dev/null";
 823 #  endif
 824   {
 825     ofstream nullStream(nullStreamName);
 826     CPPUNIT_CHECK( nullStream );
 827   }
 828
 829   {
 830     ofstream nullStream(nullStreamName, ios_base::ate);
 831     CPPUNIT_CHECK( nullStream );
 832   }
 833
 834   {
 835     ofstream nullStream(nullStreamName, ios_base::trunc);
 836     CPPUNIT_CHECK( nullStream );
 837   }
 838
 839   {
 840     ofstream nullStream(nullStreamName, ios_base::app);
 841     CPPUNIT_CHECK( nullStream );
 842   }
 843
 844   {
 845     ifstream nullStream(nullStreamName);
 846     CPPUNIT_CHECK( nullStream );
 847   }
 848
 849   {
 850     ifstream nullStream(nullStreamName, ios_base::ate);
 851     CPPUNIT_CHECK( nullStream );
 852   }
 853
 854   {
 855     fstream nullStream(nullStreamName);
 856     CPPUNIT_CHECK( nullStream );
 857   }
 858
 859   {
 860     fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::ate);
 861     CPPUNIT_CHECK( nullStream );
 862   }
 863
 864   {
 865     fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::trunc);
 866     CPPUNIT_CHECK( nullStream );
 867   }
 868 }
 869
 870 void FstreamTest::null_buf()
 871 {
 872   /* **********************************************************************************
 873
 874   testcase for bug #1830513:
 875   in _istream.c
 876
 877   template < class _CharT, class _Traits, class _Is_Delim>
 878   streamsize _STLP_CALL __read_unbuffered(basic_istream<_CharT, _Traits>* __that,
 879                                           basic_streambuf<_CharT, _Traits>* __buf,
 880                                           streamsize _Num, _CharT* __s,
 881                                           _Is_Delim __is_delim,
 882                                           bool __extract_delim, bool __append_null,
 883                                           bool __is_getline)
 884
 885   can't accept _Num == 0; this is legal case, and may happen from
 886
 887   template <class _CharT, class _Traits>
 888   basic_istream<_CharT, _Traits>&
 889   basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n, _CharT __delim)
 890
 891   *********************************************************************************** */
 892
 893   fstream f( "test.txt", ios_base::in | ios_base::out | ios_base::trunc );
 894   // string line;
 895
 896   for ( int i = 0; i < 0x200; ++i ) {
 897     f.put( ' ' );
 898   }
 899
 900   // const streambuf *b = f.rdbuf();
 901
 902   // string s;
 903   char buf[1024];
 904   buf[0] = 'a';
 905   buf[1] = 'b';
 906   buf[2] = 'c';
 907
 908   // getline( f, s );
 909   // cerr << f.good() << endl;
 910   f.seekg( 0, ios_base::beg );
 911   // f.seekg( 0, ios_base::end );
 912   // buf[0] = f.get();
 913
 914   // cerr << (void *)(b->_M_gptr()) << " " << (void *)(b->_M_egptr()) << endl;
 915   // cerr << f.good() << endl;
 916   // getline( f, s );
 917   f.getline( buf, 1 ); // <-- key line
 918   CPPUNIT_CHECK( buf[0] == 0 );
 919   CPPUNIT_CHECK( f.fail() ); // due to delimiter not found while buffer was exhausted
 920 }
 921
 922 #  if !defined (STLPORT) || !defined (_STLP_WIN32)
 923 void FstreamTest::offset()
 924 {
 925 #    if (defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE)) && !defined(_STLP_USE_DEFAULT_FILE_OFFSET)
 926   CPPUNIT_CHECK( sizeof(streamoff) == 8 );
 927 #    else
 928   CPPUNIT_CHECK( sizeof(streamoff) == sizeof(off_t) );
 929 #    endif
 930 }
 931 #  endif
 932
 933 #endif