1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Name        : tzlibcases.cpp

    15 // 

    16 //

    17 

    18 #include "tzlib.h"

    19 

    20 //uLong dictId;

    21 

    22 #define CHECK_ERR(err, msg) { \

    23 	if (err != Z_OK) { \

    24 	INFO_PRINTF2(_L("Error: %d"), err); \

    25 	return err; \

    26 	} \

    27 }

    28 

    29 

    30 TInt CTestZlib::PreDeflateInit( Byte * compr, uLong comprLen, TInt flush, TInt compression)

    31 	{

    32 	z_stream c_stream; // compression stream 

    33 	int err;

    34 	const char hello[] = "hello, hello!";

    35 	uLong len = (uLong)strlen(hello)+1;

    36 

    37 	c_stream.zalloc = (alloc_func)0;

    38 	c_stream.zfree = (free_func)0;

    39 	c_stream.opaque = (voidpf)0;

    40 

    41 	err = deflateInit(&c_stream,compression);// Z_DEFAULT_COMPRESSION);

    42 

    43 	if (err != Z_OK) 

    44 		{ 

    45 		INFO_PRINTF2(_L("deflateInit error: %d"), err); 

    46 		return err; 

    47 		} 

    48 

    49 	c_stream.next_in  = (Bytef*)hello;

    50 	c_stream.next_out = compr;

    51 

    52 	while (c_stream.total_in != len && c_stream.total_out < comprLen) 

    53 		{

    54 		c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers 

    55 		err = deflate(&c_stream, flush);

    56 		if (err != Z_OK) 

    57 			{ 

    58 			INFO_PRINTF2(_L("deflate return code: %d"), err); 

    59 			deflateEnd(&c_stream);

    60 			return err; 

    61 			} 

    62 		}

    63 	// Finish the stream, still forcing small buffers: 

    64 	for (;;) 

    65 		{

    66 		c_stream.avail_out = 1;

    67 		err = deflate(&c_stream, Z_FINISH);

    68 		if (err == Z_STREAM_END) break;

    69 		if (err != Z_OK)

    70 			{ 

    71 			INFO_PRINTF2(_L("deflate error: %d"), err); 

    72 			deflateEnd(&c_stream);

    73 			return err; 

    74 			} 

    75 		}

    76 

    77 	deflateEnd(&c_stream);

    78 	return KErrNone;

    79 	}

    80 

    81 /**

    82  * Function Name : TestDeflateTest01

    83  * TestCase Description: 1. Reads flush value more than Z_FINISH [i.e, 4]

    84  *						2. Reads negative flush value 

    85  */

    86 TInt CTestZlib::TestDeflateTest01( )

    87 	{

    88 	INFO_PRINTF1(_L("Zlib Test deflate"));	

    89 	TInt flush, compression, expRet;

    90 

    91 	Byte *comp;

    92 	uLong compLen;

    93 	compLen = 30;

    94 	comp    = (Byte*)calloc((uInt)compLen, 1);

    95 

    96 	ReadIntParam(flush);

    97 	ReadIntParam(compression);

    98 	ReadIntParam(expRet);

    99 

   100 	z_stream c_stream; // compression stream 

   101 	int err;

   102 	const char hello[] = "hello, hello!";

   103 	uLong len = (uLong)strlen(hello)+1;

   104 

   105 	c_stream.zalloc = (alloc_func)0;

   106 	c_stream.zfree = (free_func)0;

   107 	c_stream.opaque = (voidpf)0;

   108 

   109 	err = deflateInit(&c_stream,compression);// Z_DEFAULT_COMPRESSION);

   110 

   111 	if (err != Z_OK) 

   112 		{ 

   113 		INFO_PRINTF2(_L("deflateInit error: %d"), err); 

   114 		free(comp);

   115 		return err; 

   116 		}  

   117 

   118 	c_stream.next_in  = (Bytef*)hello;

   119 	c_stream.next_out = comp;

   120 

   121 	while (c_stream.total_in != len && c_stream.total_out < compLen) 

   122 		{

   123 		c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers 

   124 		err = deflate(&c_stream, flush);

   125 		if (err == Z_STREAM_ERROR) 

   126 			{ 

   127 			INFO_PRINTF1(_L("Negative test case passed"));

   128 			deflateEnd(&c_stream);

   129 			free(comp);

   130 			return KErrNone; 

   131 			}

   132 		}

   133 

   134 	return KErrNone;

   135 

   136 	}

   137 

   138 /**

   139  * Function Name : TestDeflatecopyDestNull

   140  * TestCase Description: Deflate copy with Destination as NULL

   141  */

   142 TInt CTestZlib::TestDeflatecopyDestNull()

   143 	{

   144 	uLong len = (uLong)strlen(hello)+1;

   145 	TInt retVal=0;

   146 	Byte *compr, *uncompr;

   147 	uLong comprLen = 20*sizeof(int); 

   148 	uLong uncomprLen = comprLen;

   149 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   150 	if (compr == Z_NULL)

   151 		{

   152 		return KErrNoMemory;

   153 		}

   154 

   155 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   156 	if (uncompr == Z_NULL) 

   157 		{

   158 		free(compr);

   159 		return KErrNoMemory;

   160 		}	

   161 

   162 

   163 	z_stream stream;

   164 	int err;

   165 

   166 	stream.zalloc = (alloc_func)0;

   167 	stream.zfree = (free_func)0;

   168 	stream.opaque = (voidpf)0;

   169 

   170 	stream.next_in = (Bytef*)hello;

   171 	stream.avail_in = (uInt)len;

   172 

   173 	stream.next_out = compr;

   174 	stream.avail_out = (uInt)comprLen;

   175 

   176 	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);

   177 

   178 	err=deflateCopy(NULL , &stream); 

   179 

   180 	if (err == Z_STREAM_ERROR )  

   181 		{

   182 		deflateEnd(&stream);

   183 		free(compr);

   184 		free(uncompr);

   185 		retVal = KErrNone; 

   186 		} 

   187 

   188 	return retVal;   

   189 	}

   190 

   191 /**

   192  * Function Name : TestDeflateCopyStreamStateNull

   193  * TestCase Description: Deflate copy with source stream state as Z_NULL

   194  * Return value: KErrNone on deflateCopy retruning Z_STREAM_ERROR

   195  */

   196 TInt CTestZlib::TestDeflateCopyStreamStateNull()

   197 	{

   198 	uLong len = (uLong)strlen(hello)+1;

   199 	TInt retVal=0;

   200 	Byte *compr, *uncompr;

   201 	uLong comprLen = 20*sizeof(int); 

   202 	uLong uncomprLen = comprLen;

   203 	compr = (Byte*)calloc((uInt)comprLen, 1);

   204 	if (compr == Z_NULL)

   205 		{

   206 		return KErrNoMemory;

   207 		}

   208 

   209 	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);

   210 	if (uncompr == Z_NULL) 

   211 		{

   212 		free(compr);

   213 		return KErrNoMemory;

   214 		}	    	

   215 

   216 	z_stream stream;

   217 	z_stream stream1;

   218 	int err = KErrNone;

   219 

   220 	stream.zalloc = (alloc_func)0;

   221 	stream.zfree = (free_func)0;

   222 	stream.opaque = (voidpf)0;

   223 

   224 	stream.next_in = (Bytef*)hello;

   225 	stream.avail_in = (uInt)len;

   226 

   227 	stream.next_out = compr;

   228 	stream.avail_out = (uInt)comprLen;

   229 

   230 	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);

   231 

   232 	err=deflateCopy(&stream1, &stream);

   233 	deflateEnd(&stream);

   234 	deflateEnd(&stream1);

   235 

   236 	// Make stream state Z_NULL and call deflateCopy for coverage imrprovement

   237 	stream.state = Z_NULL;

   238 	err=deflateCopy(&stream1 , &stream); 

   239 

   240 	if (err == Z_STREAM_ERROR )

   241 		{

   242 		retVal = KErrNone; 

   243 		}

   244 	free(compr);

   245 	free(uncompr);

   246 	return retVal;   

   247 	}

   248 

   249 /**

   250  * Function Name : TestDeflateInit2_WindowBits

   251  * TestCase Description: 1. WindowBits value more than 15

   252  *						2. WindowBits value less than 8

   253  *						3. WindowBits 8

   254  */

   255 TInt CTestZlib::TestDeflateInit2_WindowBits()

   256 	{

   257 	TInt res = KErrNone;

   258 	z_stream stream;

   259 	int err;

   260 	int level=Z_DEFAULT_COMPRESSION;

   261 	int WindowBits=0;

   262 

   263 	uLong sourceLen = (uLong)strlen(hello)+1;

   264 	Byte *compr;

   265 	uLong comprLen = 10*sizeof(int); 

   266 	compr = (Byte*)calloc((uInt)comprLen, 1);

   267 	if (compr == Z_NULL)

   268 		{

   269 		return KErrNoMemory;

   270 		}

   271 

   272 	ReadIntParam(WindowBits);

   273 	stream.zalloc = (alloc_func)0;

   274 	stream.zfree = (free_func)0;

   275 	stream.opaque = (voidpf)0;

   276 

   277 

   278 	err= deflateInit2_(&stream, level, 8, WindowBits, 8,

   279 			0,  zlibVersion(), sizeof(z_stream));

   280 

   281 	if (err == Z_STREAM_ERROR) 

   282 		{

   283 		res = KErrNone;

   284 		}

   285 	else if (err == Z_OK)

   286 		{

   287 		deflateEnd(&stream);

   288 		res = KErrNone;

   289 		}

   290 	else  

   291 		{    	

   292 		res = KErrGeneral; 

   293 		}       

   294 

   295 	free(compr);

   296 	return res;

   297 	}

   298 

   299 

   300 

   301 /**

   302  * Function Name : TestDeflateInit2_StreamSize

   303  * TestCase Description: Stream size less than sizeof(z_stream)

   304  */

   305 TInt CTestZlib::TestDeflateInit2_StreamSize()

   306 	{

   307 	TInt res = KErrNone ;

   308 	z_stream stream;

   309 	int err;

   310 	int level=Z_DEFAULT_COMPRESSION;

   311 	int WindowBits=0;

   312 

   313 	uLong sourceLen = (uLong)strlen(hello)+1;

   314 	Byte *compr;

   315 	uLong comprLen = 10*sizeof(int); 

   316 	compr = (Byte*)calloc((uInt)comprLen, 1);

   317 	if (compr == Z_NULL)

   318 		{

   319 		return KErrNoMemory;

   320 		}

   321 

   322 	ReadIntParam(WindowBits);

   323 	stream.zalloc = (alloc_func)0;

   324 	stream.zfree = (free_func)0;

   325 	stream.opaque = (voidpf)0;

   326 

   327 	// passing stream size < sizeof(z_stream)

   328 	err= deflateInit2_(&stream, level, 8, 15, 8,

   329 			0,  zlibVersion(), sizeof(z_stream)-10);

   330 

   331 	if (err == Z_VERSION_ERROR) 

   332 		{

   333 		res = KErrNone;

   334 		}

   335 	else  

   336 		{    	

   337 		res = KErrGeneral; 

   338 		}       

   339 

   340 	free(compr);

   341 	return res;

   342 	}

   343 

   344 /**

   345  * Function Name : TestDeflateInit2_MemLevel

   346  * TestCase Description: 1. MemLevel value less than 1

   347  *						2. MemLevel value more than MAX_MEM_LEVEL [i.e., 8]

   348  */

   349 TInt CTestZlib::TestDeflateInit2_MemLevel()

   350 	{

   351 	TInt res = KErrNone ;

   352 	z_stream stream;

   353 	int err;

   354 	int level=Z_DEFAULT_COMPRESSION;

   355 	int MemLevel=0;

   356 

   357 	uLong sourceLen = (uLong)strlen(hello)+1;

   358 	Byte *compr;

   359 	uLong comprLen = 10*sizeof(int); 

   360 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   361 	if (compr == Z_NULL)

   362 		{

   363 		return KErrNoMemory;

   364 		}

   365 

   366 	ReadIntParam(MemLevel);

   367 	stream.zalloc = (alloc_func)0;

   368 	stream.zfree = (free_func)0;

   369 	stream.opaque = (voidpf)0;

   370 

   371 

   372 	err= deflateInit2_(&stream, level, 3, 15, MemLevel,

   373 			0,  zlibVersion(), sizeof(z_stream));

   374 

   375 	if (err == Z_STREAM_ERROR) 

   376 		{

   377 		res = KErrNone;

   378 		} 

   379 	else  

   380 		{    	

   381 		res = KErrGeneral; 

   382 		}       

   383 

   384 	//deflateEnd(&stream);

   385 	free(compr);

   386 	return res;

   387 	}

   388 

   389 /**

   390  * Function Name : TestDeflateInit2_Level

   391  * TestCase Description: 1. Level value less than 0

   392  *						2. Level value more than 9

   393  */

   394 TInt CTestZlib::TestDeflateInit2_Level()

   395 	{

   396 	TInt res = KErrNone ;

   397 	z_stream stream;

   398 	int err;

   399 	int level=0;

   400 

   401 	uLong sourceLen = (uLong)strlen(hello)+1;

   402 	Byte *compr;

   403 	uLong comprLen = 10*sizeof(int); 

   404 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   405 	if (compr == Z_NULL)

   406 		{

   407 		return KErrNoMemory;

   408 		}

   409 

   410 	ReadIntParam(level);

   411 	stream.zalloc = (alloc_func)0;

   412 	stream.zfree = (free_func)0;

   413 	stream.opaque = (voidpf)0;

   414 

   415 

   416 	err= deflateInit2_(&stream, level, 8, 15, 8,

   417 			0,  zlibVersion(), sizeof(z_stream));

   418 

   419 	if (err == Z_STREAM_ERROR) 

   420 		{

   421 		res = KErrNone;

   422 		} 

   423 	else  

   424 		{    	

   425 		res = KErrGeneral; 

   426 		}       

   427 

   428 	//deflateEnd(&stream);

   429 	free(compr);

   430 	return res;

   431 	}

   432 

   433 /**

   434  * Function Name : TestDeflateInit2_Strategy

   435  * TestCase Description: 1. Strategy value less than 0

   436  *						2. Strategy value more than Z_FIXED

   437  */

   438 TInt CTestZlib::TestDeflateInit2_Strategy()

   439 	{

   440 	TInt res = KErrNone ;

   441 	z_stream stream;

   442 	int err;

   443 	int level=Z_DEFAULT_COMPRESSION;

   444 	int strategy=0;

   445 

   446 	uLong sourceLen = (uLong)strlen(hello)+1;

   447 	Byte *compr;

   448 	uLong comprLen = 10*sizeof(int); 

   449 	compr = (Byte*)calloc((uInt)comprLen, 1);

   450 	if (compr == Z_NULL)

   451 		{

   452 		return KErrNoMemory;

   453 		}

   454 

   455 	ReadIntParam(strategy);

   456 	stream.zalloc = (alloc_func)0;

   457 	stream.zfree = (free_func)0;

   458 	stream.opaque = (voidpf)0;

   459 

   460 

   461 	err= deflateInit2_(&stream, level, 8, 15, 8,

   462 			strategy, zlibVersion(), sizeof(z_stream));

   463 

   464 	if (err == Z_STREAM_ERROR) 

   465 		{

   466 		res = KErrNone;

   467 		} 

   468 	else  

   469 		{    	

   470 		res = KErrGeneral; 

   471 		}       

   472 

   473 	free(compr);

   474 	return res;

   475 	}

   476 

   477 /**

   478  * Function Name : TestDeflateInit2_Version

   479  * TestCase Description: Invalid version value

   480  * Return Value: returns Z_VERSION_ERROR

   481  */

   482 TInt CTestZlib::TestDeflateInit2_Version()

   483 	{

   484 	TInt res = KErrNone ;

   485 	z_stream stream;

   486 	int err;

   487 	int level=Z_DEFAULT_COMPRESSION;

   488 	char version[5];

   489 

   490 	uLong sourceLen = (uLong)strlen(hello)+1;

   491 	Byte *compr;

   492 	uLong comprLen = 10*sizeof(int); 

   493 	compr = (Byte*)calloc((uInt)comprLen, 1);

   494 	if (compr == Z_NULL)

   495 		{

   496 		return KErrNoMemory;

   497 		}

   498 

   499 	ReadStringParam(version);

   500 	stream.zalloc = (alloc_func)0;

   501 	stream.zfree = (free_func)0;

   502 	stream.opaque = (voidpf)0;

   503 

   504 

   505 	err= deflateInit2_(&stream, level, 8, 15, 8,

   506 			0, version, sizeof(z_stream));

   507 

   508 	if (err == Z_VERSION_ERROR) 

   509 		{

   510 		res = KErrNone;

   511 		} 

   512 	else  

   513 		{

   514 		res = KErrGeneral; 

   515 		}       

   516 

   517 	free(compr);

   518 	return res;

   519 	}

   520 

   521 /**

   522  * Function Name : TestDeflateInit2_VersionNull

   523  * TestCase Description: version value is Z_NULL

   524  * Return Value: Z_VERSION_ERROR

   525  */

   526 TInt CTestZlib::TestDeflateInit2_VersionNull()

   527 	{

   528 	TInt res = KErrNone ;

   529 	z_stream stream;

   530 	int err;

   531 	int level=Z_DEFAULT_COMPRESSION;

   532 

   533 	uLong sourceLen = (uLong)strlen(hello)+1;

   534 	Byte *compr;

   535 	uLong comprLen = 10*sizeof(int); 

   536 	compr = (Byte*)calloc((uInt)comprLen, 1);

   537 	if (compr == Z_NULL)

   538 		{

   539 		return KErrNoMemory;

   540 		}

   541 

   542 	stream.zalloc = (alloc_func)0;

   543 	stream.zfree = (free_func)0;

   544 	stream.opaque = (voidpf)0;

   545 

   546 

   547 	err= deflateInit2_(&stream, level, 8, 15, 8,

   548 			0, Z_NULL, sizeof(z_stream));

   549 

   550 	if (err == Z_VERSION_ERROR) 

   551 		{

   552 		res = KErrNone;

   553 		} 

   554 	else  

   555 		{	

   556 		res = KErrGeneral; 

   557 		}       

   558 

   559 	free(compr);

   560 	return res;

   561 	}

   562 

   563 

   564 /**

   565  * Function Name : TestDeflateInit2_StreamNull

   566  * TestCase Description: Pass Z_NULL stream

   567  */

   568 TInt CTestZlib::TestDeflateInit2_StreamNull()

   569 	{

   570 	TInt res = KErrNone ;

   571 	//z_stream stream;

   572 	int err;	

   573 	int level=Z_DEFAULT_COMPRESSION;

   574 

   575 	uLong sourceLen = (uLong)strlen(hello)+1;

   576 	Byte *compr;

   577 	uLong comprLen = 10*sizeof(int); 

   578 	compr = (Byte*)calloc((uInt)comprLen, 1);

   579 	if (compr == Z_NULL)

   580 		{

   581 		return KErrNoMemory;

   582 		}

   583 

   584 	//stream.zalloc = (alloc_func)0;

   585 	//stream.zfree = (free_func)0;

   586 	//stream.opaque = (voidpf)0;

   587 

   588 	err= deflateInit2_(Z_NULL, level, 8, 15, 8,

   589 			0,  zlibVersion(), sizeof(z_stream));

   590 

   591 	if (err == Z_STREAM_ERROR) 

   592 		{

   593 		res = KErrNone;

   594 		}

   595 	else  

   596 		{    	

   597 		res = KErrGeneral; 

   598 		}       

   599 

   600 	free(compr);

   601 	return res;

   602 	}

   603 

   604 /**

   605  * Function Name : TestInflateInit2_Version

   606  * TestCase Description: Invalid version value

   607  * Return Value: returns Z_VERSION_ERROR

   608  */

   609 TInt CTestZlib::TestInflateInit2_Version()

   610 	{ 

   611 	TInt res = KErrNone ;

   612 

   613 	z_stream d_stream; // decompression stream

   614 	char version[5];

   615 	d_stream.zalloc = (alloc_func)0;

   616 	d_stream.zfree = (free_func)0;

   617 	d_stream.opaque = (voidpf)0;

   618 

   619 	Byte *compr, *uncompr;

   620 	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS

   621 	uLong uncomprLen = comprLen;

   622 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   623 	if (compr == Z_NULL)

   624 		{

   625 		return KErrNoMemory;

   626 		}

   627 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   628 	if (uncompr == Z_NULL) 

   629 		{

   630 		free(compr);

   631 		return KErrNoMemory;

   632 		}

   633 	res = Test_deflate(compr, comprLen);

   634 	if(res<0)

   635 		{

   636 		free(compr);

   637 		free(uncompr);

   638 		return KErrNoMemory;	

   639 		}

   640 	d_stream.next_in  = compr;

   641 	d_stream.avail_in = 0;

   642 	d_stream.next_out = uncompr;

   643 

   644 	//Reading invalid version from ini file

   645 	ReadStringParam(version);	

   646 

   647 	int ret =  inflateInit2_(&d_stream, 15, version, sizeof(d_stream));

   648 	if(ret == Z_VERSION_ERROR)

   649 		{

   650 		res = KErrNone;    	

   651 		}

   652 	else

   653 		{    	

   654 		res = KErrGeneral;

   655 		}   

   656 	free(compr);

   657 	free(uncompr);

   658 	return res;   

   659 	}

   660 

   661 /**

   662  * Function Name : TestInflateInit2_VersionNull

   663  * TestCase Description: version value is Z_NULL

   664  * Return Value: Z_VERSION_ERROR

   665  */

   666 TInt CTestZlib::TestInflateInit2_VersionNull()

   667 	{ 

   668 	TInt res = KErrNone ;

   669 

   670 	z_stream d_stream; // decompression stream

   671 	d_stream.zalloc = (alloc_func)0;

   672 	d_stream.zfree = (free_func)0;

   673 	d_stream.opaque = (voidpf)0;

   674 

   675 	Byte *compr, *uncompr;

   676 	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS

   677 	uLong uncomprLen = comprLen;

   678 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   679 	if (compr == Z_NULL)

   680 		{

   681 		return KErrNoMemory;

   682 		}

   683 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   684 	if (uncompr == Z_NULL) 

   685 		{

   686 		free(compr);

   687 		return KErrNoMemory;

   688 		}

   689 	res = Test_deflate(compr, comprLen);

   690 	if(res<0)

   691 		{

   692 		free(compr);

   693 		free(uncompr);

   694 		return KErrNoMemory;	

   695 		}

   696 	d_stream.next_in  = compr;

   697 	d_stream.avail_in = 0;

   698 	d_stream.next_out = uncompr;

   699 

   700 	int ret =  inflateInit2_(&d_stream, 15, Z_NULL, sizeof(d_stream));

   701 	if(ret == Z_VERSION_ERROR)

   702 		{

   703 		res = KErrNone;    	

   704 		}

   705 	else

   706 		{    	

   707 		res = KErrGeneral;

   708 		}   

   709 	free(compr);

   710 	free(uncompr);

   711 	return res;   

   712 	}

   713 

   714 /**

   715  * Function Name : TestInflateInit2_WindowBits

   716  * TestCase Description: Window bits more than 48 to increase the conditional coverage

   717  * Return Value: returns Z_STREAM_ERROR

   718  */

   719 TInt CTestZlib::TestInflateInit2_WindowBits()

   720 	{ 

   721 	TInt res = KErrNone ;

   722 

   723 	z_stream d_stream; // decompression stream

   724 	int WindowBits = 0;

   725 	d_stream.zalloc = (alloc_func)0;

   726 	d_stream.zfree = (free_func)0;

   727 	d_stream.opaque = (voidpf)0;

   728 

   729 	Byte *compr, *uncompr;

   730 	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS

   731 	uLong uncomprLen = comprLen;

   732 	compr    = (Byte*)calloc((uInt)comprLen, 1);

   733 	if (compr == Z_NULL)

   734 		{

   735 		return KErrNoMemory;

   736 		}

   737 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   738 	if (uncompr == Z_NULL) 

   739 		{

   740 		free(compr);

   741 		return KErrNoMemory;

   742 		}

   743 	res = Test_deflate(compr, comprLen);

   744 	if(res<0)

   745 		{

   746 		free(compr);

   747 		free(uncompr);

   748 		return KErrNoMemory;	

   749 		}

   750 	d_stream.next_in  = compr;

   751 	d_stream.avail_in = 0;

   752 	d_stream.next_out = uncompr;

   753 

   754 	//Reading window bits from ini file

   755 	ReadIntParam(WindowBits);	

   756 

   757 	int ret =  inflateInit2_(&d_stream, WindowBits, "1.2.4", sizeof(d_stream));

   758 	if(ret == Z_STREAM_ERROR)

   759 		{

   760 		res = KErrNone;    	

   761 		}

   762 	else

   763 		{    	

   764 		res = KErrGeneral;

   765 		}   

   766 	free(compr);

   767 	free(uncompr);

   768 	return res;   

   769 	}

   770 

   771 /**

   772  * Function Name : TestInflateInit2_StreamNull

   773  * TestCase Description: Stream NULL

   774  * Return Value: returns Z_STREAM_ERROR

   775  */

   776 TInt CTestZlib::TestInflateInit2_StreamNull()

   777 	{ 

   778 	TInt res = KErrNone ;

   779 

   780 	z_stream d_stream; // decompression stream

   781 	//d_stream.zalloc = (alloc_func)0;

   782 	//d_stream.zfree = (free_func)0;

   783 	//d_stream.opaque = (voidpf)0;

   784 

   785 	Byte *compr, *uncompr;

   786 	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS

   787 	uLong uncomprLen = comprLen;

   788 	compr = (Byte*)calloc((uInt)comprLen, 1);

   789 	if (compr == Z_NULL)

   790 		{

   791 		return KErrNoMemory;

   792 		}

   793 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

   794 	if (uncompr == Z_NULL) 

   795 		{

   796 		free(compr);

   797 		return KErrNoMemory;

   798 		}

   799 	res = Test_deflate(compr, comprLen);

   800 	if(res<0)

   801 		{

   802 		free(compr);

   803 		free(uncompr);

   804 		return KErrNoMemory;	

   805 		}

   806 	//d_stream.next_in  = compr;

   807 	//d_stream.avail_in = 0;

   808 	//d_stream.next_out = uncompr;

   809 

   810 	int ret =  inflateInit2_(Z_NULL, 15, "1.2.4", sizeof(d_stream));

   811 	if(ret == Z_STREAM_ERROR)

   812 		{

   813 		res = KErrNone;    	

   814 		}

   815 	else

   816 		{    	

   817 		res = KErrGeneral;

   818 		}   

   819 	free(compr);

   820 	free(uncompr);

   821 	return res;   

   822 	}

   823 

   824 /**

   825  * Function Name : TestDeflate_HuffmanStrategy

   826  * TestCase Description: Strategy is HUFFMAN

   827  * Return Value: Z_OK

   828  */

   829 TInt CTestZlib::TestDeflate_HuffmanStrategy()

   830 	{

   831 	TInt res = KErrNone ;

   832 	z_stream stream;

   833 	int err;

   834 	int level=Z_DEFAULT_COMPRESSION;

   835 

   836 	uLong sourceLen = (uLong)strlen(hello)+1;

   837 	Byte *compr;

   838 	uLong comprLen = 20*sizeof(int); 

   839 	compr = (Byte*)calloc((uInt)comprLen, 1);

   840 	if (compr == Z_NULL)

   841 		{

   842 		return KErrNoMemory;

   843 		}

   844 

   845 	stream.zalloc = (alloc_func)0;

   846 	stream.zfree = (free_func)0;

   847 	stream.opaque = (voidpf)0;

   848 

   849 

   850 	err= deflateInit2_(&stream, level, 8, 15, 8,

   851 			2, zlibVersion(), sizeof(z_stream));

   852 

   853 	if (err == Z_OK) 

   854 		{

   855 		res = KErrNone;

   856 		} 

   857 	else  

   858 		{	

   859 		res = KErrGeneral; 

   860 		}

   861 

   862 	stream.next_in  = (Bytef*)hello;

   863 	stream.next_out = compr;

   864 

   865 	while (stream.total_in != sourceLen && stream.total_out < comprLen) 

   866 		{

   867 		stream.avail_in = stream.avail_out = 1; /* force small buffers */

   868 		err = deflate(&stream, Z_NO_FLUSH);

   869 		}

   870 	/* Finish the stream, still forcing small buffers: */

   871 	for (;;) 

   872 		{

   873 		stream.avail_out = 1;

   874 		err = deflate(&stream, Z_FINISH);

   875 		if (err == Z_STREAM_END) break;

   876 		if(err!=Z_OK)

   877 			{

   878 			res = KErrGeneral;

   879 			}    

   880 		}

   881 

   882 	err = deflateEnd(&stream);

   883 	if(err!=Z_OK)

   884 		{

   885 		res = KErrGeneral;

   886 		}     

   887 

   888 	free(compr);

   889 	return res;

   890 	}

   891 

   892 /**

   893  * Function Name : TestDeflate_AvailInZero

   894  * TestCase Description: avail_in value is set to 0

   895  * Return Value: Z_STREAM_ERROR

   896  */

   897 TInt CTestZlib::TestDeflate_AvailInZero()

   898 	{

   899 	TInt res = KErrNone ;

   900 	z_stream stream;

   901 	int err;

   902 	int level=Z_DEFAULT_COMPRESSION;

   903 

   904 	uLong sourceLen = (uLong)strlen(hello)+1;

   905 	Byte *compr;

   906 	uLong comprLen = 20*sizeof(int); 

   907 	compr = (Byte*)calloc((uInt)comprLen, 1);

   908 	if (compr == Z_NULL)

   909 		{

   910 		return KErrNoMemory;

   911 		}

   912 

   913 	stream.zalloc = (alloc_func)0;

   914 	stream.zfree = (free_func)0;

   915 	stream.opaque = (voidpf)0;

   916 

   917 

   918 	err= deflateInit2_(&stream, level, 8, 15, 8,

   919 			0, zlibVersion(), sizeof(z_stream));

   920 

   921 	if (err == Z_OK) 

   922 		{

   923 		res = KErrNone;

   924 		} 

   925 	else  

   926 		{	

   927 		res = KErrGeneral; 

   928 		}

   929 

   930 	stream.next_in  = Z_NULL;

   931 	stream.next_out = Z_NULL;    

   932 

   933 	while (stream.total_in != sourceLen && stream.total_out < comprLen) 

   934 		{

   935 		stream.avail_in = 0;	// Setting avail_in to zero

   936 		stream.avail_out = 1; 	// force small buffers 

   937 		err = deflate(&stream, Z_NO_FLUSH);

   938 		if (err != Z_OK)

   939 			break;

   940 		}

   941 

   942 	if (err == Z_STREAM_ERROR) 

   943 		{

   944 		res = KErrNone;

   945 		deflateEnd(&stream);

   946 		free(compr);

   947 		return res;

   948 		} 

   949 	else  

   950 		{	

   951 		res = KErrGeneral; 

   952 		free(compr);

   953 		}	   

   954 

   955 	return res;

   956 	}

   957 

   958 /**

   959  * Function Name : TestGzsetparamDefaultCompression

   960  * TestCase Description: This test case is intended to cover the condition in

   961  *						deflateParams_r. Z_DEFAULT_COMPRESSION and strategy>4 is passed

   962  * Return Value: Z_STREAM_ERROR

   963  */

   964 TInt CTestZlib::TestGzsetparamDefaultCompression()

   965 	{

   966 	TInt res = KErrNone ;

   967 

   968 	int len = (int)strlen(hello)+1;

   969 	gzFile file;

   970 

   971 	const char * fname = TESTFILE;

   972 

   973 	file = gzopen(fname, "wb");

   974 	gzputc(file, 'h');

   975 

   976 	int u = gzsetparams(file, Z_DEFAULT_COMPRESSION, 8);

   977 	if(u == Z_STREAM_ERROR)

   978 		{

   979 		res=KErrNone;	

   980 		}

   981 	int err=  gzclose(file);

   982 	if (err != Z_OK)  

   983 		{

   984 		res = KErrGeneral; 

   985 		} 

   986 

   987 	return res;

   988 	}

   989 

   990 /**

   991  * Function Name : TestDeflateResetNullStream

   992  * TestCase Description: Pass NULL stream

   993  * Return Value: Z_STREAM_ERROR

   994  */  	

   995 TInt CTestZlib::TestDeflateResetNullStream()

   996 	{ 

   997 	INFO_PRINTF1(_L("DeflateReset test with NULL input"));

   998 	TInt res = KErrNone ;

   999 	int level = Z_DEFAULT_COMPRESSION ;

  1000 	uLong len = (uLong)strlen(hello)+1;

  1001 	Byte *compr, *uncompr;

  1002 	uLong comprLen = 20*sizeof(int); 

  1003 	uLong uncomprLen = comprLen;

  1004 	int err;

  1005 	z_stream stream;

  1006 	compr    = (Byte*)calloc((uInt)comprLen, 1);

  1007 	if (compr == Z_NULL)

  1008 		{

  1009 		return KErrNoMemory;

  1010 		}

  1011 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

  1012 	if (uncompr == Z_NULL) 

  1013 		{

  1014 		free(compr);

  1015 		return KErrNoMemory;

  1016 		}

  1017 

  1018 	stream.zalloc = (alloc_func)0;

  1019 	stream.zfree = (free_func)0;

  1020 	stream.opaque = (voidpf)0;

  1021 

  1022 	err = deflateInit(&stream, level);

  1023 	if (err != Z_OK) 

  1024 		{

  1025 		free(compr);

  1026 		free(uncompr);

  1027 		return err;

  1028 		}

  1029 

  1030 	Bytef *dest = compr ;

  1031 	uLongf *destLen = &comprLen;

  1032 	const Bytef *source = (const Bytef*)hello;

  1033 	uLong sourceLen = len;  

  1034 

  1035 	stream.next_in = (Bytef*)source;

  1036 	stream.avail_in = (uInt)sourceLen;

  1037 

  1038 #ifdef MAXSEG_64K

  1039 	/* Check for source > 64K on 16-bit machine: */

  1040 	if ((uLong)stream.avail_in != sourceLen)  

  1041 		{

  1042 		res = KErrGeneral; 

  1043 		}

  1044 #endif

  1045 

  1046 	stream.next_out = dest;

  1047 	stream.avail_out = (uInt)*destLen;

  1048 

  1049 	if ((uLong)stream.avail_out != *destLen)  

  1050 		{

  1051 		res = KErrGeneral; 

  1052 		}

  1053 

  1054 	err=deflateReset(Z_NULL/*&stream*/);

  1055 	if (err == Z_STREAM_ERROR)  

  1056 		{

  1057 		res = KErrNone;     			

  1058 		} 

  1059 	else  

  1060 		{    	

  1061 		res = KErrGeneral;

  1062 		}   

  1063 	deflateEnd(&stream);

  1064 	free(compr);

  1065 	free(uncompr);

  1066 	return res;

  1067 	}

  1068 

  1069 /**

  1070  * Function Name : TestDeflateResetStreamStateNull

  1071  * TestCase Description: Pass NULL stream state

  1072  * Return Value: Z_STREAM_ERROR

  1073  */  	

  1074 TInt CTestZlib::TestDeflateResetStreamStateNull()

  1075 	{ 

  1076 	TInt res = KErrNone ;

  1077 	int level = Z_DEFAULT_COMPRESSION ;

  1078 	uLong len = (uLong)strlen(hello)+1;

  1079 	Byte *compr, *uncompr;

  1080 	uLong comprLen = 20*sizeof(int); 

  1081 	uLong uncomprLen = comprLen;

  1082 	int err;

  1083 	z_stream stream;

  1084 	compr    = (Byte*)calloc((uInt)comprLen, 1);

  1085 	if (compr == Z_NULL)

  1086 		{

  1087 		return KErrNoMemory;

  1088 		}

  1089 	uncompr  = (Byte*)calloc((uInt)uncomprLen, 1);

  1090 	if (uncompr == Z_NULL) 

  1091 		{

  1092 		free(compr);

  1093 		return KErrNoMemory;

  1094 		}

  1095 

  1096 	stream.zalloc = (alloc_func)0;

  1097 	stream.zfree = (free_func)0;

  1098 	stream.opaque = (voidpf)0;

  1099 

  1100 	err = deflateInit(&stream, level);

  1101 	if (err != Z_OK) 

  1102 		{

  1103 		free(compr);

  1104 		free(uncompr);

  1105 		return err;

  1106 		}

  1107 

  1108 	Bytef *dest = compr ;

  1109 	uLongf *destLen = &comprLen;

  1110 	const Bytef *source = (const Bytef*)hello;

  1111 	uLong sourceLen = len;  

  1112 

  1113 	stream.next_in = (Bytef*)source;

  1114 	stream.avail_in = (uInt)sourceLen;

  1115 

  1116 #ifdef MAXSEG_64K

  1117 	/* Check for source > 64K on 16-bit machine: */

  1118 	if ((uLong)stream.avail_in != sourceLen)  

  1119 		{

  1120 		res = KErrGeneral; 

  1121 		}

  1122 #endif

  1123 

  1124 	stream.next_out = dest;

  1125 	stream.avail_out = (uInt)*destLen;

  1126 

  1127 	if ((uLong)stream.avail_out != *destLen)  

  1128 		{

  1129 		res = KErrGeneral; 

  1130 		}

  1131 

  1132 	err=deflateReset(&stream);

  1133 	deflateEnd(&stream);

  1134