tests/streams/bstream.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/streams/bstream.h
   3 // Purpose:     Template class for testing base stream functions.
   4 // Author:      Hans Van Leemputten
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Hans Van Leemputten
   7 // Licence:     wxWindows licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 #ifndef _WX_TESTBSTREAM_H__
  11 #define _WX_TESTBSTREAM_H__
  12
  13 #include "wx/cppunit.h"
  14
  15 ///////////////////////////////////////////////////////////////////////////////
  16 // Some macros preventing us from typing too much ;-)
  17 //
  18
  19 #define STREAM_TEST_NAME "Streams"
  20 #define COMPOSE_TEST_NAME(Name) \
  21     STREAM_TEST_NAME "." #Name
  22 #define STREAM_REGISTER_SUB_SUITE(Name) \
  23     extern CppUnit::Test* Get##Name##Suite(); \
  24     suite->addTest(Get##Name##Suite())
  25 #define STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE(Name) \
  26     CppUnit::Test* Get##Name##Suite() { return Name::suite(); }
  27 #define STREAM_TEST_SUBSUITE_NAMED_REGISTRATION(Name) \
  28     CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Name, COMPOSE_TEST_NAME(Name) ); \
  29     STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE( Name )
  30
  31 ///////////////////////////////////////////////////////////////////////////////
  32 // Template class that implements a test for all base stream functions.
  33 //
  34
  35 template <class TStreamIn, class TStreamOut> class BaseStreamTestCase : public CppUnit::TestCase
  36 {
  37 protected:
  38     typedef BaseStreamTestCase<TStreamIn, TStreamOut> StreamTestCase;
  39
  40     class CleanupHelper
  41     {
  42     public:
  43         CleanupHelper(StreamTestCase *value)
  44             :m_pCleanup(value)
  45         {}
  46         ~CleanupHelper()
  47         {
  48             m_pCleanup->DeleteInStream();
  49             m_pCleanup->DeleteOutStream();
  50         }
  51     private:
  52         StreamTestCase   *m_pCleanup;
  53     };
  54     friend class CleanupHelper;
  55
  56 public:
  57     BaseStreamTestCase()
  58         :m_bSimpleTellITest(false),
  59          m_bSimpleTellOTest(false),
  60          m_bSeekInvalidBeyondEnd(true),
  61          m_bEofAtLastRead(true),
  62          m_pCurrentIn(NULL),
  63          m_pCurrentOut(NULL)
  64     { /* Nothing extra */ }
  65     virtual ~BaseStreamTestCase()
  66     {
  67         // Prevent mem leaks!
  68         delete m_pCurrentIn;
  69         delete m_pCurrentOut;
  70     }
  71
  72 protected:
  73     /*
  74      * Input stream tests.
  75      */
  76
  77     // Just try to perform a GetSize() on the input stream.
  78     void Input_GetSize()
  79     {
  80         CleanupHelper cleanup(this);
  81         const TStreamIn &stream_in = CreateInStream();
  82         CPPUNIT_ASSERT(!stream_in.Eof());
  83
  84         // Size should be greater then zero.
  85         // Note: streams not supporting this should register this test
  86         //       with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST.
  87         CPPUNIT_ASSERT(stream_in.GetSize() != 0);
  88     }
  89
  90     // Just try to perform a GetC() on the input stream.
  91     void Input_GetC()
  92     {
  93         CleanupHelper cleanup(this);
  94         TStreamIn &stream_in = CreateInStream();
  95         CPPUNIT_ASSERT(!stream_in.Eof());
  96
  97         // If no exception occurs the test is successful.
  98         (void)stream_in.GetC();
  99     }
 100
 101     // Just try to perform a Read() on the input stream.
 102     void Input_Read()
 103     {
 104         CleanupHelper cleanup(this);
 105         TStreamIn &stream_in = CreateInStream();
 106         CPPUNIT_ASSERT(!stream_in.Eof());
 107
 108         // Note: the input stream should at least be of min size +10!
 109
 110         char buf[10];
 111         (void)stream_in.Read(buf, 10);
 112
 113         CPPUNIT_ASSERT(!stream_in.Eof());
 114         CPPUNIT_ASSERT(stream_in.IsOk());
 115
 116         // Test the stream version aswell.
 117         TStreamOut &stream_out = CreateOutStream();
 118         (void)stream_in.Read(stream_out);
 119
 120         // The output stream should have read the input stream till the end.
 121         CPPUNIT_ASSERT(stream_in.Eof());
 122     }
 123
 124     // Test and see what happens to the EOF when we
 125     // read after EOF was encountered.
 126     void Input_Eof()
 127     {
 128         CleanupHelper cleanup(this);
 129         TStreamIn &stream_in = CreateInStream();
 130         CPPUNIT_ASSERT(!stream_in.Eof());
 131         // Double check to see if Eof it self doesn't changes the Eof status.
 132         CPPUNIT_ASSERT(!stream_in.Eof());
 133
 134         // Travel to the end of the stream.
 135         while(!stream_in.Eof())
 136         {
 137             CPPUNIT_ASSERT_MESSAGE( "unexpected non-EOF stream error",
 138                                     stream_in.IsOk() );
 139
 140             // Read, we move one byte along.
 141             (void)stream_in.GetC();
 142 #if 0
 143             // EOF behaviour is different in streams, disabled (for now?)
 144
 145             if (m_bEofAtLastRead)
 146                 // EOF should only occure after the last successful get.
 147                 CPPUNIT_ASSERT_MESSAGE("Eof is detected too late.", !(stream_in.LastRead() != 1 && stream_in.Eof()));
 148             else
 149                 // EOF should only occure after a failed get.
 150                 CPPUNIT_ASSERT_MESSAGE("Eof is detected too soon.", !(stream_in.LastRead() == 1 && stream_in.Eof()));
 151 #endif
 152         }
 153
 154         // Check EOF stream state.
 155         CPPUNIT_ASSERT_MESSAGE("EOF is not EOF?", stream_in.Eof());
 156
 157         // Ok we found the end, let's see if we can go past it.
 158         for (size_t i = 0; i < 100; i++)
 159             (void)stream_in.GetC();
 160
 161         // Check for EOF correctness.
 162         CPPUNIT_ASSERT_MESSAGE("EOF is wrong when we read past EOF!", stream_in.Eof());
 163         CPPUNIT_ASSERT_MESSAGE("Last error is not EOF while stream_in.Eof() is true", stream_in.GetLastError() == wxSTREAM_EOF);
 164     }
 165
 166     // Just try to perform a LastRead() on the input stream.
 167     void Input_LastRead()
 168     {
 169         CleanupHelper cleanup(this);
 170         TStreamIn &stream_in = CreateInStream();
 171         CPPUNIT_ASSERT(!stream_in.Eof());
 172
 173         char buf[5];
 174         (void)stream_in.Read(buf, 5);
 175         CPPUNIT_ASSERT_EQUAL(5, stream_in.LastRead());
 176         (void)stream_in.GetC();
 177         CPPUNIT_ASSERT_EQUAL(1, stream_in.LastRead());
 178     }
 179
 180     void Input_CanRead()
 181     {
 182         CleanupHelper cleanup(this);
 183         TStreamIn &stream_in = CreateInStream();
 184
 185         CPPUNIT_ASSERT( stream_in.CanRead() );
 186
 187         // read the entire contents
 188         (void)stream_in.Read(CreateOutStream());
 189
 190         CPPUNIT_ASSERT( !stream_in.CanRead() );
 191     }
 192
 193     // Just try to perform a SeekI() on the input stream.
 194     void Input_SeekI()
 195     {
 196         CleanupHelper cleanup(this);
 197         TStreamIn &stream_in = CreateInStream();
 198
 199         CPPUNIT_ASSERT( stream_in.IsSeekable() );
 200         CPPUNIT_ASSERT(!stream_in.Eof());
 201
 202         // Try to Seek in the stream...
 203         // Note: streams not supporting this should register this test
 204         //       with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST.
 205         CPPUNIT_ASSERT_EQUAL(2, stream_in.SeekI(2, wxFromStart));
 206         CPPUNIT_ASSERT_EQUAL(4, stream_in.SeekI(2, wxFromCurrent));
 207         // Not sure the following line is correct, so test it differently.
 208         //CPPUNIT_ASSERT_EQUAL(stream_in.GetSize()-2, stream_in.SeekI(-2, wxFromEnd));
 209         CPPUNIT_ASSERT(stream_in.SeekI(-2, wxFromEnd) != wxInvalidOffset);
 210         // Go beyond the stream size.
 211         CPPUNIT_ASSERT((stream_in.SeekI(10, wxFromCurrent) == wxInvalidOffset) == m_bSeekInvalidBeyondEnd);
 212     }
 213
 214     // Just try to perform a TellI() on the input stream.
 215     void Input_TellI()
 216     {
 217         CleanupHelper cleanup(this);
 218         TStreamIn &stream_in = CreateInStream();
 219
 220         CPPUNIT_ASSERT(!stream_in.Eof());
 221
 222         // Try to Get the location in the stream...
 223         CPPUNIT_ASSERT_EQUAL(0, stream_in.TellI());
 224         (void)stream_in.GetC();
 225         CPPUNIT_ASSERT_EQUAL(1, stream_in.TellI());
 226         if (!m_bSimpleTellITest)
 227         {
 228             wxFileOffset pos = stream_in.SeekI(5, wxFromStart);
 229             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 230             (void)stream_in.GetC();
 231             CPPUNIT_ASSERT_EQUAL(6, stream_in.TellI());
 232             pos = stream_in.SeekI(2, wxFromCurrent);
 233             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 234             pos = stream_in.SeekI(5, wxFromStart);
 235             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 236         }
 237     }
 238
 239     // Just try to perform a Peek() on the input stream.
 240     void Input_Peek()
 241     {
 242         CleanupHelper cleanup(this);
 243         TStreamIn &stream_in = CreateInStream();
 244
 245         // Test the full stream
 246         while (stream_in.IsOk())
 247         {
 248             char peekChar = stream_in.Peek();
 249             char getChar = stream_in.GetC();
 250             if (stream_in.LastRead() == 1)
 251                 CPPUNIT_ASSERT_EQUAL(getChar, peekChar);
 252         }
 253     }
 254
 255     // Just try to perform a Ungetch() on the input stream.
 256     void Input_Ungetch()
 257     {
 258         CleanupHelper cleanup(this);
 259         TStreamIn &stream_in = CreateInStream();
 260         CPPUNIT_ASSERT(!stream_in.Eof());
 261
 262         const char *ungetstr = "test";
 263         size_t ungetsize = stream_in.Ungetch(ungetstr, strlen(ungetstr) + 1);
 264         if (ungetsize != 0)
 265         {
 266             CPPUNIT_ASSERT_EQUAL(strlen(ungetstr) + 1, ungetsize);
 267             char buf[10];
 268             (void)stream_in.Read(buf, ungetsize);
 269             CPPUNIT_ASSERT(strcmp(buf, ungetstr) == 0);
 270         }
 271
 272         if (stream_in.Ungetch('a'))
 273         {
 274             CPPUNIT_ASSERT_EQUAL(int('a'), stream_in.GetC());
 275         }
 276     }
 277
 278     /*
 279      * Output stream tests.
 280      */
 281
 282     // Just try to perform a PutC() on the output stream.
 283     void Output_PutC()
 284     {
 285         CleanupHelper cleanup(this);
 286         TStreamOut &stream_out = CreateOutStream();
 287
 288         const char *buf = "Some text";
 289         const wxFileOffset len = strlen(buf);
 290         for ( int i = 0; i < len; i++ )
 291             stream_out.PutC(buf[i]);
 292
 293         if ( stream_out.IsSeekable() )
 294             CPPUNIT_ASSERT_EQUAL(len, stream_out.TellO());
 295     }
 296
 297     // Just try to perform a Write() on the output stream.
 298     void Output_Write()
 299     {
 300         CleanupHelper cleanup(this);
 301         TStreamOut &stream_out = CreateOutStream();
 302
 303         // Do the buffer version.
 304         const char *buf = "Some text";
 305         const wxFileOffset len = strlen(buf);
 306         (void)stream_out.Write(buf, len);
 307         if ( stream_out.IsSeekable() )
 308             CPPUNIT_ASSERT_EQUAL( len, stream_out.TellO() );
 309
 310         // Do the Stream version.
 311         TStreamIn &stream_in = CreateInStream();
 312         (void)stream_out.Write(stream_in);
 313
 314         if ( stream_out.IsSeekable() )
 315             CPPUNIT_ASSERT(stream_out.TellO() > len);
 316     }
 317
 318     // Just try to perform a LastWrite() on the output stream.
 319     void Output_LastWrite()
 320     {
 321         CleanupHelper cleanup(this);
 322         TStreamOut &stream_out = CreateOutStream();
 323
 324         const char *buf = "12345";
 325         (void)stream_out.Write(buf, 5);
 326         CPPUNIT_ASSERT_EQUAL(5, stream_out.LastWrite());
 327         (void)stream_out.PutC('1');
 328         CPPUNIT_ASSERT_EQUAL(1, stream_out.LastWrite());
 329     }
 330
 331     // Just try to perform a SeekO() on the output stream.
 332     void Output_SeekO()
 333     {
 334         CleanupHelper cleanup(this);
 335         TStreamOut &stream_out = CreateOutStream();
 336
 337         CPPUNIT_ASSERT( stream_out.IsSeekable() );
 338
 339         // First put some data in the stream, so it is not empty.
 340         const char *buf = "1234567890";
 341         (void)stream_out.Write(buf, 10);
 342
 343         // Try to Seek in the stream...
 344         // Note: streams not supporting this should register this test
 345         //       with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST.
 346         CPPUNIT_ASSERT_EQUAL(2, stream_out.SeekO(2, wxFromStart));
 347         CPPUNIT_ASSERT_EQUAL(4, stream_out.SeekO(2, wxFromCurrent));
 348         // Not sure the following line is correct, so test it differently.
 349         //CPPUNIT_ASSERT_EQUAL(stream_in.GetSize()-2, stream_out.SeekO(-2, wxFromEnd));
 350         CPPUNIT_ASSERT(stream_out.SeekO(-2, wxFromEnd) != wxInvalidOffset);
 351         // Go beyond the stream size.
 352         CPPUNIT_ASSERT((stream_out.SeekO(10, wxFromCurrent) == wxInvalidOffset) == m_bSeekInvalidBeyondEnd);
 353     }
 354
 355     // Just try to perform a TellO() on the output stream.
 356     void Output_TellO()
 357     {
 358         CleanupHelper cleanup(this);
 359         TStreamOut &stream_out = CreateOutStream();
 360
 361         // Try to Get the location in the stream...
 362         CPPUNIT_ASSERT_EQUAL(0, stream_out.TellO());
 363         (void)stream_out.PutC('1');
 364         CPPUNIT_ASSERT_EQUAL(1, stream_out.TellO());
 365         if (!m_bSimpleTellOTest)
 366         {
 367             // First put some extra data in the stream, so it's not empty.
 368             const char *buf = "1234567890";
 369             (void)stream_out.Write(buf, 10);
 370
 371             wxFileOffset pos = stream_out.SeekO(5, wxFromStart);
 372             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 373             (void)stream_out.PutC('1');
 374             CPPUNIT_ASSERT_EQUAL(6, stream_out.TellO());
 375             pos = stream_out.SeekO(2, wxFromCurrent);
 376             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 377             pos = stream_out.SeekO(5, wxFromStart);
 378             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 379         }
 380     }
 381
 382 protected:
 383     // Some tests can be configured... here you can find the config settings
 384     bool m_bSimpleTellITest;    // if true, no SeekI will be used by the TellI test.
 385                                 // Default false.
 386     bool m_bSimpleTellOTest;    // if true, no SeekO will be used by the TellI test.
 387                                 // Default false.
 388     bool m_bSeekInvalidBeyondEnd; // if true a SeekI|O beyond the end of the stream should return wxInvalidOffset
 389                                   // Default true.
 390     bool m_bEofAtLastRead;      // Does EOF occure at the moment the last byte is read or when read past the last byte.
 391                                 // Default true.
 392 protected:
 393     TStreamIn &CreateInStream()
 394     {
 395         if (m_pCurrentIn)
 396         {
 397             wxFAIL_MSG(wxT("Error in test case, the previouse input stream needs to be delete first!"));
 398         }
 399
 400         m_pCurrentIn = DoCreateInStream();
 401         wxASSERT(m_pCurrentIn != NULL);
 402         return *m_pCurrentIn;
 403     }
 404     TStreamOut &CreateOutStream()
 405     {
 406         if (m_pCurrentOut)
 407         {
 408             wxFAIL_MSG(wxT("Error in test case, the previouse output stream needs to be delete first!"));
 409         }
 410
 411         m_pCurrentOut = DoCreateOutStream();
 412         wxASSERT(m_pCurrentOut != NULL);
 413         return *m_pCurrentOut;
 414     }
 415
 416     void DeleteInStream()
 417     {
 418         if (m_pCurrentIn == NULL)
 419             return;
 420         delete m_pCurrentIn;
 421         m_pCurrentIn = NULL;
 422         // Incase something extra needs to be done.
 423         DoDeleteInStream();
 424     }
 425     void DeleteOutStream()
 426     {
 427         if (m_pCurrentOut == NULL)
 428             return;
 429
 430         CPPUNIT_ASSERT(m_pCurrentOut->Close());
 431
 432         delete m_pCurrentOut;
 433         m_pCurrentOut = NULL;
 434         // Incase something extra needs to be done.
 435         DoDeleteOutStream();
 436     }
 437
 438 protected:
 439     // Items that need to be implemented by a derived class!
 440     virtual TStreamIn  *DoCreateInStream() = 0;
 441     virtual TStreamOut *DoCreateOutStream() = 0;
 442     virtual void DoDeleteInStream()  { /* Depends on the base class */ }
 443     virtual void DoDeleteOutStream() { /* Depends on the base class */ }
 444
 445 private:
 446     TStreamIn  *m_pCurrentIn;
 447     TStreamOut *m_pCurrentOut;
 448 };
 449
 450 #endif
 451
 452