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:     wxWidgets 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, lets 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         // this test shouldn't be used at all if the stream isn't seekable
 221         CPPUNIT_ASSERT( stream_in.IsSeekable() );
 222
 223         CPPUNIT_ASSERT(!stream_in.Eof());
 224
 225         // Try to Get the location in the stream...
 226         CPPUNIT_ASSERT_EQUAL(0, stream_in.TellI());
 227         (void)stream_in.GetC();
 228         CPPUNIT_ASSERT_EQUAL(1, stream_in.TellI());
 229         if (!m_bSimpleTellITest)
 230         {
 231             wxFileOffset pos = stream_in.SeekI(5, wxFromStart);
 232             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 233             (void)stream_in.GetC();
 234             CPPUNIT_ASSERT_EQUAL(6, stream_in.TellI());
 235             pos = stream_in.SeekI(2, wxFromCurrent);
 236             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 237             pos = stream_in.SeekI(5, wxFromStart);
 238             CPPUNIT_ASSERT_EQUAL(pos, stream_in.TellI());
 239         }
 240     }
 241
 242     // Just try to perform a Peek() on the input stream.
 243     void Input_Peek()
 244     {
 245         CleanupHelper cleanup(this);
 246         TStreamIn &stream_in = CreateInStream();
 247
 248         // Test the full stream
 249         while (stream_in.IsOk())
 250         {
 251             char peekChar = stream_in.Peek();
 252             char getChar = stream_in.GetC();
 253             if (stream_in.LastRead() == 1)
 254                 CPPUNIT_ASSERT_EQUAL(getChar, peekChar);
 255         }
 256     }
 257
 258     // Just try to perform a Ungetch() on the input stream.
 259     void Input_Ungetch()
 260     {
 261         CleanupHelper cleanup(this);
 262         TStreamIn &stream_in = CreateInStream();
 263         CPPUNIT_ASSERT(!stream_in.Eof());
 264
 265         const char *ungetstr = "test";
 266         size_t ungetsize = stream_in.Ungetch(ungetstr, strlen(ungetstr) + 1);
 267         if (ungetsize != 0)
 268         {
 269             CPPUNIT_ASSERT_EQUAL(strlen(ungetstr) + 1, ungetsize);
 270             char buf[10];
 271             (void)stream_in.Read(buf, ungetsize);
 272             CPPUNIT_ASSERT(strcmp(buf, ungetstr) == 0);
 273         }
 274
 275         if (stream_in.Ungetch('a'))
 276         {
 277             CPPUNIT_ASSERT_EQUAL(int('a'), stream_in.GetC());
 278         }
 279     }
 280
 281     /*
 282      * Output stream tests.
 283      */
 284
 285     // Just try to perform a PutC() on the output stream.
 286     void Output_PutC()
 287     {
 288         CleanupHelper cleanup(this);
 289         TStreamOut &stream_out = CreateOutStream();
 290
 291         const char *buf = "Some text";
 292         const wxFileOffset len = strlen(buf);
 293         for ( int i = 0; i < len; i++ )
 294             stream_out.PutC(buf[i]);
 295
 296         if ( stream_out.IsSeekable() )
 297             CPPUNIT_ASSERT_EQUAL(len, stream_out.TellO());
 298     }
 299
 300     // Just try to perform a Write() on the output stream.
 301     void Output_Write()
 302     {
 303         CleanupHelper cleanup(this);
 304         TStreamOut &stream_out = CreateOutStream();
 305
 306         // Do the buffer version.
 307         const char *buf = "Some text";
 308         const wxFileOffset len = strlen(buf);
 309         (void)stream_out.Write(buf, len);
 310         if ( stream_out.IsSeekable() )
 311             CPPUNIT_ASSERT_EQUAL( len, stream_out.TellO() );
 312
 313         // Do the Stream version.
 314         TStreamIn &stream_in = CreateInStream();
 315         (void)stream_out.Write(stream_in);
 316
 317         if ( stream_out.IsSeekable() )
 318             CPPUNIT_ASSERT(stream_out.TellO() > len);
 319     }
 320
 321     // Just try to perform a LastWrite() on the output stream.
 322     void Output_LastWrite()
 323     {
 324         CleanupHelper cleanup(this);
 325         TStreamOut &stream_out = CreateOutStream();
 326
 327         const char *buf = "12345";
 328         (void)stream_out.Write(buf, 5);
 329         CPPUNIT_ASSERT_EQUAL(5, stream_out.LastWrite());
 330         (void)stream_out.PutC('1');
 331         CPPUNIT_ASSERT_EQUAL(1, stream_out.LastWrite());
 332     }
 333
 334     // Just try to perform a SeekO() on the output stream.
 335     void Output_SeekO()
 336     {
 337         CleanupHelper cleanup(this);
 338         TStreamOut &stream_out = CreateOutStream();
 339
 340         CPPUNIT_ASSERT( stream_out.IsSeekable() );
 341
 342         // First put some data in the stream, so it is not empty.
 343         const char *buf = "1234567890";
 344         (void)stream_out.Write(buf, 10);
 345
 346         // Try to Seek in the stream...
 347         // Note: streams not supporting this should register this test
 348         //       with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST.
 349         CPPUNIT_ASSERT_EQUAL(2, stream_out.SeekO(2, wxFromStart));
 350         CPPUNIT_ASSERT_EQUAL(4, stream_out.SeekO(2, wxFromCurrent));
 351         // Not sure the following line is correct, so test it differently.
 352         //CPPUNIT_ASSERT_EQUAL(stream_in.GetSize()-2, stream_out.SeekO(-2, wxFromEnd));
 353         CPPUNIT_ASSERT(stream_out.SeekO(-2, wxFromEnd) != wxInvalidOffset);
 354         // Go beyond the stream size.
 355         CPPUNIT_ASSERT((stream_out.SeekO(10, wxFromCurrent) == wxInvalidOffset) == m_bSeekInvalidBeyondEnd);
 356     }
 357
 358     // Just try to perform a TellO() on the output stream.
 359     void Output_TellO()
 360     {
 361         CleanupHelper cleanup(this);
 362         TStreamOut &stream_out = CreateOutStream();
 363
 364         // If this test is used, the stream must be seekable
 365         CPPUNIT_ASSERT( stream_out.IsSeekable() );
 366
 367         // Try to Get the location in the stream...
 368         CPPUNIT_ASSERT_EQUAL(0, stream_out.TellO());
 369         (void)stream_out.PutC('1');
 370         CPPUNIT_ASSERT_EQUAL(1, stream_out.TellO());
 371         if (!m_bSimpleTellOTest)
 372         {
 373             // First put some extra data in the stream, so it's not empty.
 374             const char *buf = "1234567890";
 375             (void)stream_out.Write(buf, 10);
 376
 377             wxFileOffset pos = stream_out.SeekO(5, wxFromStart);
 378             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 379             (void)stream_out.PutC('1');
 380             CPPUNIT_ASSERT_EQUAL(6, stream_out.TellO());
 381             pos = stream_out.SeekO(2, wxFromCurrent);
 382             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 383             pos = stream_out.SeekO(5, wxFromStart);
 384             CPPUNIT_ASSERT_EQUAL(pos, stream_out.TellO());
 385         }
 386     }
 387
 388 protected:
 389     // Some tests can be configured... here you can find the config settings
 390     bool m_bSimpleTellITest;    // if true, no SeekI will be used by the TellI test.
 391                                 // Default false.
 392     bool m_bSimpleTellOTest;    // if true, no SeekO will be used by the TellI test.
 393                                 // Default false.
 394     bool m_bSeekInvalidBeyondEnd; // if true a SeekI|O beyond the end of the stream should return wxInvalidOffset
 395                                   // Default true.
 396     bool m_bEofAtLastRead;      // Does EOF occure at the moment the last byte is read or when read past the last byte.
 397                                 // Default true.
 398 protected:
 399     TStreamIn &CreateInStream()
 400     {
 401         if (m_pCurrentIn)
 402         {
 403             wxFAIL_MSG(wxT("Error in test case, the previouse input stream needs to be delete first!"));
 404         }
 405
 406         m_pCurrentIn = DoCreateInStream();
 407         wxASSERT(m_pCurrentIn != NULL);
 408         return *m_pCurrentIn;
 409     }
 410     TStreamOut &CreateOutStream()
 411     {
 412         if (m_pCurrentOut)
 413         {
 414             wxFAIL_MSG(wxT("Error in test case, the previouse output stream needs to be delete first!"));
 415         }
 416
 417         m_pCurrentOut = DoCreateOutStream();
 418         wxASSERT(m_pCurrentOut != NULL);
 419         return *m_pCurrentOut;
 420     }
 421
 422     void DeleteInStream()
 423     {
 424         if (m_pCurrentIn == NULL)
 425             return;
 426         delete m_pCurrentIn;
 427         m_pCurrentIn = NULL;
 428         // Incase something extra needs to be done.
 429         DoDeleteInStream();
 430     }
 431     void DeleteOutStream()
 432     {
 433         if (m_pCurrentOut == NULL)
 434             return;
 435
 436         CPPUNIT_ASSERT(m_pCurrentOut->Close());
 437
 438         delete m_pCurrentOut;
 439         m_pCurrentOut = NULL;
 440         // Incase something extra needs to be done.
 441         DoDeleteOutStream();
 442     }
 443
 444 protected:
 445     // Items that need to be implemented by a derived class!
 446     virtual TStreamIn  *DoCreateInStream() = 0;
 447     virtual TStreamOut *DoCreateOutStream() = 0;
 448     virtual void DoDeleteInStream()  { /* Depends on the base class */ }
 449     virtual void DoDeleteOutStream() { /* Depends on the base class */ }
 450
 451 private:
 452     TStreamIn  *m_pCurrentIn;
 453     TStreamOut *m_pCurrentOut;
 454 };
 455
 456 #endif
 457
 458