FstreamTest Class Reference

Inheritance diagram for FstreamTest:

Collaboration diagram for FstreamTest:

Protected Member Functions
void	output ()
void	input ()
void	input_char ()
void	io ()
void	err ()
void	tellg ()
void	tellp ()
void	seek ()
void	buf ()
void	rdbuf ()
void	streambuf_output ()
void	win32_file_format ()
void	null_stream ()
void	null_buf ()
void	offset ()
void	custom_facet ()

Private Member Functions
	CPPUNIT_TEST_SUITE (FstreamTest)
	CPPUNIT_TEST (output)
	CPPUNIT_TEST (input)
	CPPUNIT_TEST (input_char)
	CPPUNIT_TEST (io)
	CPPUNIT_TEST (err)
	CPPUNIT_TEST (tellg)
	CPPUNIT_TEST (tellp)
	CPPUNIT_TEST (seek)
	CPPUNIT_TEST (buf)
	CPPUNIT_TEST (rdbuf)
	CPPUNIT_TEST (streambuf_output)
	CPPUNIT_TEST (win32_file_format)
	CPPUNIT_TEST (null_stream)
	CPPUNIT_TEST (null_buf)
	CPPUNIT_TEST (offset)
	CPPUNIT_TEST (custom_facet)
	CPPUNIT_TEST_SUITE_END ()

Private Attributes
	CPPUNIT_IGNORE

Detailed Description

Definition at line 35 of file fstream_test.cpp.

Member Function Documentation

buf()

void FstreamTest::buf ( )

protected

Definition at line 344 of file fstream_test.cpp.

{
  fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
 
  ss << "1234567\n89\n";
  ss.seekg( 0, ios_base::beg );
  char buf[10];
  buf[7] = 'x';
  ss.get( buf, 10 );
  CPPUNIT_ASSERT( !ss.fail() );
  CPPUNIT_ASSERT( buf[0] == '1' );
  CPPUNIT_ASSERT( buf[1] == '2' );
  CPPUNIT_ASSERT( buf[2] == '3' );
  CPPUNIT_ASSERT( buf[3] == '4' );
  CPPUNIT_ASSERT( buf[4] == '5' );
  CPPUNIT_ASSERT( buf[5] == '6' );
  CPPUNIT_ASSERT( buf[6] == '7' ); // 27.6.1.3 paragraph 10, paragraph 7
  CPPUNIT_ASSERT( buf[7] == 0 ); // 27.6.1.3 paragraph 8
  char c;
  ss.get(c);
  CPPUNIT_ASSERT( !ss.fail() );
  CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 10, paragraph 7
  ss.get(c);
  CPPUNIT_ASSERT( !ss.fail() );
  CPPUNIT_ASSERT( c == '8' );
}

Referenced by input_char().

CPPUNIT_TEST() [1/16]

FstreamTest::CPPUNIT_TEST ( buf  )

private

CPPUNIT_TEST() [2/16]

FstreamTest::CPPUNIT_TEST ( custom_facet  )

private

CPPUNIT_TEST() [3/16]

FstreamTest::CPPUNIT_TEST ( err  )

private

CPPUNIT_TEST() [4/16]

FstreamTest::CPPUNIT_TEST ( input  )

private

CPPUNIT_TEST() [5/16]

FstreamTest::CPPUNIT_TEST ( input_char  )

private

CPPUNIT_TEST() [6/16]

FstreamTest::CPPUNIT_TEST ( io  )

private

CPPUNIT_TEST() [7/16]

FstreamTest::CPPUNIT_TEST ( null_buf  )

private

CPPUNIT_TEST() [8/16]

FstreamTest::CPPUNIT_TEST ( null_stream  )

private

CPPUNIT_TEST() [9/16]

FstreamTest::CPPUNIT_TEST ( offset  )

private

CPPUNIT_TEST() [10/16]

FstreamTest::CPPUNIT_TEST ( output  )

private

CPPUNIT_TEST() [11/16]

FstreamTest::CPPUNIT_TEST ( rdbuf  )

private

CPPUNIT_TEST() [12/16]

FstreamTest::CPPUNIT_TEST ( seek  )

private

CPPUNIT_TEST() [13/16]

FstreamTest::CPPUNIT_TEST ( streambuf_output  )

private

CPPUNIT_TEST() [14/16]

