]> git.saurik.com Git - wxWidgets.git/blob - tests/streams/zlibstream.cpp
more dmc fixes (patch 941830)
[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 #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