tests/streams/zlibstream.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/streams/zlibstream.cpp
   3 // Purpose:     Test wxZlibInputStream/wxZlibOutputStream
   4 // Author:      Hans Van Leemputten
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Hans Van Leemputten
   7 // Licence:     wxWidgets licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 #if defined(__GNUG__) && !defined(__APPLE__)
  11     #pragma implementation
  12     #pragma interface
  13 #endif
  14
  15 // For compilers that support precompilation, includes "wx/wx.h".
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19     #pragma hdrstop
  20 #endif
  21
  22 // for all others, include the necessary headers
  23 #ifndef WX_PRECOMP
  24     #include "wx/wx.h"
  25 #endif
  26
  27 #include "wx/cppunit.h"
  28 #include "wx/zstream.h"
  29 #include "wx/wfstream.h"
  30 #include "wx/mstream.h"
  31
  32 #include "wx/txtstrm.h"
  33
  34 #include "bstream.h"
  35
  36 using namespace std;
  37 using namespace CppUnit;
  38
  39 #define WXTEST_WITH_GZIP_CONDITION(testMethod) \
  40     WXTEST_WITH_CONDITION( COMPOSE_TEST_NAME(zlibStream), wxZlibInputStream::CanHandleGZip() && wxZlibOutputStream::CanHandleGZip(), testMethod )
  41
  42 #define DATABUFFER_SIZE 1024
  43
  44 static const wxString FILENAME_GZ = _T("zlibtest.gz");
  45
  46 ///////////////////////////////////////////////////////////////////////////////
  47 // The test case
  48 //
  49 // Try to fully test wxZlibInputStream and wxZlibOutputStream
  50
  51 class zlibStream : public BaseStreamTestCase<wxZlibInputStream, wxZlibOutputStream>
  52 {
  53 public:
  54     zlibStream();
  55     virtual ~zlibStream();
  56
  57     CPPUNIT_TEST_SUITE(zlibStream);
  58         // Base class stream tests the zlibstream supports.
  59         CPPUNIT_TEST_FAIL(Input_GetSize);
  60         CPPUNIT_TEST(Input_GetC);
  61         CPPUNIT_TEST(Input_Read);
  62         CPPUNIT_TEST(Input_Eof);
  63         CPPUNIT_TEST(Input_LastRead);
  64         CPPUNIT_TEST_FAIL(Input_SeekI);
  65         CPPUNIT_TEST(Input_TellI);
  66         CPPUNIT_TEST(Input_Peek);
  67         CPPUNIT_TEST(Input_Ungetch);
  68
  69         CPPUNIT_TEST(Output_PutC);
  70         CPPUNIT_TEST(Output_Write);
  71         CPPUNIT_TEST(Output_LastWrite);
  72         CPPUNIT_TEST_FAIL(Output_SeekO);
  73         CPPUNIT_TEST(Output_TellO);
  74
  75         // Other test specific for zlib stream test case.
  76         CPPUNIT_TEST(TestStream_NoHeader_Default);
  77         CPPUNIT_TEST(TestStream_NoHeader_NoComp);
  78         CPPUNIT_TEST(TestStream_NoHeader_SpeedComp);
  79         CPPUNIT_TEST(TestStream_NoHeader_BestComp);
  80         CPPUNIT_TEST(TestStream_ZLib_Default);
  81         CPPUNIT_TEST(TestStream_ZLib_NoComp);
  82         CPPUNIT_TEST(TestStream_ZLib_SpeedComp);
  83         CPPUNIT_TEST(TestStream_ZLib_BestComp);
  84         WXTEST_WITH_GZIP_CONDITION(TestStream_GZip_Default);
  85         WXTEST_WITH_GZIP_CONDITION(TestStream_GZip_NoComp);
  86         WXTEST_WITH_GZIP_CONDITION(TestStream_GZip_SpeedComp);
  87         WXTEST_WITH_GZIP_CONDITION(TestStream_GZip_BestComp);
  88         WXTEST_WITH_GZIP_CONDITION(TestStream_ZLibGZip);
  89         CPPUNIT_TEST(Decompress_BadData);
  90 #if WXWIN_COMPATIBILITY_2_4
  91         CPPUNIT_TEST(Decompress_wx24Data);
  92 #endif
  93         CPPUNIT_TEST(Decompress_wx251_zlib114_Data_NoHeader);
  94         CPPUNIT_TEST(Decompress_wx251_zlib114_Data_ZLib);
  95         WXTEST_WITH_GZIP_CONDITION(Decompress_gzip135Data);
  96     CPPUNIT_TEST_SUITE_END();
  97
  98 protected:
  99     // Test different stream construct settings.
 100     void TestStream_NoHeader_Default();
 101     void TestStream_NoHeader_NoComp();
 102     void TestStream_NoHeader_SpeedComp();
 103     void TestStream_NoHeader_BestComp();
 104     void TestStream_ZLib_Default();
 105     void TestStream_ZLib_NoComp();
 106     void TestStream_ZLib_SpeedComp();
 107     void TestStream_ZLib_BestComp();
 108     void TestStream_GZip_Default();
 109     void TestStream_GZip_NoComp();
 110     void TestStream_GZip_SpeedComp();
 111     void TestStream_GZip_BestComp();
 112     void TestStream_ZLibGZip();
 113     // Try to decompress bad data.
 114     void Decompress_BadData();
 115     // Decompress data that was compress by an external app.
 116     // (like test wx 2.4.2, 2.5.1 and gzip data)
 117     // Note: This test is limited in testing range!
 118 #if WXWIN_COMPATIBILITY_2_4
 119     void Decompress_wx24Data();
 120 #endif
 121     void Decompress_wx251_zlib114_Data_NoHeader();
 122     void Decompress_wx251_zlib114_Data_ZLib();
 123     void Decompress_gzip135Data();
 124
 125 private:
 126     const char *GetDataBuffer();
 127     const unsigned char *GetCompressedData();
 128     void doTestStreamData(int input_flag, int output_flag, int compress_level);
 129     void doDecompress_ExternalData(const unsigned char *data, const char *value, size_t data_size, size_t value_size, int flag = wxZLIB_AUTO);
 130
 131 private:
 132     // Implement base class functions.
 133     virtual wxZlibInputStream  *DoCreateInStream();
 134     virtual wxZlibOutputStream *DoCreateOutStream();
 135     virtual void DoDeleteInStream();
 136     virtual void DoDeleteOutStream();
 137
 138     // Helper that can be used to create new wx compatibility tests...
 139     // Otherwise not used by the tests.
 140     void genExtTestData(wxTextOutputStream &out, const char *buf, int flag);
 141
 142 private:
 143     char            m_DataBuffer[DATABUFFER_SIZE];
 144     size_t          m_SizeCompressedData;
 145     unsigned char  *m_pCompressedData;
 146
 147     // Used by the base Creat[In|Out]Stream and Delete[In|Out]Stream.
 148     wxMemoryInputStream  *m_pTmpMemInStream;
 149     wxMemoryOutputStream *m_pTmpMemOutStream;
 150 };
 151
 152 zlibStream::zlibStream()
 153     :m_SizeCompressedData(0),
 154      m_pCompressedData(NULL),
 155      m_pTmpMemInStream(NULL),
 156      m_pTmpMemOutStream(NULL)
 157 {
 158     // Init the data buffer.
 159     for (size_t i = 0; i < DATABUFFER_SIZE; i++)
 160         m_DataBuffer[i] = (i % 0xFF);
 161
 162     // Set extra base config settings.
 163     m_bSimpleTellITest = true;
 164     m_bSimpleTellOTest = true;
 165
 166 /* Example code on how to produce test data...
 167     {
 168         wxFFileOutputStream fstream_out(_T("gentest.cpp"));
 169         wxTextOutputStream out( fstream_out );
 170
 171         genExtTestData(out, "zlib data created with wxWidgets 2.5.x [March 27], wxZLIB_NO_HEADER, zlib 1.1.4", wxZLIB_NO_HEADER);
 172         genExtTestData(out, "zlib data created with wxWidgets 2.5.x [March 27], wxZLIB_ZLIB, zlib 1.1.4", wxZLIB_ZLIB);
 173     }
 174 */
 175 }
 176
 177 zlibStream::~zlibStream()
 178 {
 179     delete m_pCompressedData;
 180
 181     delete m_pTmpMemInStream;
 182     delete m_pTmpMemOutStream;
 183 }
 184
 185 void zlibStream::TestStream_NoHeader_Default()
 186 {
 187     doTestStreamData(wxZLIB_NO_HEADER, wxZLIB_NO_HEADER, wxZ_DEFAULT_COMPRESSION);
 188 }
 189 void zlibStream::TestStream_NoHeader_NoComp()
 190 {
 191     doTestStreamData(wxZLIB_NO_HEADER, wxZLIB_NO_HEADER, wxZ_NO_COMPRESSION);
 192 }
 193 void zlibStream::TestStream_NoHeader_SpeedComp()
 194 {
 195     doTestStreamData(wxZLIB_NO_HEADER, wxZLIB_NO_HEADER, wxZ_BEST_SPEED);
 196 }
 197 void zlibStream::TestStream_NoHeader_BestComp()
 198 {
 199     doTestStreamData(wxZLIB_NO_HEADER, wxZLIB_NO_HEADER, wxZ_BEST_COMPRESSION);
 200 }
 201
 202 void zlibStream::TestStream_ZLib_Default()
 203 {
 204     doTestStreamData(wxZLIB_ZLIB, wxZLIB_ZLIB, wxZ_DEFAULT_COMPRESSION);
 205 }
 206 void zlibStream::TestStream_ZLib_NoComp()
 207 {
 208     doTestStreamData(wxZLIB_ZLIB, wxZLIB_ZLIB, wxZ_NO_COMPRESSION);
 209 }
 210 void zlibStream::TestStream_ZLib_SpeedComp()
 211 {
 212     doTestStreamData(wxZLIB_ZLIB, wxZLIB_ZLIB, wxZ_BEST_SPEED);
 213 }
 214 void zlibStream::TestStream_ZLib_BestComp()
 215 {
 216     doTestStreamData(wxZLIB_ZLIB, wxZLIB_ZLIB, wxZ_BEST_COMPRESSION);
 217 }
 218
 219 void zlibStream::TestStream_GZip_Default()
 220 {
 221     doTestStreamData(wxZLIB_GZIP, wxZLIB_GZIP, wxZ_DEFAULT_COMPRESSION);
 222 }
 223 void zlibStream::TestStream_GZip_NoComp()
 224 {
 225     doTestStreamData(wxZLIB_GZIP, wxZLIB_GZIP, wxZ_NO_COMPRESSION);
 226 }
 227 void zlibStream::TestStream_GZip_SpeedComp()
 228 {
 229     doTestStreamData(wxZLIB_GZIP, wxZLIB_GZIP, wxZ_BEST_SPEED);
 230 }
 231 void zlibStream::TestStream_GZip_BestComp()
 232 {
 233     doTestStreamData(wxZLIB_GZIP, wxZLIB_GZIP, wxZ_BEST_COMPRESSION);
 234 }
 235
 236 void zlibStream::TestStream_ZLibGZip()
 237 {
 238     // Only use default compression level, as this test is
 239     // for testing if the streams can determine the stream type info them self...
 240     doTestStreamData(wxZLIB_AUTO, wxZLIB_ZLIB, wxZ_DEFAULT_COMPRESSION);
 241     doTestStreamData(wxZLIB_AUTO, wxZLIB_GZIP, wxZ_DEFAULT_COMPRESSION);
 242 }
 243
 244 void zlibStream::Decompress_BadData()
 245 {
 246     // Setup the bad data stream and the zlib stream.
 247     wxMemoryInputStream memstream_in(GetDataBuffer(), DATABUFFER_SIZE);
 248     CPPUNIT_ASSERT(memstream_in.IsOk());
 249     wxZlibInputStream zstream_in(memstream_in);
 250     CPPUNIT_ASSERT(zstream_in.IsOk()); // We did not yet read from the stream
 251                                        // so it should still be OK.
 252     // Try to force the stream to go to bad status.
 253     CPPUNIT_ASSERT(!zstream_in.Eof());
 254     if (zstream_in.IsOk())
 255         zstream_in.GetC();
 256
 257     // Because of the bad data in the input stream the zlib
 258     // stream should be marked as NOT OK.
 259     CPPUNIT_ASSERT(!zstream_in.IsOk());
 260 }
 261
 262 #if WXWIN_COMPATIBILITY_2_4
 263 void zlibStream::Decompress_wx24Data()
 264 {
 265     // The wx24_value was used in a wxWidgets 2.4(.2)
 266     // application to produce wx24_data, using wxZlibOutputStream.
 267     const unsigned char wx24_data[] = {120,156,242,72,205,201,201,87,40,207,47,202,73,97,0,0,0,0,255,255,0};
 268     const char *wx24_value = "Hello world";
 269     // Size of the value and date items.
 270     const size_t data_size = sizeof(wx24_data);
 271     const size_t value_size = strlen(wx24_value) + 1; // +1 because the wx24 app also did this.
 272
 273     // Perform a generic data test on the data.
 274     doDecompress_ExternalData(wx24_data, wx24_value, data_size, value_size, wxZLIB_24COMPATIBLE);
 275 }
 276 #endif
 277
 278 void zlibStream::Decompress_wx251_zlib114_Data_NoHeader()
 279 {
 280     const unsigned char data[] = {171,202,201,76,82,72,73,44,73,84,72,46,74,77,44,73,77,81,40,207,44,201,80,40,175,8,207,76,73,79,45,41,86,48,210,51,213,171,80,136,246,77,44,74,206,80,48,50,143,213,1,202,69,249,120,58,197,251,249,199,123,184,58,186,184,6,233,40,84,129,12,49,212,51,212,51,1,0,32};
 281     const char *value = "zlib data created with wxWidgets 2.5.x [March 27], wxZLIB_NO_HEADER, zlib 1.1.4";
 282     const size_t data_size = sizeof(data);
 283     const size_t value_size = strlen(value);
 284     // We need to specify wxZLIB_NO_HEADER because wxZLIB_AUTO can't find it his self.
 285     doDecompress_ExternalData(data, value, data_size, value_size, wxZLIB_NO_HEADER);
 286 }
 287
 288 void zlibStream::Decompress_wx251_zlib114_Data_ZLib()
 289 {
 290     const unsigned char data[] = {120,156,171,202,201,76,82,72,73,44,73,84,72,46,74,77,44,73,77,81,40,207,44,201,80,40,175,8,207,76,73,79,45,41,86,48,210,51,213,171,80,136,246,77,44,74,206,80,48,50,143,213,1,202,69,249,120,58,197,131,8,29,133,42,144,126,67,61,67,61,19,0,191,86,23,216};
 291     const char *value = "zlib data created with wxWidgets 2.5.x [March 27], wxZLIB_ZLIB, zlib 1.1.4";
 292     const size_t data_size = sizeof(data);
 293     const size_t value_size = strlen(value);
 294     doDecompress_ExternalData(data, value, data_size, value_size);
 295 }
 296
 297 void zlibStream::Decompress_gzip135Data()
 298 {
 299     // Compressed data was on the command line with gzip 1.3.5.
 300     const unsigned char gzip135_data[] = {31,139,8,0,177,248,112,64,4,3,115,206,207,45,40,74,45,46,78,77,81,72,73,44,73,84,72,46,74,77,44,1,114,202,51,75,50,20,220,253,66,21,210,171,50,11,20,12,245,140,245,76,185,0,1,107,16,80,44,0,0,0,0};
 301     const char *gzip135_value = "Compressed data created with GNU gzip 1.3.5\n";
 302     // Size of the value and date items.
 303     const size_t data_size = sizeof(gzip135_data);
 304     const size_t value_size = strlen(gzip135_value);
 305
 306     // Perform a generic data test on the data.
 307     doDecompress_ExternalData(gzip135_data, gzip135_value, data_size, value_size);
 308 }
 309
 310 const char *zlibStream::GetDataBuffer()
 311 {
 312     return m_DataBuffer;
 313 }
 314
 315 const unsigned char *zlibStream::GetCompressedData()
 316 {
 317     if (!m_pCompressedData)
 318     {
 319         // Construct the compressed data live.
 320         wxMemoryOutputStream memstream_out;
 321         {
 322             const char *buf = "01234567890123456789012345678901234567890123456789"; /* = 50 */
 323             wxZlibOutputStream zstream_out(memstream_out);
 324             zstream_out.Write(buf, strlen(buf));
 325         }
 326
 327         // Copy the to the
 328         m_SizeCompressedData = memstream_out.GetSize();
 329         m_pCompressedData = new unsigned char[m_SizeCompressedData];
 330         memstream_out.CopyTo(m_pCompressedData, m_SizeCompressedData);
 331     }
 332
 333     CPPUNIT_ASSERT(m_pCompressedData != NULL);
 334     return m_pCompressedData;
 335 }
 336
 337 void zlibStream::doTestStreamData(int input_flag, int output_flag, int compress_level)
 338 {
 339     size_t fail_pos;
 340     char last_value = 0;
 341     bool bWasEOF;
 342
 343     {   // Part one: Create a compressed file.
 344         wxFileOutputStream fstream_out(FILENAME_GZ);
 345         CPPUNIT_ASSERT(fstream_out.IsOk());
 346         {
 347             wxZlibOutputStream zstream_out(fstream_out, compress_level, output_flag);
 348             CPPUNIT_ASSERT_MESSAGE("Could not create the output stream", zstream_out.IsOk());
 349
 350             // Next: Compress some data so the file is containing something.
 351             zstream_out.Write(GetDataBuffer(), DATABUFFER_SIZE);
 352         }
 353
 354         // Next thing is required by zlib versions pre 1.2.0.
 355         if (input_flag == wxZLIB_NO_HEADER)
 356             fstream_out.PutC(' ');
 357     }
 358
 359     {   // Part two: Verify that the compressed data when uncompressed
 360         //           matches the original data.
 361         wxFileInputStream fstream_in(FILENAME_GZ);
 362         CPPUNIT_ASSERT(fstream_in.IsOk());
 363         wxZlibInputStream zstream_in(fstream_in, input_flag);
 364         CPPUNIT_ASSERT_MESSAGE("Could not create the input stream", zstream_in.IsOk());
 365
 366         // Next: Check char per char if the returned data is valid.
 367         const char *pbuf = GetDataBuffer();
 368         for (fail_pos = 0; !zstream_in.Eof(); fail_pos++)
 369         {
 370             last_value = zstream_in.GetC();
 371             if (zstream_in.LastRead() != 1 ||
 372                 last_value != pbuf[fail_pos])
 373                 break;
 374         }
 375
 376         bWasEOF = zstream_in.Eof();
 377     }
 378
 379     // Remove the temp file...
 380     ::wxRemoveFile(FILENAME_GZ);
 381
 382     // Check state of the verify action.
 383     if (fail_pos != DATABUFFER_SIZE || !bWasEOF)
 384     {
 385         wxString msg(wxString::Format(_T("Wrong data item at pos %d (Org_val %d != Zlib_val %d), with compression level %d"),
 386                                             fail_pos, GetDataBuffer()[fail_pos], last_value, compress_level));
 387         CPPUNIT_FAIL(string(msg.mb_str()));
 388     }
 389 }
 390
 391 void zlibStream::doDecompress_ExternalData(const unsigned char *data, const char *value, size_t data_size, size_t value_size, int flag)
 392 {
 393     // See that the input is ok.
 394     wxASSERT(data != NULL);
 395     wxASSERT(value != NULL);
 396     wxASSERT(data_size > 0);
 397     wxASSERT(value_size > 0);
 398
 399     // Quickly try to see if the data is valid.
 400     switch (flag)
 401     {
 402     case wxZLIB_NO_HEADER:
 403         break;
 404 #if WXWIN_COMPATIBILITY_2_4
 405     case wxZLIB_24COMPATIBLE:
 406 #endif
 407     case wxZLIB_ZLIB:
 408         if (!(data_size >= 1 && data[0] == 0x78))
 409             wxLogError(_T("zlib data seems to not be zlib data!"));
 410         break;
 411     case wxZLIB_GZIP:
 412         if (!(data_size >= 2 && data[0] == 0x1F && data[1] == 0x8B))
 413             wxLogError(_T("gzip data seems to not be gzip data!"));
 414         break;
 415     case wxZLIB_AUTO:
 416         if (!(data_size >= 1 && data[0] == 0x78) ||
 417             !(data_size >= 2 && data[0] == 0x1F && data[1] == 0x8B))
 418             wxLogError(_T("Data seems to not be zlib or gzip data!"));
 419     default:
 420         wxLogError(_T("Unknown flag, skipping quick test."));
 421     };
 422
 423     // Creat the needed streams.
 424     wxMemoryInputStream memstream_in(data, data_size);
 425     CPPUNIT_ASSERT(memstream_in.IsOk());
 426     wxZlibInputStream zstream_in(memstream_in, flag);
 427     CPPUNIT_ASSERT(zstream_in.IsOk());
 428
 429     bool bValueEq = true;
 430     size_t i;
 431     for (i = 0; !zstream_in.Eof(); i++)
 432     {
 433         char last_value = zstream_in.GetC();
 434
 435         // First check if it is a valid read.
 436         if (zstream_in.LastRead() == 1)
 437         {
 438             // Check the values
 439             if (last_value != value[i])
 440             {
 441                 bValueEq = false;
 442                 break;
 443             }
 444         }
 445         else
 446         {
 447             // If the read failed and turned the stream to Eof we stop reading.
 448             if (zstream_in.Eof())
 449                 break;
 450
 451             CPPUNIT_ASSERT_MESSAGE("Stream is no longer ok!", zstream_in.IsOk());
 452         }
 453
 454         // Don't go over the end of the value buffer...
 455         if (i == value_size)
 456         {
 457             // And if we do then try to see how long the stream actually is.
 458             while (!zstream_in.Eof())
 459             {
 460                 // Move one item along in the stream.
 461                 (void)zstream_in.GetC();
 462                 i++;
 463
 464                 // Check if we are in an infinite loop by multiplying value_size
 465                 // by 5 to have a *much* bigger range then the real range.
 466                 // Note: Incase you ask your self, why 5, the answer is no reason...
 467                 //       it is not to big and not to small a size, nothing more
 468                 //       nothing less to it.
 469                 if (i > (value_size*5))
 470                 {
 471                     // Note: Please make sure Input_Eof test passed.
 472                     CPPUNIT_FAIL("Infinite stream detected, breaking the infinite loop");
 473                     return;
 474                 }
 475             }
 476         }
 477     }
 478
 479     CPPUNIT_ASSERT_MESSAGE("Could not decompress the compressed data, original and restored value did not match.",
 480                            i == value_size && bValueEq);
 481 }
 482
 483 wxZlibInputStream *zlibStream::DoCreateInStream()
 484 {
 485     const unsigned char *buf = GetCompressedData();
 486     m_pTmpMemInStream = new wxMemoryInputStream(buf, m_SizeCompressedData);
 487     CPPUNIT_ASSERT(m_pTmpMemInStream->IsOk());
 488     wxZlibInputStream *pzstream_in = new wxZlibInputStream(*m_pTmpMemInStream);
 489     CPPUNIT_ASSERT(pzstream_in->IsOk());
 490     return pzstream_in;
 491 }
 492 wxZlibOutputStream *zlibStream::DoCreateOutStream()
 493 {
 494     m_pTmpMemOutStream = new wxMemoryOutputStream();
 495     CPPUNIT_ASSERT(m_pTmpMemOutStream->IsOk());
 496     wxZlibOutputStream *pzstream_out = new wxZlibOutputStream(*m_pTmpMemOutStream);
 497     CPPUNIT_ASSERT(pzstream_out->IsOk());
 498     return pzstream_out;
 499 }
 500 void zlibStream::DoDeleteInStream()
 501 {
 502     delete m_pTmpMemInStream;
 503     m_pTmpMemInStream = NULL;
 504 }
 505 void zlibStream::DoDeleteOutStream()
 506 {
 507     delete m_pTmpMemOutStream;
 508     m_pTmpMemOutStream = NULL;
 509 }
 510
 511
 512 void zlibStream::genExtTestData(wxTextOutputStream &out, const char *buf, int flag)
 513 {
 514     unsigned char *data;
 515     size_t size;
 516
 517     {   // Gen data
 518         wxMemoryOutputStream memstream_out;
 519         {
 520             wxZlibOutputStream zstream_out(memstream_out, wxZ_DEFAULT_COMPRESSION, flag);
 521             zstream_out.Write(buf, strlen(buf));
 522         }
 523         if (flag == wxZLIB_NO_HEADER)
 524             memstream_out.PutC(' ');
 525
 526         size = memstream_out.GetSize();
 527         data = new unsigned char[size];
 528         memstream_out.CopyTo(data, size);
 529     }
 530
 531     out << _T("void zlibStream::Decompress_wxXXXData()") << _T("\n");
 532     out << _T("{") << _T("\n") << _T("    const unsigned char data[] = {");
 533
 534     size_t i;
 535     for (i = 0; i < size; i++)
 536     {
 537         if (i+1 != size)
 538             out << wxString::Format(_T("%d,"), data[i]);
 539         else
 540             out << wxString::Format(_T("%d"), data[i]);
 541     }
 542     delete [] data;
 543
 544     out << _T("};") << _T("\n");
 545     out << _T("    const char *value = \"") << wxString(buf, wxConvUTF8) << _T("\";") << _T("\n");
 546     out << _T("    const size_t data_size = sizeof(data);") << _T("\n");
 547     out << _T("    const size_t value_size = strlen(value);") << _T("\n");
 548     out << _T("    doDecompress_ExternalData(data, value, data_size, value_size);") << _T("\n");
 549     out << _T("}") << _T("\n");
 550 }
 551
 552
 553 // Register the stream sub suite, by using some stream helper macro.
 554 // Note: Don't forget to connect it to the base suite (See: bstream.cpp => StreamCase::suite())
 555 STREAM_TEST_SUBSUITE_NAMED_REGISTRATION(zlibStream)
 556