FstreamTest::CPPUNIT_TEST ( tellg  )

private

CPPUNIT_TEST() [15/16]

FstreamTest::CPPUNIT_TEST ( tellp  )

private

CPPUNIT_TEST() [16/16]

FstreamTest::CPPUNIT_TEST ( win32_file_format  )

private

CPPUNIT_TEST_SUITE()

FstreamTest::CPPUNIT_TEST_SUITE ( FstreamTest  )

private

CPPUNIT_TEST_SUITE_END()

FstreamTest::CPPUNIT_TEST_SUITE_END ( )

private

custom_facet()

void FstreamTest::custom_facet ( )

protected

Definition at line 677 of file fstream_test.cpp.

{
#if defined (DO_CUSTOM_FACET_TEST)
  const char* fileName = "test_file.txt";
  //File preparation:
  {
    ofstream ofstr(fileName, ios_base::binary);
    ofstr << "0123456789";
    CPPUNIT_ASSERT( ofstr );
  }
 
  {
    typedef basic_ifstream<char, my_traits> my_ifstream;
    typedef basic_string<char, my_traits> my_string;
 
    my_ifstream ifstr(fileName);
    CPPUNIT_ASSERT( ifstr );
 
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
    ifstr.imbue(locale::classic());
    CPPUNIT_ASSERT( ifstr.fail() && !ifstr.bad() );
    ifstr.clear();
#  endif
    typedef codecvt<char, char, my_state> my_codecvt;
    locale my_loc(locale::classic(), new my_codecvt());
    // Check that my_codecvt has not replace default codecvt:
    CPPUNIT_ASSERT( (has_facet<my_codecvt>(my_loc)) );
    CPPUNIT_ASSERT( (has_facet<codecvt<char, char, mbstate_t> >(my_loc)) );
#  if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
    CPPUNIT_ASSERT( (has_facet<codecvt<wchar_t, char, mbstate_t> >(my_loc)) );
#  endif
    ifstr.imbue(my_loc);
    CPPUNIT_ASSERT( ifstr.good() );
    /*
    my_string res;
    ifstr >> res;
    CPPUNIT_ASSERT( !ifstr.fail() );
    CPPUNIT_ASSERT( !ifstr.bad() );
    CPPUNIT_ASSERT( ifstr.eof() );
    CPPUNIT_ASSERT( res == "0123456789" );
    */
  }
#endif
}

err()

void FstreamTest::err ( )

protected

Definition at line 190 of file fstream_test.cpp.

{
  basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 
  CPPUNIT_ASSERT( f.is_open() );
 
  int i = 9;
  f << i;
  CPPUNIT_ASSERT( f.good() );
  i = 0;
  f.seekg( 0, ios_base::beg );
  f >> i;
  CPPUNIT_ASSERT( !f.fail() );
  CPPUNIT_ASSERT( i == 9 );
  f >> i;
  CPPUNIT_ASSERT( f.fail() );
  CPPUNIT_ASSERT( f.eof() );
  CPPUNIT_ASSERT( i == 9 );
}

input()

void FstreamTest::input ( )

protected

Definition at line 105 of file fstream_test.cpp.

{
  {
    ifstream f( "test_file.txt" );
    int i = 0;
    f >> i;
    CPPUNIT_ASSERT( f.good() );
    CPPUNIT_ASSERT( i == 1 );
    double d = 0.0;
    f >> d;
    CPPUNIT_ASSERT( f.good() );
    CPPUNIT_ASSERT( d == 2.0 );
    string str;
    f >> str;
    CPPUNIT_ASSERT( f.good() );
    CPPUNIT_ASSERT( str == "abcd" );
    char c;
    f.get(c); // extract newline, that not extracted by operator >>
    CPPUNIT_ASSERT( f.good() );
    CPPUNIT_ASSERT( c == '\n' );
    getline( f, str );
    CPPUNIT_ASSERT( f.good() );
    CPPUNIT_ASSERT( str == "ghk lm" );
    getline( f, str );
    CPPUNIT_ASSERT( f.eof() );
    CPPUNIT_ASSERT( str == "abcd ef" );
  }
#if defined (STLPORT) && !defined (_STLP_USE_WIN32_IO)
  {
    ifstream in("/tmp");
    if (in.good()) {
      string s;
      getline(in, s);
      CPPUNIT_ASSERT( in.fail() );
    }
  }
#endif
}

