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