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