input_char()

void FstreamTest::input_char ( )

protected

Definition at line 144 of file fstream_test.cpp.

{
  char buf[16] = { 0, '1', '2', '3' };
  ifstream s( "test_file.txt" );
  s >> buf;
 
  CPPUNIT_ASSERT( buf[0] == '1' );
  CPPUNIT_ASSERT( buf[1] == 0 );
  CPPUNIT_ASSERT( buf[2] == '2' );
}

io()

void FstreamTest::io ( )

protected

Definition at line 155 of file fstream_test.cpp.

{
  basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
 
  CPPUNIT_ASSERT( f.is_open() );
 
  f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
 
  // f.flush();
  f.seekg( 0, ios_base::beg );
 
  int i = 0;
  f >> i;
  CPPUNIT_ASSERT( f.good() );
  CPPUNIT_ASSERT( i == 1 );
  double d = 0.0;
  f >> d;
  CPPUNIT_ASSERT( d == 2.0 );
  string s;
  f >> s;
  CPPUNIT_ASSERT( f.good() );
  CPPUNIT_ASSERT( s == "abcd" );
  char c;
  f.get(c); // extract newline, that not extracted by operator >>
  CPPUNIT_ASSERT( f.good() );
  CPPUNIT_ASSERT( c == '\n' );
  getline( f, s );
  CPPUNIT_ASSERT( f.good() );
  CPPUNIT_ASSERT( s == "ghk lm" );
  getline( f, s );
  CPPUNIT_ASSERT( !f.fail() );
  CPPUNIT_ASSERT( s == "abcd ef" );
  CPPUNIT_ASSERT( f.eof() );
}

null_buf()

void FstreamTest::null_buf ( )

protected

Definition at line 852 of file fstream_test.cpp.

{
  /* **********************************************************************************
 
  testcase for bug #1830513:
  in _istream.c
 
  template < class _CharT, class _Traits, class _Is_Delim>
  streamsize _STLP_CALL __read_unbuffered(basic_istream<_CharT, _Traits>* __that,
                                          basic_streambuf<_CharT, _Traits>* __buf,
                                          streamsize _Num, _CharT* __s,
                                          _Is_Delim __is_delim,
                                          bool __extract_delim, bool __append_null,
                                          bool __is_getline)
 
  can't accept _Num == 0; this is legal case, and may happen from
 
  template <class _CharT, class _Traits>
  basic_istream<_CharT, _Traits>&
  basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n, _CharT __delim)
 
  *********************************************************************************** */
 
  fstream f( "test.txt", ios_base::in | ios_base::out | ios_base::trunc );
  // string line;
 
  for ( int i = 0; i < 0x200; ++i ) {
    f.put( ' ' );
  }
 
  // const streambuf *b = f.rdbuf();
 
  // string s;
  char buf[1024];
  buf[0] = 'a';
  buf[1] = 'b';
  buf[2] = 'c';
 
  // getline( f, s );
  // cerr << f.good() << endl;
  f.seekg( 0, ios_base::beg );
  // f.seekg( 0, ios_base::end );
  // buf[0] = f.get();
 
  // cerr << (void *)(b->_M_gptr()) << " " << (void *)(b->_M_egptr()) << endl;
  // cerr << f.good() << endl;
  // getline( f, s );
  f.getline( buf, 1 ); // <-- key line
  CPPUNIT_CHECK( buf[0] == 0 );
  CPPUNIT_CHECK( f.fail() ); // due to delimiter not found while buffer was exhausted
}

null_stream()

void FstreamTest::null_stream ( )

protected

Definition at line 798 of file fstream_test.cpp.

{
#  if (defined (STLPORT) && defined (_STLP_USE_WIN32_IO)) || \
      (!defined (STLPORT) && (defined (WIN32) || defined (_WIN32)))
  const char* nullStreamName = "NUL";
#  else
  const char* nullStreamName = "/dev/null";
#  endif
  {
    ofstream nullStream(nullStreamName);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    ofstream nullStream(nullStreamName, ios_base::ate);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    ofstream nullStream(nullStreamName, ios_base::trunc);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    ofstream nullStream(nullStreamName, ios_base::app);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    ifstream nullStream(nullStreamName);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    ifstream nullStream(nullStreamName, ios_base::ate);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    fstream nullStream(nullStreamName);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::ate);
    CPPUNIT_CHECK( nullStream );
  }
 
  {
    fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::trunc);
    CPPUNIT_CHECK( nullStream );
  }
}

