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