Commit | Line | Data |
---|---|---|
340da6ae VS |
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 | ||
340da6ae | 10 | // For compilers that support precompilation, includes "wx/wx.h". |
8899b155 RN |
11 | // and "wx/cppunit.h" |
12 | #include "testprec.h" | |
340da6ae VS |
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 | ||
340da6ae VS |
23 | #include "wx/zstream.h" |
24 | #include "wx/wfstream.h" | |
25 | #include "wx/mstream.h" | |
26 | ||
7735998c VS |
27 | #include "wx/txtstrm.h" |
28 | ||
340da6ae VS |
29 | #include "bstream.h" |
30 | ||
3e5f6c1c | 31 | using std::string; |
340da6ae | 32 | |
08776b09 VS |
33 | #define WXTEST_WITH_GZIP_CONDITION(testMethod) \ |
34 | WXTEST_WITH_CONDITION( COMPOSE_TEST_NAME(zlibStream), wxZlibInputStream::CanHandleGZip() && wxZlibOutputStream::CanHandleGZip(), testMethod ) | |
35 | ||
340da6ae VS |
36 | #define DATABUFFER_SIZE 1024 |
37 | ||
38 | static const wxString FILENAME_GZ = _T("zlibtest.gz"); | |
39 | ||
40 | /////////////////////////////////////////////////////////////////////////////// | |
41 | // The test case | |
42 | // | |
08776b09 | 43 | // Try to fully test wxZlibInputStream and wxZlibOutputStream |
340da6ae VS |
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); | |
08776b09 VS |
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); | |
340da6ae | 83 | CPPUNIT_TEST(Decompress_BadData); |
82073497 | 84 | #if WXWIN_COMPATIBILITY_2_4 |
340da6ae | 85 | CPPUNIT_TEST(Decompress_wx24Data); |
82073497 | 86 | #endif |
7735998c VS |
87 | CPPUNIT_TEST(Decompress_wx251_zlib114_Data_NoHeader); |
88 | CPPUNIT_TEST(Decompress_wx251_zlib114_Data_ZLib); | |
89 | WXTEST_WITH_GZIP_CONDITION(Decompress_gzip135Data); | |
340da6ae VS |
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(); | |
3e5f6c1c | 109 | // Decompress data that was compress by an external app. |
7735998c | 110 | // (like test wx 2.4.2, 2.5.1 and gzip data) |
340da6ae | 111 | // Note: This test is limited in testing range! |
82073497 | 112 | #if WXWIN_COMPATIBILITY_2_4 |
340da6ae | 113 | void Decompress_wx24Data(); |
82073497 | 114 | #endif |
7735998c VS |
115 | void Decompress_wx251_zlib114_Data_NoHeader(); |
116 | void Decompress_wx251_zlib114_Data_ZLib(); | |
3e5f6c1c | 117 | void Decompress_gzip135Data(); |
340da6ae | 118 | |
3e5f6c1c | 119 | private: |
340da6ae VS |
120 | const char *GetDataBuffer(); |
121 | const unsigned char *GetCompressedData(); | |
122 | void doTestStreamData(int input_flag, int output_flag, int compress_level); | |
7735998c | 123 | void doDecompress_ExternalData(const unsigned char *data, const char *value, size_t data_size, size_t value_size, int flag = wxZLIB_AUTO); |
340da6ae VS |
124 | |
125 | private: | |
126 | // Implement base class functions. | |
3e5f6c1c | 127 | virtual wxZlibInputStream *DoCreateInStream(); |
340da6ae VS |
128 | virtual wxZlibOutputStream *DoCreateOutStream(); |
129 | virtual void DoDeleteInStream(); | |
130 | virtual void DoDeleteOutStream(); | |
131 | ||
3e5f6c1c | 132 | // Helper that can be used to create new wx compatibility tests... |
7735998c VS |
133 | // Otherwise not used by the tests. |
134 | void genExtTestData(wxTextOutputStream &out, const char *buf, int flag); | |
135 | ||
340da6ae VS |
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; | |
7735998c VS |
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 | */ | |
340da6ae VS |
169 | } |
170 | ||
171 | zlibStream::~zlibStream() | |
172 | { | |
6b7d5d1c | 173 | delete[] m_pCompressedData; |
340da6ae VS |
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 | { | |
3e5f6c1c | 232 | // Only use default compression level, as this test is |
340da6ae | 233 | // for testing if the streams can determine the stream type info them self... |
7735998c VS |
234 | doTestStreamData(wxZLIB_AUTO, wxZLIB_ZLIB, wxZ_DEFAULT_COMPRESSION); |
235 | doTestStreamData(wxZLIB_AUTO, wxZLIB_GZIP, wxZ_DEFAULT_COMPRESSION); | |
340da6ae VS |
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); | |
3e5f6c1c | 244 | CPPUNIT_ASSERT(zstream_in.IsOk()); // We did not yet read from the stream |
340da6ae VS |
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 | ||
82073497 | 256 | #if WXWIN_COMPATIBILITY_2_4 |
340da6ae VS |
257 | void zlibStream::Decompress_wx24Data() |
258 | { | |
3e5f6c1c | 259 | // The wx24_value was used in a wxWidgets 2.4(.2) |
340da6ae VS |
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); | |
7735998c | 265 | const size_t value_size = strlen(wx24_value) + 1; // +1 because the wx24 app also did this. |
340da6ae | 266 | |
7735998c VS |
267 | // Perform a generic data test on the data. |
268 | doDecompress_ExternalData(wx24_data, wx24_value, data_size, value_size, wxZLIB_24COMPATIBLE); | |
269 | } | |
82073497 | 270 | #endif |
340da6ae | 271 | |
7735998c VS |
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 | } | |
340da6ae | 281 | |
7735998c VS |
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 | } | |
340da6ae | 290 | |
7735998c VS |
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); | |
340da6ae | 299 | |
7735998c VS |
300 | // Perform a generic data test on the data. |
301 | doDecompress_ExternalData(gzip135_data, gzip135_value, data_size, value_size); | |
340da6ae VS |
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 | { | |
340da6ae VS |
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 | ||
3e5f6c1c | 321 | // Copy the to the |
340da6ae VS |
322 | m_SizeCompressedData = memstream_out.GetSize(); |
323 | m_pCompressedData = new unsigned char[m_SizeCompressedData]; | |
324 | memstream_out.CopyTo(m_pCompressedData, m_SizeCompressedData); | |
340da6ae VS |
325 | } |
326 | ||
3e5f6c1c | 327 | CPPUNIT_ASSERT(m_pCompressedData != NULL); |
340da6ae VS |
328 | return m_pCompressedData; |
329 | } | |
330 | ||
331 | void zlibStream::doTestStreamData(int input_flag, int output_flag, int compress_level) | |
332 | { | |
0e43839c | 333 | size_t fail_pos; |
340da6ae | 334 | char last_value = 0; |
0e43839c | 335 | bool bWasEOF; |
340da6ae VS |
336 | |
337 | { // Part one: Create a compressed file. | |
338 | wxFileOutputStream fstream_out(FILENAME_GZ); | |
339 | CPPUNIT_ASSERT(fstream_out.IsOk()); | |
340da6ae | 340 | { |
7735998c VS |
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); | |
340da6ae VS |
346 | } |
347 | ||
7735998c VS |
348 | // Next thing is required by zlib versions pre 1.2.0. |
349 | if (input_flag == wxZLIB_NO_HEADER) | |
350 | fstream_out.PutC(' '); | |
340da6ae VS |
351 | } |
352 | ||
3e5f6c1c | 353 | { // Part two: Verify that the compressed data when uncompressed |
340da6ae VS |
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(); | |
3e5f6c1c | 365 | if (zstream_in.LastRead() != 1 || |
7735998c | 366 | last_value != pbuf[fail_pos]) |
340da6ae VS |
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 | { | |
3e5f6c1c | 379 | wxString msg(wxString::Format(_T("Wrong data item at pos %d (Org_val %d != Zlib_val %d), with compression level %d"), |
340da6ae VS |
380 | fail_pos, GetDataBuffer()[fail_pos], last_value, compress_level)); |
381 | CPPUNIT_FAIL(string(msg.mb_str())); | |
382 | } | |
383 | } | |
384 | ||
7735998c VS |
385 | void zlibStream::doDecompress_ExternalData(const unsigned char *data, const char *value, size_t data_size, size_t value_size, int flag) |
386 | { | |
387 | // See that the input is ok. | |
388 | wxASSERT(data != NULL); | |
389 | wxASSERT(value != NULL); | |
390 | wxASSERT(data_size > 0); | |
391 | wxASSERT(value_size > 0); | |
392 | ||
393 | // Quickly try to see if the data is valid. | |
394 | switch (flag) | |
395 | { | |
396 | case wxZLIB_NO_HEADER: | |
397 | break; | |
ce426152 | 398 | #if WXWIN_COMPATIBILITY_2_4 |
7735998c | 399 | case wxZLIB_24COMPATIBLE: |
ce426152 | 400 | #endif |
7735998c VS |
401 | case wxZLIB_ZLIB: |
402 | if (!(data_size >= 1 && data[0] == 0x78)) | |
403 | wxLogError(_T("zlib data seems to not be zlib data!")); | |
404 | break; | |
405 | case wxZLIB_GZIP: | |
406 | if (!(data_size >= 2 && data[0] == 0x1F && data[1] == 0x8B)) | |
407 | wxLogError(_T("gzip data seems to not be gzip data!")); | |
408 | break; | |
409 | case wxZLIB_AUTO: | |
3e5f6c1c | 410 | if (!(data_size >= 1 && data[0] == 0x78) || |
7735998c VS |
411 | !(data_size >= 2 && data[0] == 0x1F && data[1] == 0x8B)) |
412 | wxLogError(_T("Data seems to not be zlib or gzip data!")); | |
413 | default: | |
414 | wxLogError(_T("Unknown flag, skipping quick test.")); | |
415 | }; | |
416 | ||
417 | // Creat the needed streams. | |
418 | wxMemoryInputStream memstream_in(data, data_size); | |
419 | CPPUNIT_ASSERT(memstream_in.IsOk()); | |
420 | wxZlibInputStream zstream_in(memstream_in, flag); | |
421 | CPPUNIT_ASSERT(zstream_in.IsOk()); | |
422 | ||
423 | bool bValueEq = true; | |
424 | size_t i; | |
425 | for (i = 0; !zstream_in.Eof(); i++) | |
426 | { | |
427 | char last_value = zstream_in.GetC(); | |
428 | ||
429 | // First check if it is a valid read. | |
430 | if (zstream_in.LastRead() == 1) | |
431 | { | |
432 | // Check the values | |
433 | if (last_value != value[i]) | |
434 | { | |
435 | bValueEq = false; | |
436 | break; | |
437 | } | |
438 | } | |
439 | else | |
440 | { | |
441 | // If the read failed and turned the stream to Eof we stop reading. | |
442 | if (zstream_in.Eof()) | |
443 | break; | |
444 | ||
445 | CPPUNIT_ASSERT_MESSAGE("Stream is no longer ok!", zstream_in.IsOk()); | |
446 | } | |
447 | ||
448 | // Don't go over the end of the value buffer... | |
449 | if (i == value_size) | |
450 | { | |
451 | // And if we do then try to see how long the stream actually is. | |
452 | while (!zstream_in.Eof()) | |
453 | { | |
454 | // Move one item along in the stream. | |
455 | (void)zstream_in.GetC(); | |
456 | i++; | |
3e5f6c1c | 457 | |
7735998c VS |
458 | // Check if we are in an infinite loop by multiplying value_size |
459 | // by 5 to have a *much* bigger range then the real range. | |
3e5f6c1c WS |
460 | // Note: Incase you ask your self, why 5, the answer is no reason... |
461 | // it is not to big and not to small a size, nothing more | |
7735998c | 462 | // nothing less to it. |
3e5f6c1c | 463 | if (i > (value_size*5)) |
7735998c VS |
464 | { |
465 | // Note: Please make sure Input_Eof test passed. | |
466 | CPPUNIT_FAIL("Infinite stream detected, breaking the infinite loop"); | |
467 | return; | |
468 | } | |
469 | } | |
470 | } | |
471 | } | |
472 | ||
3e5f6c1c | 473 | CPPUNIT_ASSERT_MESSAGE("Could not decompress the compressed data, original and restored value did not match.", |
7735998c VS |
474 | i == value_size && bValueEq); |
475 | } | |
476 | ||
3e5f6c1c WS |
477 | wxZlibInputStream *zlibStream::DoCreateInStream() |
478 | { | |
340da6ae VS |
479 | const unsigned char *buf = GetCompressedData(); |
480 | m_pTmpMemInStream = new wxMemoryInputStream(buf, m_SizeCompressedData); | |
481 | CPPUNIT_ASSERT(m_pTmpMemInStream->IsOk()); | |
482 | wxZlibInputStream *pzstream_in = new wxZlibInputStream(*m_pTmpMemInStream); | |
483 | CPPUNIT_ASSERT(pzstream_in->IsOk()); | |
484 | return pzstream_in; | |
485 | } | |
486 | wxZlibOutputStream *zlibStream::DoCreateOutStream() | |
3e5f6c1c | 487 | { |
340da6ae VS |
488 | m_pTmpMemOutStream = new wxMemoryOutputStream(); |
489 | CPPUNIT_ASSERT(m_pTmpMemOutStream->IsOk()); | |
490 | wxZlibOutputStream *pzstream_out = new wxZlibOutputStream(*m_pTmpMemOutStream); | |
491 | CPPUNIT_ASSERT(pzstream_out->IsOk()); | |
492 | return pzstream_out; | |
493 | } | |
3e5f6c1c WS |
494 | void zlibStream::DoDeleteInStream() |
495 | { | |
340da6ae VS |
496 | delete m_pTmpMemInStream; |
497 | m_pTmpMemInStream = NULL; | |
498 | } | |
3e5f6c1c WS |
499 | void zlibStream::DoDeleteOutStream() |
500 | { | |
340da6ae VS |
501 | delete m_pTmpMemOutStream; |
502 | m_pTmpMemOutStream = NULL; | |
503 | } | |
504 | ||
7735998c VS |
505 | |
506 | void zlibStream::genExtTestData(wxTextOutputStream &out, const char *buf, int flag) | |
507 | { | |
0e43839c VS |
508 | unsigned char *data; |
509 | size_t size; | |
3e5f6c1c | 510 | |
7735998c VS |
511 | { // Gen data |
512 | wxMemoryOutputStream memstream_out; | |
513 | { | |
514 | wxZlibOutputStream zstream_out(memstream_out, wxZ_DEFAULT_COMPRESSION, flag); | |
515 | zstream_out.Write(buf, strlen(buf)); | |
516 | } | |
517 | if (flag == wxZLIB_NO_HEADER) | |
518 | memstream_out.PutC(' '); | |
3e5f6c1c | 519 | |
7735998c VS |
520 | size = memstream_out.GetSize(); |
521 | data = new unsigned char[size]; | |
522 | memstream_out.CopyTo(data, size); | |
523 | } | |
524 | ||
525 | out << _T("void zlibStream::Decompress_wxXXXData()") << _T("\n"); | |
526 | out << _T("{") << _T("\n") << _T(" const unsigned char data[] = {"); | |
3e5f6c1c | 527 | |
7735998c VS |
528 | size_t i; |
529 | for (i = 0; i < size; i++) | |
530 | { | |
531 | if (i+1 != size) | |
532 | out << wxString::Format(_T("%d,"), data[i]); | |
533 | else | |
534 | out << wxString::Format(_T("%d"), data[i]); | |
3e5f6c1c | 535 | } |
7735998c VS |
536 | delete [] data; |
537 | ||
538 | out << _T("};") << _T("\n"); | |
539 | out << _T(" const char *value = \"") << wxString(buf, wxConvUTF8) << _T("\";") << _T("\n"); | |
540 | out << _T(" const size_t data_size = sizeof(data);") << _T("\n"); | |
541 | out << _T(" const size_t value_size = strlen(value);") << _T("\n"); | |
542 | out << _T(" doDecompress_ExternalData(data, value, data_size, value_size);") << _T("\n"); | |
543 | out << _T("}") << _T("\n"); | |
544 | } | |
545 | ||
546 | ||
340da6ae VS |
547 | // Register the stream sub suite, by using some stream helper macro. |
548 | // Note: Don't forget to connect it to the base suite (See: bstream.cpp => StreamCase::suite()) | |
549 | STREAM_TEST_SUBSUITE_NAMED_REGISTRATION(zlibStream) | |
550 |