offset()

void FstreamTest::offset ( )

protected

Definition at line 905 of file fstream_test.cpp.

{
#    if (defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE)) && !defined(_STLP_USE_DEFAULT_FILE_OFFSET)
  CPPUNIT_CHECK( sizeof(streamoff) == 8 );
#    else
  CPPUNIT_CHECK( sizeof(streamoff) == sizeof(off_t) );
#    endif
}

output()

void FstreamTest::output ( )

protected

Definition at line 96 of file fstream_test.cpp.

{
  ofstream f( "test_file.txt" );
 
  f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
  CPPUNIT_ASSERT (f.good());
  // CPPUNIT_ASSERT( s.str() == "1\n2\nabcd\nghk lm\nabcd ef" );
}

rdbuf()

void FstreamTest::rdbuf ( )

protected

Definition at line 491 of file fstream_test.cpp.

{
  fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
 
  ss << "1234567\n89\n";
  ss.seekg( 0, ios_base::beg );
 
  ostringstream os;
  ss.get( *os.rdbuf(), '\n' );
  CPPUNIT_ASSERT( !ss.fail() );
  char c;
  ss.get(c);
  CPPUNIT_ASSERT( !ss.fail() );
  CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 12
  CPPUNIT_ASSERT( os.str() == "1234567" );
}

seek()

void FstreamTest::seek ( )

protected

Definition at line 371 of file fstream_test.cpp.

{
  {
    // Test in binary mode:
    {
      fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
      CPPUNIT_ASSERT( s );
 
      s << "1234567890\n";
      CPPUNIT_ASSERT( s );
    }
 
    char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
    fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary );
    CPPUNIT_ASSERT( s );
 
    int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
    CPPUNIT_CHECK( chars_read == 11 );
    CPPUNIT_CHECK( b1[9] == '0' );
    CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( 0, ios_base::cur ) == fstream::pos_type(chars_read) );
    CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( -chars_read, ios_base::cur ) == fstream::pos_type(0) );
 
    char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
 
    CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 10 ) == 10 );
    CPPUNIT_CHECK( b2[9] == '0' );
  }
 
  {
    // Test in text mode:
    {
      fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
      CPPUNIT_ASSERT( s );
 
      s << "1234567890\n";
      CPPUNIT_ASSERT( s );
    }
 
    char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
    fstream s( "test_file.txt", ios_base::in | ios_base::out );
    CPPUNIT_ASSERT( s );
 
    int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
    CPPUNIT_CHECK( chars_read == 11 );
    CPPUNIT_CHECK( b1[9] == '0' );
 
    fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
    // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
    streamoff offset = pos;
    CPPUNIT_ASSERT( offset >= chars_read );
    offset = s.rdbuf()->pubseekoff( -offset, ios_base::cur );
    CPPUNIT_ASSERT( offset == 0 );
 
    char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
 
    CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
    CPPUNIT_CHECK( b2[4] == '5' );
 
    pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
    CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
    CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
  }
 
#if !defined (STLPORT) || \
    (!defined (_STLP_NO_WCHAR_T) && defined (_STLP_USE_EXCEPTIONS))
  {
    // Test with a wariable encoding:
    locale loc;
    try
    {
      locale tmp(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".UTF8"));
      loc = tmp;
    }
    catch (const runtime_error&)
    {
      // Localization no supported so no test:
      return;
    }
 
    {
      wfstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
      CPPUNIT_ASSERT( s );
      s.imbue(loc);
      CPPUNIT_ASSERT( s );
 
      s << L"1234567890\n";
      CPPUNIT_ASSERT( s );
    }
 
    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' };
    wfstream s( "test_file.txt", ios_base::in | ios_base::out );
    CPPUNIT_ASSERT( s );
    s.imbue(loc);
    CPPUNIT_ASSERT( s );
 
    int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) / sizeof(wchar_t) );
    CPPUNIT_CHECK( chars_read == 11 );
    CPPUNIT_CHECK( b1[9] == L'0' );
 
    fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
    // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
    streamoff off = pos;
    CPPUNIT_ASSERT( off >= chars_read );
    off = s.rdbuf()->pubseekoff(-off, ios_base::cur);
    CPPUNIT_ASSERT( off == -1 );
    off = s.rdbuf()->pubseekoff(0, ios_base::beg);
    CPPUNIT_ASSERT( off == 0 );
 
    wchar_t b2[10] = { L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y' };
 
    CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
    CPPUNIT_CHECK( b2[4] == L'5' );
 
    pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
    CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
    //CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
  }
