tests/streams/stdstream.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/streams/stdstream.cpp
   3 // Purpose:     Test wxStdInputStreamBuffer/wxStdOutputStreamBuffer
   4 // Author:      Jonathan Liu <net147@gmail.com>
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2009 Jonathan Liu
   7 // Licence:     wxWidgets licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx/wx.h".
  11 // and "wx/cppunit.h"
  12 #include "testprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 // for all others, include the necessary headers
  19 #ifndef WX_PRECOMP
  20     #include "wx/wx.h"
  21 #endif
  22
  23 #if wxUSE_STD_IOSTREAM
  24
  25 #include "wx/stdstream.h"
  26
  27 #include <string.h>
  28 #include "wx/mstream.h"
  29
  30 // when std::streamoff is simply long we don't need this as we already allow
  31 // comparisons between int and long but we do need it otherwise -- and we don't
  32 // have any way to detect it so for now just assume that all 64 bit Unix builds
  33 // use long as streamoff and if this is wrong we'll add a check to configure
  34 // later
  35 #ifndef __WXMSW__
  36     #if SIZEOF_SIZE_T != 8
  37         WX_CPPUNIT_ALLOW_EQUALS_TO_INT(std::streamoff)
  38     #endif
  39 #endif
  40
  41 // ==========================================================================
  42 // Definitions
  43 // ==========================================================================
  44
  45 const int TEST_SIZE = 384;
  46
  47 // ==========================================================================
  48 // Test class
  49 // ==========================================================================
  50
  51 class StdStreamTestCase : public CppUnit::TestCase
  52 {
  53 public:
  54     StdStreamTestCase();
  55
  56 private:
  57     CPPUNIT_TEST_SUITE( StdStreamTestCase );
  58         // Input buffer management and positioning
  59         CPPUNIT_TEST( InputBuffer_pubsetbuf );
  60         CPPUNIT_TEST( InputBuffer_pubseekoff );
  61         CPPUNIT_TEST( InputBuffer_pubseekpos );
  62         CPPUNIT_TEST( InputBuffer_pubsync );
  63
  64         // Input functions
  65         CPPUNIT_TEST( InputBuffer_in_avail );
  66         CPPUNIT_TEST( InputBuffer_snextc );
  67         CPPUNIT_TEST( InputBuffer_sbumpc );
  68         CPPUNIT_TEST( InputBuffer_sgetc );
  69         CPPUNIT_TEST( InputBuffer_sgetn );
  70         CPPUNIT_TEST( InputBuffer_sputbackc );
  71         CPPUNIT_TEST( InputBuffer_sungetc );
  72
  73         // Output buffer management and positioning
  74         CPPUNIT_TEST( OutputBuffer_pubsetbuf );
  75         CPPUNIT_TEST( OutputBuffer_pubseekoff );
  76         CPPUNIT_TEST( OutputBuffer_pubseekpos );
  77         CPPUNIT_TEST( OutputBuffer_pubsync );
  78
  79         // Output functions
  80         CPPUNIT_TEST( OutputBuffer_sputc );
  81         CPPUNIT_TEST( OutputBuffer_sputn );
  82     CPPUNIT_TEST_SUITE_END();
  83
  84     // Input buffer management and positioning
  85     void InputBuffer_pubsetbuf();
  86     void InputBuffer_pubseekoff();
  87     void InputBuffer_pubseekpos();
  88     void InputBuffer_pubsync();
  89
  90     // Input functions
  91     void InputBuffer_in_avail();
  92     void InputBuffer_snextc();
  93     void InputBuffer_sbumpc();
  94     void InputBuffer_sgetc();
  95     void InputBuffer_sgetn();
  96     void InputBuffer_sputbackc();
  97     void InputBuffer_sungetc();
  98
  99     // Output buffer management and positioning
 100     void OutputBuffer_pubsetbuf();
 101     void OutputBuffer_pubseekoff();
 102     void OutputBuffer_pubseekpos();
 103     void OutputBuffer_pubsync();
 104
 105     // Output functions
 106     void OutputBuffer_sputc();
 107     void OutputBuffer_sputn();
 108
 109     char m_testData[TEST_SIZE];
 110
 111     DECLARE_NO_COPY_CLASS(StdStreamTestCase)
 112 };
 113
 114 // register in the unnamed registry so that these tests are run by default
 115 CPPUNIT_TEST_SUITE_REGISTRATION( StdStreamTestCase );
 116
 117 // also include in it's own registry so that these tests can be run alone
 118 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( StdStreamTestCase,
 119                                        "StdStreamTestCase" );
 120
 121 // ==========================================================================
 122 // Implementation
 123 // ==========================================================================
 124
 125 StdStreamTestCase::StdStreamTestCase()
 126 {
 127     for (int i = 0; i < TEST_SIZE; ++i)
 128         m_testData[i] = (i & 0xFF);
 129 }
 130
 131 // --------------------------------------------------------------------------
 132 // Input buffer management and positioning
 133 // --------------------------------------------------------------------------
 134
 135 void StdStreamTestCase::InputBuffer_pubsetbuf()
 136 {
 137     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 138     wxStdInputStreamBuffer buffer(stream);
 139     char testBuffer[TEST_SIZE];
 140
 141     CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
 142 }
 143
 144 void StdStreamTestCase::InputBuffer_pubseekoff()
 145 {
 146     const char *testData = "0123456789";
 147     wxMemoryInputStream stream(testData, 10);
 148     wxStdInputStreamBuffer buffer(stream);
 149
 150     CPPUNIT_ASSERT_EQUAL(2,
 151                          buffer.pubseekoff(2, std::ios_base::beg,
 152                                            std::ios_base::in));
 153     CPPUNIT_ASSERT_EQUAL(-1,
 154                          buffer.pubseekoff(2, std::ios_base::beg,
 155                                            std::ios_base::out));
 156
 157     CPPUNIT_ASSERT_EQUAL(4,
 158                          buffer.pubseekoff(2, std::ios_base::cur));
 159     CPPUNIT_ASSERT_EQUAL(-1,
 160                          buffer.pubseekoff(2, std::ios_base::cur,
 161                                            std::ios_base::out));
 162
 163     CPPUNIT_ASSERT_EQUAL(8,
 164                          buffer.pubseekoff(-2, std::ios_base::end));
 165     CPPUNIT_ASSERT_EQUAL(-1,
 166                          buffer.pubseekoff(-2, std::ios_base::end,
 167                                            std::ios_base::out));
 168
 169     CPPUNIT_ASSERT_EQUAL(-1,
 170                          buffer.pubseekoff(3, std::ios_base::cur));
 171     CPPUNIT_ASSERT_EQUAL(-1,
 172                          buffer.pubseekoff(3, std::ios_base::cur,
 173                                            std::ios_base::out));
 174 }
 175
 176 void StdStreamTestCase::InputBuffer_pubseekpos()
 177 {
 178     const char *testData = "0123456789";
 179     wxMemoryInputStream stream(testData, 10);
 180     wxStdInputStreamBuffer buffer(stream);
 181
 182     for (int i = 9; i >= 0; --i)
 183     {
 184         if (i % 2 == 0)
 185             CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
 186         else
 187             CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i, std::ios_base::in));
 188
 189         CPPUNIT_ASSERT_EQUAL('0' + i, buffer.sgetc());
 190     }
 191 }
 192
 193 void StdStreamTestCase::InputBuffer_pubsync()
 194 {
 195     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 196     wxStdInputStreamBuffer buffer(stream);
 197
 198     CPPUNIT_ASSERT(buffer.pubsync() == 0);
 199 }
 200
 201 // --------------------------------------------------------------------------
 202 // Input functions
 203 // --------------------------------------------------------------------------
 204
 205 void StdStreamTestCase::InputBuffer_in_avail()
 206 {
 207     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 208     wxStdInputStreamBuffer buffer(stream);
 209
 210     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 211     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 212
 213     char data[TEST_SIZE / 2];
 214
 215     buffer.sgetn(data, TEST_SIZE / 2);
 216     CPPUNIT_ASSERT_EQUAL(TEST_SIZE - TEST_SIZE / 2, buffer.in_avail());
 217 }
 218
 219 void StdStreamTestCase::InputBuffer_snextc()
 220 {
 221     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 222     wxStdInputStreamBuffer buffer(stream);
 223
 224     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 225     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 226
 227     char data[TEST_SIZE];
 228
 229     data[0] = buffer.sgetc();
 230
 231     for (int i = 1; i < TEST_SIZE; ++i)
 232         data[i] = buffer.snextc();
 233
 234     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 235     CPPUNIT_ASSERT_EQUAL((int)(unsigned char) (m_testData[TEST_SIZE - 1]),
 236                          buffer.sbumpc());
 237     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 238 }
 239
 240 void StdStreamTestCase::InputBuffer_sbumpc()
 241 {
 242     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 243     wxStdInputStreamBuffer buffer(stream);
 244
 245     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 246     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 247
 248     char data[TEST_SIZE];
 249
 250     for (int i = 0; i < TEST_SIZE; ++i)
 251         data[i] = buffer.sbumpc();
 252
 253     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 254     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 255 }
 256
 257 void StdStreamTestCase::InputBuffer_sgetc()
 258 {
 259     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 260     wxStdInputStreamBuffer buffer(stream);
 261
 262     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 263     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 264
 265     char data[TEST_SIZE];
 266
 267     for (int i = 0; i < TEST_SIZE; ++i) {
 268         data[i] = buffer.sgetc();
 269         buffer.sbumpc();
 270     }
 271
 272     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 273     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 274 }
 275
 276 void StdStreamTestCase::InputBuffer_sgetn()
 277 {
 278     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 279     wxStdInputStreamBuffer buffer(stream);
 280
 281     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 282     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 283
 284     char data[TEST_SIZE * 2];
 285     std::streamsize read = buffer.sgetn(data, TEST_SIZE * 2);
 286
 287     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
 288     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 289     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 290 }
 291
 292 void StdStreamTestCase::InputBuffer_sputbackc()
 293 {
 294     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 295     wxStdInputStreamBuffer buffer(stream);
 296
 297     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 298     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 299
 300     char data[TEST_SIZE];
 301     std::streamsize read = buffer.sgetn(data, TEST_SIZE);
 302
 303     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
 304     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 305     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 306
 307     char putBackChar = m_testData[TEST_SIZE - 1] + 147;
 308
 309     CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sputbackc(putBackChar));
 310     CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sgetc());
 311     CPPUNIT_ASSERT_EQUAL((int) putBackChar, buffer.sbumpc());
 312     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 313 }
 314
 315 void StdStreamTestCase::InputBuffer_sungetc()
 316 {
 317     wxMemoryInputStream stream(m_testData, TEST_SIZE);
 318     wxStdInputStreamBuffer buffer(stream);
 319
 320     CPPUNIT_ASSERT(buffer.sgetc() != EOF);
 321     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, buffer.in_avail());
 322
 323     char data[TEST_SIZE];
 324     std::streamsize read = buffer.sgetn(data, TEST_SIZE);
 325
 326     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, read);
 327     CPPUNIT_ASSERT(memcmp(data, m_testData, TEST_SIZE) == 0);
 328     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 329
 330     CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sungetc());
 331     CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sgetc());
 332     CPPUNIT_ASSERT_EQUAL((int) m_testData[TEST_SIZE - 1], buffer.sbumpc());
 333     CPPUNIT_ASSERT(buffer.sgetc() == EOF);
 334 }
 335
 336 // --------------------------------------------------------------------------
 337 // Output buffer management and positioning
 338 // --------------------------------------------------------------------------
 339
 340 void StdStreamTestCase::OutputBuffer_pubsetbuf()
 341 {
 342     wxMemoryOutputStream stream;
 343     wxStdOutputStreamBuffer buffer(stream);
 344     char testBuffer[TEST_SIZE];
 345
 346     CPPUNIT_ASSERT(buffer.pubsetbuf(testBuffer, TEST_SIZE) == NULL);
 347 }
 348
 349 void StdStreamTestCase::OutputBuffer_pubseekoff()
 350 {
 351     char testData[] = "0123456789";
 352     wxMemoryOutputStream stream(testData, 10);
 353     wxStdOutputStreamBuffer buffer(stream);
 354
 355     CPPUNIT_ASSERT_EQUAL(2,
 356                          buffer.pubseekoff(2, std::ios_base::beg,
 357                                            std::ios_base::out));
 358     CPPUNIT_ASSERT_EQUAL(-1,
 359                          buffer.pubseekoff(2, std::ios_base::beg,
 360                                            std::ios_base::in));
 361
 362     CPPUNIT_ASSERT_EQUAL(4,
 363                          buffer.pubseekoff(2, std::ios_base::cur));
 364     CPPUNIT_ASSERT_EQUAL(-1,
 365                          buffer.pubseekoff(2, std::ios_base::cur,
 366                                            std::ios_base::in));
 367
 368     CPPUNIT_ASSERT_EQUAL(8,
 369                          buffer.pubseekoff(-2, std::ios_base::end));
 370     CPPUNIT_ASSERT_EQUAL(-1,
 371                          buffer.pubseekoff(-2, std::ios_base::end,
 372                                            std::ios_base::in));
 373
 374     CPPUNIT_ASSERT_EQUAL(-1,
 375                          buffer.pubseekoff(3, std::ios_base::cur));
 376     CPPUNIT_ASSERT_EQUAL(-1,
 377                          buffer.pubseekoff(3, std::ios_base::cur,
 378                                            std::ios_base::in));
 379 }
 380
 381 void StdStreamTestCase::OutputBuffer_pubseekpos()
 382 {
 383     char testData[] = "0123456789";
 384     wxMemoryOutputStream stream(testData, 10);
 385     wxStdOutputStreamBuffer buffer(stream);
 386
 387     for (int i = 9; i >= 0; --i)
 388     {
 389         if (i % 2 == 0)
 390         {
 391             CPPUNIT_ASSERT_EQUAL(i, buffer.pubseekpos(i));
 392         }
 393         else
 394         {
 395             CPPUNIT_ASSERT_EQUAL(i,
 396                                  buffer.pubseekpos(i, std::ios_base::out));
 397         }
 398
 399         CPPUNIT_ASSERT_EQUAL('0' + (9 - i), buffer.sputc('0' + (9 - i)));
 400     }
 401
 402     CPPUNIT_ASSERT(memcmp(testData, "9876543210", 10) == 0);
 403
 404     CPPUNIT_ASSERT_EQUAL(-1, buffer.pubseekpos(5, std::ios_base::in));
 405 }
 406
 407 void StdStreamTestCase::OutputBuffer_pubsync()
 408 {
 409     wxMemoryOutputStream stream;
 410     wxStdOutputStreamBuffer buffer(stream);
 411
 412     CPPUNIT_ASSERT(buffer.pubsync() == 0);
 413 }
 414
 415 // --------------------------------------------------------------------------
 416 // Output functions
 417 // --------------------------------------------------------------------------
 418
 419 void StdStreamTestCase::OutputBuffer_sputc()
 420 {
 421     wxMemoryOutputStream stream;
 422     wxStdOutputStreamBuffer buffer(stream);
 423
 424     for (int i = 0; i < TEST_SIZE; ++i)
 425         buffer.sputc(m_testData[i]);
 426
 427     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());
 428
 429     char result[TEST_SIZE];
 430
 431     stream.CopyTo(result, TEST_SIZE);
 432     CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
 433 }
 434
 435 void StdStreamTestCase::OutputBuffer_sputn()
 436 {
 437     wxMemoryOutputStream stream;
 438     wxStdOutputStreamBuffer buffer(stream);
 439
 440     buffer.sputn(m_testData, TEST_SIZE);
 441     CPPUNIT_ASSERT_EQUAL(TEST_SIZE, stream.GetSize());
 442
 443     char result[TEST_SIZE];
 444
 445     stream.CopyTo(result, TEST_SIZE);
 446     CPPUNIT_ASSERT(memcmp(result, m_testData, TEST_SIZE) == 0);
 447 }
 448
 449 #endif // wxUSE_STD_IOSTREAM