From e3f810a21b956aed08df9c1fb7e272acb34de690 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=A1clav=20Slav=C3=ADk?= Date: Thu, 1 Apr 2004 12:22:44 +0000 Subject: [PATCH] forgot to add header file git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@26541 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- tests/streams/bstream.h | 410 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 410 insertions(+) create mode 100644 tests/streams/bstream.h diff --git a/tests/streams/bstream.h b/tests/streams/bstream.h new file mode 100644 index 0000000000..7e8380ebb4 --- /dev/null +++ b/tests/streams/bstream.h @@ -0,0 +1,410 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: tests/streams/bstream.h +// Purpose: Template class for testing base stream functions. +// Author: Hans Van Leemputten +// RCS-ID: $Id$ +// Copyright: (c) 2004 Hans Van Leemputten +// Licence: wxWidgets licence +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_TESTBSTREAM_H__ +#define _WX_TESTBSTREAM_H__ + +#include "wx/cppunit.h" +using namespace CppUnit; + +/////////////////////////////////////////////////////////////////////////////// +// Some macros preventing use from typing too much ;-) +// + +#define STREAM_TEST_NAME "Streams" +#define STREAM_REGISTER_SUB_SUITE(Name) \ + extern Test* Get##Name##Suite(); \ + suite->addTest(Get##Name##Suite()) +#define STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE(Name) \ + Test* Get##Name##Suite() { return Name::suite(); } +#define STREAM_TEST_SUBSUITE_NAMED_REGISTRATION(Name) \ + CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( Name, STREAM_TEST_NAME "." #Name ); \ + STREAM_IMPLEMENT_SUB_REGISTRATION_ROUTINE( Name ) + + +/////////////////////////////////////////////////////////////////////////////// +// Template class that implements a test for all base stream functions. +// + +template class BaseStreamTestCase : public TestCase +{ +protected: + typedef BaseStreamTestCase StreamTestCase; + + class CleanupHelper + { + public: + CleanupHelper(StreamTestCase *value) + :m_pCleanup(value) + {} + ~CleanupHelper() + { + m_pCleanup->DeleteInStream(); + m_pCleanup->DeleteOutStream(); + } + private: + StreamTestCase *m_pCleanup; + }; + friend class CleanupHelper; + +public: + BaseStreamTestCase() + :m_bSimpleTellITest(false), + m_bSimpleTellOTest(false), + m_pCurrentIn(NULL), + m_pCurrentOut(NULL) + { /* Nothing extra */ } + virtual ~BaseStreamTestCase() + { + // Prevent mem leaks! + delete m_pCurrentIn; + delete m_pCurrentOut; + } + +protected: + /* + * Input stream tests. + */ + + // Just try to perform a GetSize() on the input stream. + void Input_GetSize() + { + CleanupHelper cleanup(this); + const TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + // Size should be greater then zero. + // Note: streams not supporting this should register this test + // with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST. + CPPUNIT_ASSERT(stream_in.GetSize() != 0); + } + + // Just try to perform a GetC() on the input stream. + void Input_GetC() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + // If no exception occurs the test is successful. + (void)stream_in.GetC(); + } + + // Just try to perform a Read() on the input stream. + void Input_Read() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + // Note: the input stream should at least be of min size +10! + + char buf[10]; + (void)stream_in.Read(buf, 10); + + CPPUNIT_ASSERT(!stream_in.Eof()); + CPPUNIT_ASSERT(stream_in.IsOk()); + + // Test the stream version aswell. + TStreamOut &stream_out = CreateOutStream(); + (void)stream_in.Read(stream_out); + + // The output stream should have read the input stream till the end. + CPPUNIT_ASSERT(stream_in.Eof()); + } + + // Test and see what happens to the EOF when we + // read after EOF was encountered. + void Input_Eof() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + // Double check to see if Eof it self doesn't changes the Eof status. + CPPUNIT_ASSERT(!stream_in.Eof()); + + // Travel to the end of the stream. + while(!stream_in.Eof()) + { + // Double check to see if normal Eof works. + CPPUNIT_ASSERT_MESSAGE("Eof() doesn't return true when IsOk returns false!", stream_in.IsOk()); + // Read, we move one byte along. + (void)stream_in.GetC(); + } + + // Ok we found the end, lets see if we can go past it. + for (size_t i = 0; i < 100; i++) + (void)stream_in.GetC(); + + // Check for EOF correctness. + CPPUNIT_ASSERT_MESSAGE("EOF is wrong when we read past EOF!", stream_in.Eof()); + } + + // Just try to perform a LastRead() on the input stream. + void Input_LastRead() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + char buf[5]; + (void)stream_in.Read(buf, 5); + CPPUNIT_ASSERT(stream_in.LastRead() == 5); + (void)stream_in.GetC(); + CPPUNIT_ASSERT(stream_in.LastRead() == 1); + } + + // Just try to perform a SeekI() on the input stream. + void Input_SeekI() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + // Try to Seek in the stream... + // Note: streams not supporting this should register this test + // with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST. + CPPUNIT_ASSERT(stream_in.SeekI(2, wxFromStart) == 2); + CPPUNIT_ASSERT(stream_in.SeekI(2, wxFromCurrent) == 4); + // Not sure the following line is correct, so test it differently. + //CPPUNIT_ASSERT(stream_in.SeekI(-2, wxFromEnd) == (off_t)stream_in.GetSize()-2); + CPPUNIT_ASSERT(stream_in.SeekI(-2, wxFromEnd) != wxInvalidOffset); + // Go beyond the stream size. + CPPUNIT_ASSERT(stream_in.SeekI(10, wxFromCurrent) == wxInvalidOffset); + } + + // Just try to perform a TellI() on the input stream. + void Input_TellI() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + // Try to Get the location in the stream... + CPPUNIT_ASSERT(stream_in.TellI() == 0); + (void)stream_in.GetC(); + CPPUNIT_ASSERT(stream_in.TellI() == 1); + if (!m_bSimpleTellITest) + { + off_t pos = stream_in.SeekI(5, wxFromStart); + CPPUNIT_ASSERT(stream_in.TellI() == pos); + (void)stream_in.GetC(); + CPPUNIT_ASSERT(stream_in.TellI() == 6); + pos = stream_in.SeekI(2, wxFromCurrent); + CPPUNIT_ASSERT(stream_in.TellI() == pos); + pos = stream_in.SeekI(5, wxFromStart); + CPPUNIT_ASSERT(stream_in.TellI() == pos); + } + } + + // Just try to perform a Peek() on the input stream. + void Input_Peek() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + + // Test the full stream + while(!stream_in.Eof()) + { + if (!stream_in.IsOk()) + break; + + char peekChar = stream_in.Peek(); + char getChar = stream_in.GetC(); + CPPUNIT_ASSERT(peekChar == getChar); + } + } + + // Just try to perform a Ungetch() on the input stream. + void Input_Ungetch() + { + CleanupHelper cleanup(this); + TStreamIn &stream_in = CreateInStream(); + CPPUNIT_ASSERT(!stream_in.Eof()); + + const char *ungetstr = "test"; + size_t ungetsize = stream_in.Ungetch(ungetstr, strlen(ungetstr) + 1); + if (ungetsize != 0) + { + CPPUNIT_ASSERT(ungetsize == strlen(ungetstr) + 1); + char buf[10]; + (void)stream_in.Read(buf, ungetsize); + CPPUNIT_ASSERT(strcmp(buf, ungetstr) == 0); + } + + if (stream_in.Ungetch('a')) + { + CPPUNIT_ASSERT(stream_in.GetC() == 'a'); + } + } + + /* + * Output stream tests. + */ + + // Just try to perform a PutC() on the output stream. + void Output_PutC() + { + CleanupHelper cleanup(this); + TStreamOut &stream_out = CreateOutStream(); + + char *buf = "Some text"; + off_t i; + off_t len = (off_t) strlen(buf); + for (i = 0; i < len; i++) + stream_out.PutC(buf[i]); + + CPPUNIT_ASSERT(i == stream_out.TellO()); + } + + // Just try to perform a Write() on the output stream. + void Output_Write() + { + CleanupHelper cleanup(this); + TStreamOut &stream_out = CreateOutStream(); + + // Do the buffer version. + char *buf = "Some text"; + off_t len = (off_t) strlen(buf); + (void)stream_out.Write(buf, len); + CPPUNIT_ASSERT(stream_out.TellO() == len); + + // Do the Stream version. + TStreamIn &stream_in = CreateInStream(); + (void)stream_out.Write(stream_in); + CPPUNIT_ASSERT(stream_out.TellO() > len); + } + + // Just try to perform a LastWrite() on the output stream. + void Output_LastWrite() + { + CleanupHelper cleanup(this); + TStreamOut &stream_out = CreateOutStream(); + + char *buf = "12345"; + (void)stream_out.Write(buf, 5); + CPPUNIT_ASSERT(stream_out.LastWrite() == 5); + (void)stream_out.PutC('1'); + CPPUNIT_ASSERT(stream_out.LastWrite() == 1); + } + + // Just try to perform a SeekO() on the output stream. + void Output_SeekO() + { + CleanupHelper cleanup(this); + TStreamOut &stream_out = CreateOutStream(); + + // First put some data in the stream, so it is not empty. + char *buf = "1234567890"; + (void)stream_out.Write(buf, 10); + + // Try to Seek in the stream... + // Note: streams not supporting this should register this test + // with CPPUNIT_TEST_FAIL instead of CPPUNIT_TEST. + CPPUNIT_ASSERT(stream_out.SeekO(2, wxFromStart) == 2); + CPPUNIT_ASSERT(stream_out.SeekO(2, wxFromCurrent) == 4); + // Not sure the following line is correct, so test it differently. + //CPPUNIT_ASSERT(stream_out.SeekO(-2, wxFromEnd) == (off_t)stream_in.GetSize()-2); + CPPUNIT_ASSERT(stream_out.SeekO(-2, wxFromEnd) != wxInvalidOffset); + // Go beyond the stream size. + CPPUNIT_ASSERT(stream_out.SeekO(10, wxFromCurrent) == wxInvalidOffset); + } + + // Just try to perform a TellO() on the output stream. + void Output_TellO() + { + CleanupHelper cleanup(this); + TStreamOut &stream_out = CreateOutStream(); + + // Try to Get the location in the stream... + CPPUNIT_ASSERT(stream_out.TellO() == 0); + (void)stream_out.PutC('1'); + CPPUNIT_ASSERT(stream_out.TellO() == 1); + if (!m_bSimpleTellOTest) + { + // First put some extra data in the stream, so it's not empty. + char *buf = "1234567890"; + (void)stream_out.Write(buf, 10); + + off_t pos = stream_out.SeekO(5, wxFromStart); + CPPUNIT_ASSERT(stream_out.TellO() == pos); + (void)stream_out.PutC('1'); + CPPUNIT_ASSERT(stream_out.TellO() == 6); + pos = stream_out.SeekO(2, wxFromCurrent); + CPPUNIT_ASSERT(stream_out.TellO() == pos); + pos = stream_out.SeekO(5, wxFromStart); + CPPUNIT_ASSERT(stream_out.TellO() == pos); + } + } + +protected: + // Some tests can be configured... here you can find the config settings + bool m_bSimpleTellITest; // if true, no SeekI will be used by the TellI test. + // Default false. + bool m_bSimpleTellOTest; // if true, no SeekO will be used by the TellI test. + // Default false. + +protected: + TStreamIn &CreateInStream() + { + if (m_pCurrentIn) + { + wxFAIL_MSG(_T("Error in test case, the previouse input stream needs to be delete first!")); + } + + m_pCurrentIn = DoCreateInStream(); + wxASSERT(m_pCurrentIn != NULL); + return *m_pCurrentIn; + } + TStreamOut &CreateOutStream() + { + if (m_pCurrentOut) + { + wxFAIL_MSG(_T("Error in test case, the previouse output stream needs to be delete first!")); + } + + m_pCurrentOut = DoCreateOutStream(); + wxASSERT(m_pCurrentOut != NULL); + return *m_pCurrentOut; + } + + void DeleteInStream() + { + if (m_pCurrentIn == NULL) + return; + delete m_pCurrentIn; + m_pCurrentIn = NULL; + // Incase something extra needs to be done. + DoDeleteInStream(); + } + void DeleteOutStream() + { + if (m_pCurrentOut == NULL) + return; + delete m_pCurrentOut; + m_pCurrentOut = NULL; + // Incase something extra needs to be done. + DoDeleteOutStream(); + } + +protected: + // Items that need to be implemented by a derived class! + virtual TStreamIn *DoCreateInStream() = 0; + virtual TStreamOut *DoCreateOutStream() = 0; + virtual void DoDeleteInStream() { /* Depends on the base class */ } + virtual void DoDeleteOutStream() { /* Depends on the base class */ } + +private: + TStreamIn *m_pCurrentIn; + TStreamOut *m_pCurrentOut; +}; + +#endif + +