#endif
}

streambuf_output()

void FstreamTest::streambuf_output ( )

protected

Definition at line 508 of file fstream_test.cpp.

{
  {
    ofstream ofstr("test_file.txt", ios_base::binary);
    if (!ofstr)
      //No test if we cannot create the file
      return;
    ofstr << "01234567890123456789";
    CPPUNIT_ASSERT( ofstr );
  }
 
  {
    ifstream in("test_file.txt", ios_base::binary);
    CPPUNIT_ASSERT( in );
 
    full_streambuf full_buf(10);
    ostream out(&full_buf);
    CPPUNIT_ASSERT( out );
 
    out << in.rdbuf();
    CPPUNIT_ASSERT( out );
    CPPUNIT_ASSERT( in );
    CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
 
    out << in.rdbuf();
    CPPUNIT_ASSERT( out.fail() );
    CPPUNIT_ASSERT( in );
 
    ostringstream ostr;
    ostr << in.rdbuf();
    CPPUNIT_ASSERT( ostr );
    CPPUNIT_ASSERT( in );
    CPPUNIT_ASSERT( ostr.str() == "0123456789" );
  }
 
#  if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
  {
    //If the output stream buffer throws:
    ifstream in("test_file.txt", ios_base::binary);
    CPPUNIT_ASSERT( in );
 
    full_streambuf full_buf(10, true);
    ostream out(&full_buf);
    CPPUNIT_ASSERT( out );
 
    out << in.rdbuf();
    CPPUNIT_ASSERT( out.bad() );
    CPPUNIT_ASSERT( in );
    //out is bad we have no guaranty on what has been extracted:
    //CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
 
    out.clear();
    out << in.rdbuf();
    CPPUNIT_ASSERT( out.fail() && out.bad() );
    CPPUNIT_ASSERT( in );
 
    ostringstream ostr;
    ostr << in.rdbuf();
    CPPUNIT_ASSERT( ostr );
    CPPUNIT_ASSERT( in );
    CPPUNIT_ASSERT( ostr.str() == "0123456789" );
  }
#  endif
}

tellg()

void FstreamTest::tellg ( )

protected

Definition at line 210 of file fstream_test.cpp.

{
  {
    // bogus ios_base::binary is for Wins
    ofstream of("test_file.txt", ios_base::out | ios_base::binary | ios_base::trunc);
    CPPUNIT_ASSERT( of.is_open() );
 
    for (int i = 0; i < 50; ++i) {
      of << "line " << setiosflags(ios_base::right) << setfill('0') << setw(2) << i << "\n";
      CPPUNIT_ASSERT( !of.fail() );
    }
    of.close();
  }
 
  {
    // bogus ios_base::binary is for Wins
    ifstream is("test_file.txt", ios_base::in | ios_base::binary);
    CPPUNIT_ASSERT( is.is_open() );
    char buf[64];
 
    // CPPUNIT_ASSERT( is.tellg() == 0 );
    streampos p = 0;
    for (int i = 0; i < 50; ++i) {
      is.read(buf, 0);
      CPPUNIT_ASSERT( is.gcount() == 0 );
      CPPUNIT_ASSERT( is.tellg() == p );
      is.read( buf, 8 );
      CPPUNIT_ASSERT( !is.fail() );
      CPPUNIT_ASSERT( is.gcount() == 8 );
      p += 8;
    }
  }
 
  {
    // bogus ios_base::binary is for Wins
    ifstream is("test_file.txt", ios_base::in | ios_base::binary);
    CPPUNIT_ASSERT( is.is_open() );
 
    streampos p = 0;
    for (int i = 0; i < 50; ++i) {
      CPPUNIT_ASSERT( !is.fail() );
      is.tellg();
      CPPUNIT_ASSERT( is.tellg() == p );
      p += 8;
      is.seekg( p, ios_base::beg  );
      CPPUNIT_ASSERT( !is.fail() );
    }
  }
 
  {
    // bogus ios_base::binary is for Wins
    ifstream is("test_file.txt", ios_base::in | ios_base::binary);
    CPPUNIT_ASSERT( is.is_open() );
 
    streampos p = 0;
    for (int i = 0; i < 50; ++i) {
      CPPUNIT_ASSERT( is.tellg() == p );
      p += 8;
      is.seekg( 8, ios_base::cur );
      CPPUNIT_ASSERT( !is.fail() );
    }
  }
}

