tests/streams/datastreamtest.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/streams/datastreamtest.cpp
   3 // Purpose:     wxDataXXXStream Unit Test
   4 // Author:      Ryan Norton
   5 // Created:     2004-08-14
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2004 Ryan Norton
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ----------------------------------------------------------------------------
  11 // headers
  12 // ----------------------------------------------------------------------------
  13
  14 #include "testprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/wx.h"
  22 #endif // WX_PRECOMP
  23
  24 #include <vector>
  25
  26 #include "wx/datstrm.h"
  27 #include "wx/wfstream.h"
  28 #include "wx/math.h"
  29
  30 // ----------------------------------------------------------------------------
  31 // test class
  32 // ----------------------------------------------------------------------------
  33
  34 class DataStreamTestCase : public CppUnit::TestCase
  35 {
  36 public:
  37     DataStreamTestCase();
  38
  39 private:
  40     CPPUNIT_TEST_SUITE( DataStreamTestCase );
  41         CPPUNIT_TEST( FloatRW );
  42         CPPUNIT_TEST( DoubleRW );
  43 #if wxUSE_LONGLONG
  44         CPPUNIT_TEST( LongLongRW );
  45 #endif
  46 #if wxHAS_INT64
  47         CPPUNIT_TEST( Int64RW );
  48 #endif
  49         CPPUNIT_TEST( NaNRW );
  50     CPPUNIT_TEST_SUITE_END();
  51
  52     void FloatRW();
  53     void DoubleRW();
  54 #if wxUSE_LONGLONG
  55     void LongLongRW();
  56 #endif
  57 #if wxHAS_INT64
  58     void Int64RW();
  59 #endif
  60     void NaNRW();
  61
  62     DECLARE_NO_COPY_CLASS(DataStreamTestCase)
  63 };
  64
  65 // register in the unnamed registry so that these tests are run by default
  66 CPPUNIT_TEST_SUITE_REGISTRATION( DataStreamTestCase );
  67
  68 // also include in its own registry so that these tests can be run alone
  69 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( DataStreamTestCase, "DataStreamTestCase" );
  70
  71 DataStreamTestCase::DataStreamTestCase()
  72 {
  73 }
  74
  75 static
  76 wxFloat64 TestFloatRW(wxFloat64 fValue)
  77 {
  78     {
  79         wxFileOutputStream pFileOutput( wxT("mytext.dat") );
  80         wxDataOutputStream pDataOutput( pFileOutput );
  81
  82         pDataOutput << fValue;
  83     }
  84
  85     wxFileInputStream pFileInput( wxT("mytext.dat") );
  86     wxDataInputStream pDataInput( pFileInput );
  87
  88     wxFloat64 fInFloat;
  89
  90     pDataInput >> fInFloat;
  91
  92     return fInFloat;
  93 }
  94
  95 template <class T>
  96 class TestMultiRW {
  97 public:
  98     typedef std::vector<T> ValueArray;
  99     typedef void (wxDataOutputStream::*FnWriter)(const T *buffer, size_t size);
 100     typedef void (wxDataInputStream::*FnReader)(T *buffer, size_t size);
 101
 102 private:
 103     bool m_ok;
 104
 105 private:
 106     void ProcessData(const T *Values,
 107                      typename ValueArray::size_type Size,
 108                      FnWriter pfnWriter,
 109                      FnReader pfnReader)
 110     {
 111         ValueArray InValues(Size);
 112
 113         {
 114             wxFileOutputStream FileOutput( wxT("mytext.dat") );
 115             wxDataOutputStream DataOutput( FileOutput );
 116
 117             (DataOutput.*pfnWriter)(Values, Size);
 118         }
 119
 120         {
 121             wxFileInputStream FileInput( wxT("mytext.dat") );
 122             wxDataInputStream DataInput( FileInput );
 123
 124             (DataInput.*pfnReader)(&*InValues.begin(), InValues.size());
 125         }
 126
 127         m_ok = true;
 128         for (typename ValueArray::size_type idx=0; idx!=Size; ++idx) {
 129             if (InValues[idx]!=Values[idx]) {
 130                 m_ok = false;
 131                 break;
 132             }
 133         }
 134     }
 135
 136
 137 public:
 138     TestMultiRW(const T *Values,
 139                 size_t Size,
 140                 FnWriter pfnWriter,
 141                 FnReader pfnReader)
 142     {
 143         ProcessData(Values, (typename ValueArray::size_type) Size, pfnWriter, pfnReader);
 144     }
 145     TestMultiRW(const ValueArray &Values,
 146                 FnWriter pfnWriter,
 147                 FnReader pfnReader)
 148     {
 149         ProcessData(&*Values.begin(), Values.size(), pfnWriter, pfnReader);
 150     }
 151
 152     bool IsOk() const
 153     {
 154         return m_ok;
 155     }
 156 };
 157
 158 template <class T>
 159 static
 160 T TestRW(const T &Value)
 161 {
 162     T InValue;
 163
 164     {
 165         wxFileOutputStream FileOutput( wxT("mytext.dat") );
 166         wxDataOutputStream DataOutput( FileOutput );
 167
 168         DataOutput << Value;
 169     }
 170
 171     {
 172         wxFileInputStream FileInput( wxT("mytext.dat") );
 173         wxDataInputStream DataInput( FileInput );
 174
 175         DataInput >> InValue;
 176     }
 177
 178     return InValue;
 179 }
 180
 181 void DataStreamTestCase::FloatRW()
 182 {
 183     CPPUNIT_ASSERT( TestFloatRW(5.5) == 5.5 );
 184     CPPUNIT_ASSERT( TestFloatRW(5) == 5 );
 185     CPPUNIT_ASSERT( TestFloatRW(5.55) == 5.55 );
 186     CPPUNIT_ASSERT( TestFloatRW(55555.555555) == 55555.555555 );
 187 }
 188
 189 void DataStreamTestCase::DoubleRW()
 190 {
 191     CPPUNIT_ASSERT( TestFloatRW(2132131.1232132) == 2132131.1232132 );
 192     CPPUNIT_ASSERT( TestFloatRW(21321343431.1232143432) == 21321343431.1232143432 );
 193 }
 194
 195 #if wxUSE_LONGLONG
 196 void DataStreamTestCase::LongLongRW()
 197 {
 198     TestMultiRW<wxLongLong>::ValueArray ValuesLL;
 199     TestMultiRW<wxULongLong>::ValueArray ValuesULL;
 200
 201     ValuesLL.push_back(wxLongLong(0l));
 202     ValuesLL.push_back(wxLongLong(1l));
 203     ValuesLL.push_back(wxLongLong(-1l));
 204     ValuesLL.push_back(wxLongLong(0x12345678l));
 205     ValuesLL.push_back(wxLongLong(0x12345678l, 0xabcdef01l));
 206
 207     ValuesULL.push_back(wxULongLong(0l));
 208     ValuesULL.push_back(wxULongLong(1l));
 209     ValuesULL.push_back(wxULongLong(0x12345678l));
 210     ValuesULL.push_back(wxULongLong(0x12345678l, 0xabcdef01l));
 211
 212     CPPUNIT_ASSERT( TestRW(wxLongLong(0x12345678l)) == wxLongLong(0x12345678l) );
 213     CPPUNIT_ASSERT( TestRW(wxLongLong(0x12345678l, 0xabcdef01l)) == wxLongLong(0x12345678l, 0xabcdef01l) );
 214     CPPUNIT_ASSERT( TestMultiRW<wxLongLong>(ValuesLL, &wxDataOutputStream::WriteLL, &wxDataInputStream::ReadLL).IsOk() );
 215     CPPUNIT_ASSERT( TestMultiRW<wxULongLong>(ValuesULL, &wxDataOutputStream::WriteLL, &wxDataInputStream::ReadLL).IsOk() );
 216 }
 217 #endif
 218
 219 #if wxHAS_INT64
 220 void DataStreamTestCase::Int64RW()
 221 {
 222     TestMultiRW<wxInt64>::ValueArray ValuesI64;
 223     TestMultiRW<wxUint64>::ValueArray ValuesUI64;
 224
 225     ValuesI64.push_back(wxInt64(0l));
 226     ValuesI64.push_back(wxInt64(1l));
 227     ValuesI64.push_back(wxInt64(-1l));
 228     ValuesI64.push_back(wxInt64(0x12345678l));
 229     ValuesI64.push_back((wxInt64(0x12345678l) << 32) + wxInt64(0xabcdef01l));
 230
 231     ValuesUI64.push_back(wxUint64(0l));
 232     ValuesUI64.push_back(wxUint64(1l));
 233     ValuesUI64.push_back(wxUint64(0x12345678l));
 234     ValuesUI64.push_back((wxUint64(0x12345678l) << 32) + wxUint64(0xabcdef01l));
 235
 236     CPPUNIT_ASSERT( TestRW(wxUint64(0x12345678l)) == wxUint64(0x12345678l) );
 237     CPPUNIT_ASSERT( TestRW((wxUint64(0x12345678l) << 32) + wxUint64(0xabcdef01l)) == (wxUint64(0x12345678l) << 32) + wxUint64(0xabcdef01l) );
 238     CPPUNIT_ASSERT( TestMultiRW<wxInt64>(ValuesI64, &wxDataOutputStream::Write64, &wxDataInputStream::Read64).IsOk() );
 239     CPPUNIT_ASSERT( TestMultiRW<wxUint64>(ValuesUI64, &wxDataOutputStream::Write64, &wxDataInputStream::Read64).IsOk() );
 240 }
 241 #endif
 242
 243 void DataStreamTestCase::NaNRW()
 244 {
 245     //TODO?
 246 }
 247
 248