tellp()

void FstreamTest::tellp ( )

protected

Definition at line 274 of file fstream_test.cpp.

{
  {
    ofstream o( "test_file.txt" );
 
    o << "123456";
 
    CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(6) );
    CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(6) );
  }
  {
    ofstream o( "test_file.txt" );
 
    o << "123456789";
 
    CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(9) );
    CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(9) );
  }
  /* According to the standard
     ofstream o( "test_file.txt", ios_base::app | ios_base::out )
     should give the same effect as fopen( "test_file.txt", "a" ).
     Problem is fopen( "test_file.txt", "a" ) has a bit different behaviour
     on different platforms, and this difference is not covered by specification.
     After fopen( "test_file.txt", "a" ) in this context ftell( f ) == 9 for
     Linux and Mac OS X (I expect the same for others POSIX-like platforms too);
     on Windows (independently from version?) ftell( f ) == 0, i.e. write pointer not
     shifted to EOF (but shifted to EOF just before write, as described in the specs).
 
     It isn't specifications violation, neither for Linux and Mac OS X nor for Windows.
 
     The code below is intended to demonstrate ambiguity (dependance from fopen implementation).
   */
  {
    #ifdef WIN32
    //In Windows, stlport and fopen use kernel32.CreateFile for open.
    //File position is at BOF after open, unless we open with ios_base::ate
    long expected_pos = 0;
    #else
    //On UNIX flavours, stlport and fopen use unix's open
    //File position is at EOF after open
    //
    //3rd possible scenario, "other platforms" - _STLP_USE_STDIO_IO
    //stlport uses fopen here. This case may fail this test, since the file position after
    //fopen is implementation-dependent
    long expected_pos = 9;
    #endif
    ofstream o( "test_file.txt", ios_base::app | ios_base::out );
    CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(expected_pos) );
    CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(expected_pos) );
  }
  { // for reference, to test fopen/ftell behaviour in append mode:
    #ifdef WIN32
    long expected_pos = 0;
    #else
    long expected_pos = 9;
    #endif
    FILE* f = fopen( "test_file.txt", "a" );
    CPPUNIT_CHECK( ftell( f ) == expected_pos );
    fclose( f );
  }
  {
    //In append mode, file is positioned at EOF just before a write.
    // After a write, file is at EOF. This is implementation-independent.
    ofstream o( "test_file.txt", ios_base::app | ios_base::out );
    o << "X";
    CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(10) );
    CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(10) );
  }
}

win32_file_format()

void FstreamTest::win32_file_format ( )

protected

Definition at line 573 of file fstream_test.cpp.

{
  const char* file_name = "win32_file_format.tmp";
  const size_t nb_lines = 2049;
  {
    ofstream out(file_name);
    CPPUNIT_ASSERT( out.good() );
    out << 'a';
    for (size_t i = 0; i < nb_lines - 1; ++i) {
      out << '\n';
    }
    out << '\r';
    CPPUNIT_ASSERT( out.good() );
  }
  {
    ifstream in(file_name);
    CPPUNIT_ASSERT( in.good() );
    string line, last_line;
    size_t nb_read_lines = 0;
    while (getline(in, line)) {
      ++nb_read_lines;
      last_line = line;
    }
    CPPUNIT_ASSERT( in.eof() );
    CPPUNIT_ASSERT( nb_read_lines == nb_lines );
    CPPUNIT_ASSERT( !last_line.empty() && (last_line[0] == '\r') );
  }
}

Member Data Documentation

CPPUNIT_IGNORE

FstreamTest::CPPUNIT_IGNORE

private

Definition at line 62 of file fstream_test.cpp.

---

The documentation for this class was generated from the following file:

• sdk/lib/3rdparty/stlport/test/unit/fstream_test.cpp