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        : tzlibadvanced.cpp

    15 // 

    16 //

    17 

    18 #include "tzlib.h"

    19 #include "zutil.h"

    20 //#include "deflate.h"

    21 

    22 #define COMPRESSED_DATA_BUFFER_LENGTH 200*sizeof(int) 

    23 #define FAILURE_RATE_LIMIT 100

    24 #define TEST_MID_MEM_LEVEL 5

    25 

    26 // Add this to the windowBits value to use a GZip header instead of a Zlib header

    27 #define TEST_GZIP_HEADER 16

    28 

    29 // Add this to the windowBits when calling inflateInit2() to use automatic header detection

    30 #define TEST_AUTO_HEADER_DETECTION 32

    31 

    32 #define CHECK_CONDITION0L(condition, leaveErr, errMessage) \

    33 	if (condition) \

    34 		{ \

    35 		ERR_PRINTF1(_L(errMessage)); \

    36 		User::Leave(leaveErr); \

    37     	}

    38 

    39 #define CHECK_CONDITION1L(condition, leaveErr, errMessage, p1) \

    40 	if (condition) \

    41 		{ \

    42 		ERR_PRINTF2(_L(errMessage), p1); \

    43 		User::Leave(leaveErr); \

    44     	}

    45 

    46 _LIT(KParam1, "Param1");

    47 _LIT(KParam2, "Param2");

    48 _LIT(KParam3, "Param3");

    49 _LIT(KParam4, "Param4");

    50 

    51 // bufferDescriptor holds extra information required by in_func and out_func to perform their jobs

    52 struct bufferDescriptor

    53 	{

    54 	Byte *buffer;

    55 	int next;

    56 	int length;

    57 	};

    58 

    59 /*

    60  * Helper member function that sets up the deflate stream for use.

    61  */

    62 void CTestZlib::DeflateInitL(z_stream &aStream, const int aLevel, const int expectedResult)

    63 	{

    64 	TInt err = Z_OK;

    65 	

    66 	aStream.zalloc = Z_NULL;

    67 	aStream.zfree = Z_NULL;

    68 	aStream.opaque = Z_NULL;

    69     

    70 	err = deflateInit(&aStream, aLevel);

    71 	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit error: %d", err);

    72 	}

    73 

    74 /*

    75  * Helper member function that sets up the deflate stream for use.

    76  */

    77 void CTestZlib::DeflateInit2L(z_stream &aStream, const int aLevel, const int aMethod, const int aWindowBits, const int aMemLevel, const int aStrategy, const int expectedResult)

    78 	{

    79 	int err;

    80 	

    81 	aStream.zalloc = Z_NULL;

    82 	aStream.zfree = Z_NULL;

    83 	aStream.opaque = Z_NULL;

    84     

    85 	err =  deflateInit2(&aStream, aLevel, aMethod, aWindowBits, aMemLevel, aStrategy);

    86 	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit2 error: %d", err);

    87 	}

    88 

    89 /*

    90  * Helper member function that compresses data using the deflate function.

    91  */

    92 TInt CTestZlib::DeflateCompress(z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength)

    93 	{

    94 	int err;

    95 	int flush;

    96 	

    97 	// Compress data in the input buffer and place compressed data in the output buffer

    98 	aStream.next_in  = aInputData;

    99 	aStream.next_out = aCompressedDataBuffer; 

   100     

   101     do 

   102     	{

   103     	if (aStream.total_in < aInputDataLength)

   104     		{

   105 			aStream.avail_in = 1; // force small buffer

   106     		}

   107     	

   108     	flush = (aStream.total_in == aInputDataLength) ?  Z_FINISH : Z_NO_FLUSH;

   109     	

   110 	    // Run deflate() on input until output buffer not full

   111     	// Finish compression if all of input buffer has been read in

   112 	    do 

   113 	    	{

   114 	    	if (aStream.total_out < aCompressedDataBufferLength)

   115 	    		{

   116 				aStream.avail_out = 1; // force small buffer

   117 	    		}

   118 

   119 	        err = deflate(&aStream, flush); 

   120 	        if(err != Z_OK && err != Z_STREAM_END) 

   121 	    		{ 

   122 	    		return err; 

   123 	    	    } 

   124 	    	} while(aStream.avail_out == 0 && err == Z_OK);

   125     	} while(err != Z_STREAM_END); 

   126     

   127     return Z_OK;

   128 	}

   129 

   130 /*

   131  * Helper member function that cleans up a deflate stream.

   132  */

   133 void CTestZlib::DeflateEnd(TAny *aStream)

   134 	{

   135 	if(((z_stream *)aStream)->state != NULL)

   136 		{

   137 		deflateEnd((z_stream *)aStream);  

   138 		}

   139 	}

   140 

   141 /*

   142  * Helper member function that sets up the inflate stream for use.

   143  */

   144 void CTestZlib::InflateInitL(z_stream &aStream, const int expectedResult)

   145 	{

   146 	TInt err = Z_OK;

   147 	

   148 	aStream.zalloc = Z_NULL;

   149 	aStream.zfree = Z_NULL;

   150 	aStream.opaque = Z_NULL;

   151     

   152 	err = inflateInit(&aStream);

   153 	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit error: %d", err);	

   154 	}

   155 

   156 /*

   157  * Helper member function that sets up the inflate stream for use.

   158  */

   159 void CTestZlib::InflateInit2L(z_stream &aStream, const int aWindowBits, const int expectedResult)

   160 	{

   161 	TInt err = Z_OK;

   162 	

   163 	aStream.zalloc = Z_NULL;

   164 	aStream.zfree = Z_NULL;

   165 	aStream.opaque = Z_NULL;

   166     

   167 	err = inflateInit2(&aStream, aWindowBits);

   168 	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit2 error: %d", err);

   169 	}

   170 

   171 void CTestZlib::InflateBackInitL(z_stream &aStream, const int aWindowBits, Bytef *aWindow, const int expectedResult)

   172 	{

   173 	int err;

   174 	

   175 	aStream.zalloc = Z_NULL;

   176 	aStream.zfree = Z_NULL;

   177 	aStream.opaque = Z_NULL;

   178 	

   179 	err = inflateBackInit(&aStream, aWindowBits, aWindow);

   180 	CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateBackInit error: %d", err);

   181 	}

   182 

   183 /*

   184  * Helper member function that decompresses data using the inflate function.

   185  */

   186 TInt CTestZlib::InflateDecompress(z_stream &aStream, Byte *aCompressedDataBuffer, int aCompressedDataLength, Byte *aDecompressedDataBuffer, int aDecompressedDataBufferLength)

   187 	{

   188 	int err;

   189 	

   190 	// Decompress data in the aCompressedDataBuffer and place it in the aDecompressedDataBuffer

   191 	aStream.next_in  = aCompressedDataBuffer;

   192 	aStream.next_out = aDecompressedDataBuffer;    

   193     

   194 	// Keep providing input data and output space for deflate()

   195 	do 

   196 		{

   197 		if(aStream.total_in < aCompressedDataLength)

   198     		{

   199     		aStream.avail_in = 1; // force small buffer 

   200     		}

   201 

   202 		if (aStream.total_out < aDecompressedDataBufferLength)

   203     		{

   204 			aStream.avail_out = 1; // force small buffer

   205     		}

   206     	

   207         err = inflate(&aStream, Z_NO_FLUSH); 

   208         if(err != Z_OK && err != Z_STREAM_END) 

   209     		{  

   210     		return err; 

   211     	    } 

   212 		} while(err != Z_STREAM_END); 

   213 	

   214 	return Z_OK;

   215 	}

   216 

   217 /*

   218  * Helper member function that cleans up a inflate stream.

   219  */

   220 void CTestZlib::InflateEnd(TAny *aStream)

   221 	{

   222 	if(((z_stream *)aStream)->state != NULL)

   223 		{

   224 		inflateEnd((z_stream *)aStream);  

   225 		}

   226 	}

   227 

   228 /*

   229  * Helper member function that cleans up an inflate back stream.

   230  */

   231 void CTestZlib::InflateBackEnd(TAny *aStream)

   232 	{

   233 	if(((z_stream *)aStream)->state != NULL)

   234 		{

   235 		inflateBackEnd((z_stream *)aStream);  

   236 		}

   237 	}

   238 

   239 /*

   240  * Helper member function that compares the contents of two GZip headers to make

   241  * sure they are the same.

   242  */

   243 TBool CTestZlib::GZipHeadersEqual(const gz_header &header1, const gz_header &header2)

   244 	{

   245 	TBool headersEqual = true;

   246 	

   247 	if(header1.text != header2.text)

   248 		{

   249 		INFO_PRINTF3(_L("readGZipHeader.text - Expected %d and got %d"), header1.text, header2.text);

   250 		headersEqual = false;

   251 		}

   252 	

   253 	if(header1.time != header2.time)

   254 		{

   255 		INFO_PRINTF3(_L("readGZipHeader.time - Expected %d and got %d"), header1.time, header2.time);

   256 		headersEqual = false;

   257 		}

   258 	

   259 	if(header1.xflags != header2.xflags)

   260 		{

   261 		INFO_PRINTF3(_L("readGZipHeader.xflags - Expected %d and got %d"), header1.xflags, header2.xflags);

   262 		headersEqual = false;

   263 		}

   264 	

   265 	if(header1.os != header2.os)

   266 		{

   267 		INFO_PRINTF3(_L("readGZipHeader.os - Expected %d and got %d"), header1.os, header2.os);

   268 		headersEqual = false;

   269 		}

   270 

   271 	if(header1.extra != NULL & header2.extra != NULL)

   272 		{

   273 		if(header1.extra_len != header2.extra_len)

   274 			{

   275 			INFO_PRINTF1(_L("readGZipHeader.extra_len - Unexpected value."));

   276 			headersEqual = false;

   277 			}

   278 		else if(memcmp(header1.extra, header2.extra, header1.extra_len) != 0)

   279 			{

   280 			INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value."));

   281 			headersEqual = false;

   282 			}

   283 		}

   284 	else if(header1.extra == NULL && header2.extra != NULL

   285 			|| header1.extra != NULL && header2.extra == NULL)

   286 		{

   287 		INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value."));

   288 		headersEqual = false;

   289 		}

   290 	

   291 	if(header1.name != NULL && header2.name != NULL)

   292 		{

   293 		if(strcmp((char *)header1.name, (char *)header2.name) != 0)

   294 			{

   295 			INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. The headers contained different strings."));

   296 			headersEqual = false;

   297 			}

   298 		}

   299 	else if((header1.name == NULL && header2.name != NULL)

   300 			|| (header1.name != NULL && header2.name == NULL))

   301 		{

   302 		INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. One of the headers contained a NULL value."));

   303 		headersEqual = false;

   304 		}

   305 	

   306 	if(header1.comment != NULL && header2.comment != NULL)

   307 		{

   308 		if(strcmp((char *)header1.comment, (char *)header2.comment) != 0)

   309 			{

   310 			INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. The headers contained different strings."));

   311 			headersEqual = false;

   312 			}

   313 		}

   314 	else if((header1.comment == NULL && header2.comment != NULL)

   315 			|| (header1.comment != NULL && header2.comment == NULL))

   316 		{

   317 		INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. One of the headers contained a NULL value."));

   318 		headersEqual = false;

   319 		}

   320 	

   321 	if(header1.hcrc != header2.hcrc)

   322 		{

   323 		INFO_PRINTF3(_L("readGZipHeader.hcrc - Expected %d and got %d"), header1.hcrc, header2.hcrc);

   324 		headersEqual = false;

   325 		}

   326 

   327 	if(header1.done != header2.done)

   328 		{

   329 		INFO_PRINTF3(_L("readGZipHeader.done - Expected %d and got %d"), header1.done, header2.done);

   330 		headersEqual = false;

   331 		}

   332 	

   333 	return headersEqual;

   334 	}

   335 

   336 /*

   337  * Helper member function that checks to see if the header is the default GZip header

   338  */

   339 TBool CTestZlib::IsDefaultGZipHeader(const gz_header &header)

   340 	{

   341 	gz_header defaultHeader;

   342 	

   343 	// gz_header default values

   344 	defaultHeader.text = 0;

   345 	defaultHeader.time = 0;

   346 	defaultHeader.xflags = 0;

   347 	defaultHeader.os = OS_CODE;

   348 	defaultHeader.extra = NULL;

   349 	defaultHeader.name = NULL;

   350 	defaultHeader.comment = NULL;

   351 	defaultHeader.hcrc = 0;

   352 	defaultHeader.done = 1;

   353 	

   354 	return GZipHeadersEqual(defaultHeader, header);

   355 	}

   356 

   357 /*

   358  * Helper member function that compresses an input buffer and place it in a compressed output buffer

   359  */

   360 void CTestZlib::CompressDataL(StreamSettings &aStreamSettings, z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength, gz_headerp aHeader)

   361 	{

   362 	TInt err = Z_OK;

   363 	

   364 	// Initialise the deflate stream

   365 	if(aStreamSettings.deflateInit2 == false)

   366 		{

   367 		this->DeflateInitL(aStream, aStreamSettings.level);

   368 		}

   369 	else

   370 		{

   371 		this->DeflateInit2L(aStream, aStreamSettings.level, aStreamSettings.method, aStreamSettings.deflateWindowBits, aStreamSettings.memLevel, aStreamSettings.strategy);

   372 		}

   373 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &aStream));

   374 	

   375 	// If a GZip header is specified insert the gzip header information to the 

   376 	// start of the output when deflate is called

   377 	if(aHeader != NULL)

   378 		{

   379 		err = deflateSetHeader(&aStream, aHeader);

   380 		CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateSetHeader error: %d", err);

   381 		}

   382 	

   383 	// Compress the input

   384 	err = this->DeflateCompress(aStream, aInputData, aInputDataLength, aCompressedDataBuffer, aCompressedDataBufferLength);

   385 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err);

   386 	

   387 	// Clean up the deflateStream

   388 	err = deflateEnd(&aStream);

   389 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err);

   390 	CleanupStack::Pop(1);

   391 	}

   392 

   393 /*

   394  * Helper function that deflates some input data as a gzip stream and then inflates 

   395  * the compressed data.

   396  */

   397 TVerdict CTestZlib::DefInfGZipHeaderL(const TBool aIgnoreHeader, const TBool aAutoDetectHeader, gz_headerp aSpecifiedGZipHeader)

   398 	{

   399 	int err = Z_OK;

   400 	TVerdict verdict = EPass;

   401 	

   402 	// Streams

   403 	z_stream deflateStream;

   404 	z_stream inflateStream;

   405 	

   406 	// Headers

   407 	gz_header readGZipHeader;

   408 	readGZipHeader.extra = NULL;

   409 	readGZipHeader.name = NULL;

   410 	readGZipHeader.comment = NULL;

   411 	

   412 	// Buffers

   413 	const char inputData[] = "This is a piece of data to compress.\0"; // data to compress

   414     uLong inputDataLength = (uLong)strlen(inputData) + 1;     

   415     Byte *compressedDataBuffer = NULL;

   416     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

   417     Byte *decompressedDataBuffer = NULL;  

   418     uLong decompressedDataBufferLength = inputDataLength;

   419     

   420     // deflateInit2 and inflateInit2 arguments

   421     StreamSettings streamSettings;

   422     streamSettings.deflateInit2 = true;

   423     streamSettings.level = Z_DEFAULT_COMPRESSION;

   424     streamSettings.method = Z_DEFLATED;

   425     streamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

   426     streamSettings.inflateWindowBits = MAX_WBITS;

   427     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

   428     streamSettings.strategy = Z_DEFAULT_STRATEGY;

   429 

   430     streamSettings.inflateWindowBits += (aAutoDetectHeader == true) ? TEST_AUTO_HEADER_DETECTION : TEST_GZIP_HEADER;

   431 

   432     compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

   433     CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer.");

   434     CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer));

   435     

   436     decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte));

   437     CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer.");

   438     CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer));

   439     

   440     // Allocate memory, if required, for readGZipHeader if header data is being 

   441     // checked and if a specified GZip header has been given. This is because 

   442     // extra, name and comment may have been set in the specified GZip header.

   443     if(aIgnoreHeader == false && aSpecifiedGZipHeader != NULL) 

   444     	{

   445     	if(aSpecifiedGZipHeader->extra != NULL)

   446     		{

   447     		readGZipHeader.extra_max = aSpecifiedGZipHeader->extra_max;

   448     		readGZipHeader.extra = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->extra_max * sizeof(Bytef));

   449     		CHECK_CONDITION0L(readGZipHeader.extra == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.extra.");

   450 		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.extra));

   451     		}

   452 

   453     	if(aSpecifiedGZipHeader->name != NULL)

   454     		{

   455     		readGZipHeader.name_max = aSpecifiedGZipHeader->name_max;

   456 		    readGZipHeader.name = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->name_max * sizeof(Bytef));

   457 		    CHECK_CONDITION0L(readGZipHeader.name == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.name.");

   458 		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.name));

   459     		}

   460 

   461     	if(aSpecifiedGZipHeader->comment != NULL)

   462     		{

   463     		readGZipHeader.comm_max = aSpecifiedGZipHeader->comm_max;

   464 		    readGZipHeader.comment = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->comm_max * sizeof(Bytef));

   465 		    CHECK_CONDITION0L(readGZipHeader.comment == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.comment.");

   466 		    CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.comment));

   467     		}

   468     	}

   469 	this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength, aSpecifiedGZipHeader);

   470 

   471 	// Initialise the inflateStream

   472 	this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits);

   473 	CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream));

   474 

   475 	// If the header information is not to be ignored get the GZip 

   476 	// header information when inflate is called

   477 	if(aIgnoreHeader == false)

   478 		{

   479 		err = inflateGetHeader(&inflateStream, &readGZipHeader);

   480 		CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateGetHeader error: %d", err);

   481 		}

   482 

   483 	err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength);

   484 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err);

   485 

   486 	// Clean up the inflateStream

   487 	err = inflateEnd(&inflateStream);

   488 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err);

   489 	CleanupStack::Pop(1);

   490 	

   491 	// If the header information hasn't been ignored Check the GZip header 

   492 	// contains the expected information

   493 	if(aIgnoreHeader == false)

   494 		{

   495 		if(aSpecifiedGZipHeader != NULL)

   496 			{

   497 			verdict = GZipHeadersEqual(*aSpecifiedGZipHeader, readGZipHeader) ? EPass : EFail;

   498 			}

   499 		else

   500 			{

   501 			verdict = IsDefaultGZipHeader(readGZipHeader) ? EPass : EFail;

   502 			}

   503 		}

   504 

   505 	if(readGZipHeader.comment != NULL)

   506 		{

   507 		CleanupStack::PopAndDestroy(1);

   508 		}

   509 	

   510 	if(readGZipHeader.name != NULL)

   511 		{

   512 		CleanupStack::PopAndDestroy(1);

   513 		}

   514 	

   515 	if(readGZipHeader.extra != NULL)

   516 		{

   517 		CleanupStack::PopAndDestroy(1);

   518 		}

   519 

   520 	// Free buffers

   521 	CleanupStack::PopAndDestroy(2);

   522 	    

   523 	return verdict;

   524 	}

   525 

   526 /*

   527  * Helper function that deflates some input data as a gzip stream with a specified header

   528  * and then inflates the compressed data.

   529  */

   530 TVerdict CTestZlib::DefInfGZipSpecifiedHeaderL(TBool aIgnoreHeader, TBool aAutoDetectHeader)

   531 	{

   532 	gz_header specifiedGZipHeader;

   533 	

   534 	Bytef extra[] = "12345"; 

   535 	Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0";  

   536 	Bytef comment[] = "This is a test comment.\0"; 

   537 

   538 	// gz_header user specified values. Set the specifiedGZipHeader ready for deflateSetHeader

   539 	specifiedGZipHeader.text = 1;

   540 	specifiedGZipHeader.time = 101;

   541 	specifiedGZipHeader.xflags = 0; // Set so that the value can be compared to the value in the header read from the deflated data

   542 	specifiedGZipHeader.os = 1; // Amiga

   543 	specifiedGZipHeader.extra = extra;

   544 	specifiedGZipHeader.extra_len = TEST_MID_MEM_LEVEL;

   545 	specifiedGZipHeader.extra_max = specifiedGZipHeader.extra_len + 10; // Add extra 10 to check readGZipHeader.extra_len is set properly

   546 	specifiedGZipHeader.name = name;

   547 	specifiedGZipHeader.name_max = strlen((char *)name) + 1;

   548 	specifiedGZipHeader.comment = comment;

   549 	specifiedGZipHeader.comm_max = strlen((char *)comment) + 1;

   550 	specifiedGZipHeader.hcrc = 0;

   551 	specifiedGZipHeader.done = 1; // Finished reading header. Set so that the value can be compared to the value in the header read from the deflated data

   552 	

   553 	return DefInfGZipHeaderL(aIgnoreHeader, aAutoDetectHeader, &specifiedGZipHeader);

   554 	}

   555 

   556 /**

   557 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4259

   558 @SYMTestCaseDesc     	To ensure deflation works after tuning the deflate stream using 

   559                         deflateTune().

   560 @SYMTestPriority     	Medium

   561 @SYMTestActions      	1.	Create a stream and initialise it. 

   562                         2.	Call deflateTune() passing it the specified parameters.

   563                         3.	Check the state of the stream to make sure that the values 

   564                             are identical to the specified parameters. Also check that 

   565                             Z_OK is returned.

   566                         4.	Deflate the input and cleanup using deflateEnd(), checking 

   567                             Z_OK is returned.

   568                         

   569                         Note: The test should be repeated for deflateInit() parameter values:

   570                         •	3 and 4 for level

   571                         

   572                         and for deflateTune() parameter values:

   573                         •	0 and a high value for good_length

   574                         •	0 and a high value for max_lazy

   575                         •	0 and a high value for nice_length

   576                         •	0 and a high value for max_chain                        

   577                         Appropriate high values can be picked based on the global 

   578                         configuration_table array in deflate.cpp.

   579 @SYMTestExpectedResults deflateTune() should return Z_OK and the input should be compressed.

   580 @SYMDEF                 REQ7362

   581 */

   582 TVerdict CTestZlib::TestDeflateTuneL()

   583 	{	

   584 	int err = Z_OK;

   585 	TBool ret;

   586 	

   587 	// Streams

   588 	z_stream deflateStream;

   589 	

   590 	// Buffers

   591 	const char inputData[] = "This is a piece of data to compress.\0";

   592     uLong inputDataLength = (uLong)strlen(inputData) + 1;     

   593     Byte *compressedDataBuffer;

   594     

   595     // deflateInit arguments

   596     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

   597     int level = Z_DEFAULT_COMPRESSION;	

   598 	int goodLength = 0;

   599     int maxLazy = 0;

   600     int niceLength = 0;

   601     int maxChain = 0;

   602 	

   603     // Allocate memory for output buffer

   604     compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

   605     CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for output buffer.");

   606     CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer));

   607 

   608 	// Read in the values for deflate tune from the ini file

   609 	ret = GetIntFromConfig(ConfigSection(), KParam1, goodLength);

   610 	CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param1 from ini file");

   611 	

   612 	ret = GetIntFromConfig(ConfigSection(), KParam2, maxLazy);

   613 	CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param2 from ini file");

   614 	

   615 	ret = GetIntFromConfig(ConfigSection(), KParam3, niceLength);

   616 	CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param3 from ini file");

   617 	

   618 	ret = GetIntFromConfig(ConfigSection(), KParam4, maxChain);

   619 	CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param4 from ini file");

   620 	

   621 	 // Initialise the stream

   622 	this->DeflateInitL(deflateStream, level);

   623 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream));

   624 	

   625 	// Tune the deflate stream

   626 	err = deflateTune(&deflateStream, goodLength, maxLazy, niceLength, maxChain);

   627 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateTune error: %d", err);

   628 	

   629 	// Check deflateTune has set the streams state values correctly

   630 	/*

   631 	internal_state *s = deflateStream.state;

   632 	CHECK_CONDITION0L(s->good_match != goodLength || s->max_lazy_match != maxLazy || s->nice_match != niceLength || s->max_chain_length != maxChain, KErrGeneral, "deflateTune did not set the stream->state values correctly");

   633 	*/

   634 

   635 	err = this->DeflateCompress(deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength);

   636 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err);

   637 	

   638 	// Clean up the deflate stream

   639 	err = deflateEnd(&deflateStream);

   640 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err);

   641 	CleanupStack::Pop(1);

   642 

   643 	// Free buffer

   644 	CleanupStack::PopAndDestroy(1);  

   645 	

   646 	return EPass;

   647 	}

   648 

   649 /**

   650 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4260

   651 @SYMTestCaseDesc     	Check deflateTune() fails when given an invalid stream.

   652 @SYMTestPriority     	Medium

   653 @SYMTestActions      	1.	Create a stream and initialise it.

   654                         2.	Call deflateTune() passing it parameter values:

   655                             a.	NULL for the stream argument

   656                             b.	a stream whose state is NULL for the stream argument

   657 @SYMTestExpectedResults deflateTune() fails returning Z_STREAM_ERROR in both cases.

   658 @SYMDEF                 REQ7362

   659 */

   660 

   661 TVerdict CTestZlib::TestDeflateTuneFailL()

   662 	{

   663 	int err = Z_OK;

   664 	

   665 	// Streams

   666 	z_stream deflateStream;

   667 	

   668 	// deflateInit2 arguments

   669 	int level = Z_DEFAULT_COMPRESSION;	

   670 	

   671 	// Initialise the stream

   672 	this->DeflateInitL(deflateStream, level);

   673 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream));

   674 	

   675 	// Try tuning a NULL deflate stream

   676 	err = deflateTune(NULL, 0, 0, 0, 0);

   677 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateTune on a NULL stream returned an unexpected value: %d", err);

   678 	

   679 	// Keep a pointer to the streams state so we can clean up properly with deflateEnd()

   680 	internal_state *deflateState  = deflateStream.state;

   681 	

   682 	// Try tuning a deflate stream that has a NULL state

   683 	deflateStream.state = NULL;

   684 	err = deflateTune(&deflateStream, 0, 0, 0, 0);

   685 	deflateStream.state = deflateState;

   686 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateTune on a stream with a NULL state returned an unexpected value: %d", err);

   687 	

   688 	// Clean up the deflate stream

   689 	err = deflateEnd(&deflateStream);

   690 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err);

   691 	CleanupStack::Pop(1);

   692 	

   693 	return EPass;

   694 	}

   695 

   696 /**

   697 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4261

   698 @SYMTestCaseDesc     	Check input can be compressed and decompressed with default gzip 

   699                         header not being read.

   700 @SYMTestPriority     	High

   701 @SYMTestActions      	1.	Create a deflate stream and initialise it using deflateInit2(), 

   702                             adding 16 to windowBits.

   703                         2.	Deflate the input and cleanup using deflateEnd(). 

   704                         3.	Create an inflate stream and initialise it using inflateInit2(), 

   705                             adding 16 to windowBits.

   706                         4.	Inflate the input and cleanup using inflateEnd().

   707 @SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and 

   708                         decompressed with inflateEnd() returning Z_OK. There should be no 

   709                         header information stored.

   710 @SYMDEF                 REQ7362

   711 */

   712 

   713 TVerdict CTestZlib::TestDefInfGZipDefaultHeaderIgnoreL()

   714 	{

   715 	return DefInfGZipHeaderL(true, false, NULL);

   716 	}

   717 

   718 /**

   719 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4262

   720 @SYMTestCaseDesc     	Check input can be compressed and decompressed with default gzip 

   721                         header being read using automatic header detection.

   722 @SYMTestPriority     	High

   723 @SYMTestActions      	1.	Create a deflate stream and initialise it using deflateInit2(), 

   724                             adding 16 to windowBits.

   725                         2.	Deflate the input and cleanup using deflateEnd(). 

   726                         3.	Create an inflate stream and initialise it using inflateInit2(), 

   727                             adding 32 to windowBits. 

   728                         4.	Use inflateGetHeader() to get the default header information 

   729                             and make sure the gzip header information is set correctly.

   730                         5.	Inflate the input and cleanup using inflateEnd().

   731 @SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and 

   732                         decompressed with inflateEnd() returning Z_OK. There should be 

   733                         correct header information stored.

   734 @SYMDEF                 REQ7362

   735 */

   736 

   737 TVerdict CTestZlib::TestDefInfGZipDefaultHeaderAutoL()

   738 	{

   739 	return DefInfGZipHeaderL(false, true, NULL);

   740 	}

   741 

   742 /**

   743 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4263

   744 @SYMTestCaseDesc     	Check input can be compressed and decompressed with specified gzip 

   745                         header being read.

   746 @SYMTestPriority     	High

   747 @SYMTestActions      	1.	Create a deflate stream and initialise it using deflateInit2(), 

   748                             adding 16 to windowBits.

   749                         2.	Use deflateSetHeader() to specify header information and check 

   750                             that the gzip header information is set correctly. 

   751                         3.	Deflate the input and cleanup using deflateEnd(). 

   752                         4.	Create an inflate stream and initialise it using inflateInit2(), 

   753                             adding 16 to windowBits. 

   754                         5.	Use inflateGetHeader() to get the header information and make 

   755                             sure that it matches the header information originally entered. 

   756                         6.	Inflate the input and cleanup using inflateEnd().

   757 @SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and 

   758                         the header details being set correctly. The data should also be 

   759                         decompressed with inflateEnd() returning Z_OK and the header details 

   760                         matching the original header information. There should also be header 

   761                         information stored.

   762 @SYMDEF                 REQ7362

   763 */

   764 

   765 TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderManualL()

   766 	{

   767 	return DefInfGZipSpecifiedHeaderL(false, false);

   768 	}

   769 

   770 /**

   771 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4264

   772 @SYMTestCaseDesc     	Check input can be compressed and decompressed with specified gzip 

   773                         header being read using automatic header detection.

   774 @SYMTestPriority     	High

   775 @SYMTestActions      	1.	Create a deflate stream and initialise it using deflateInit2(), 

   776                             adding 16 to windowBits. 

   777                         2.	Use deflateSetHeader() to specify header information and check 

   778                             that the gzip header information is set correctly. 

   779                         3.	Deflate the input and cleanup using deflateEnd(). 

   780                         4.	Create an inflate stream and initialise it using inflateInit2(), 

   781                             adding 32 to windowBits. 

   782                         5.	Use inflateGetHeader() to get the header information and make 

   783                             sure that it matches the header information originally entered. 

   784                         6.	Inflate the input and cleanup using inflateEnd().

   785 @SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and 

   786                         the header details being set correctly. The data should also be 

   787                         decompressed with inflateEnd() returning Z_OK and the header details 

   788                         matching the original header information. There should also be header 

   789                         information stored.

   790 @SYMDEF                 REQ7362

   791 */

   792 

   793 TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderAutoL()

   794 	{

   795 	return DefInfGZipSpecifiedHeaderL(false, true);

   796 	}

   797 

   798 /**

   799 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4265

   800 @SYMTestCaseDesc     	Check input can be compressed and decompressed with zlib header 

   801                         using automatic header detection.

   802 @SYMTestPriority     	High

   803 @SYMTestActions      	1.	Create a deflate stream and initialise it. 

   804                         2.	Deflate the input and cleanup using deflateEnd(). 

   805                         3.	Create an inflate stream and initialise it using inflateInit2(), 

   806                             adding 32 to windowBits. 

   807                         4.	Inflate the input and cleanup using inflateEnd().

   808 @SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK 

   809                         and decompressed with inflateEnd returning Z_OK.

   810 @SYMDEF                 REQ7362

   811 */

   812 

   813 TVerdict CTestZlib::TestDefInfZlibHeaderAutoL()

   814 	{

   815 	int err = Z_OK;

   816 	

   817 	// Streams

   818 	z_stream deflateStream;

   819 	z_stream inflateStream;

   820 	

   821 	// Stream settings

   822 	StreamSettings streamSettings;

   823 	streamSettings.deflateInit2 = false;

   824 	streamSettings.level = Z_DEFAULT_COMPRESSION;

   825 	streamSettings.inflateWindowBits = MAX_WBITS + TEST_AUTO_HEADER_DETECTION;

   826 	

   827 	// Buffers

   828 	const char inputData[] = "This is a piece of data to compress.\0"; // data to compress

   829     uLong inputDataLength = (uLong)strlen(inputData) + 1;     

   830     Byte *compressedDataBuffer = NULL;

   831     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

   832     Byte *decompressedDataBuffer = NULL;  

   833     uLong decompressedDataBufferLength = inputDataLength;

   834 	

   835 	// Allocate memory for buffers

   836     compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

   837     CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer.");

   838     CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer));

   839 

   840     decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte));

   841     CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer.");

   842     CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer));

   843 

   844     this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength);

   845  

   846 	// Initialise the inflateStream

   847 	this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits);

   848 	CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream));

   849 	

   850 	err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength);

   851 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err);

   852 	

   853 	// Clean up the inflateStream

   854 	err = inflateEnd(&inflateStream);

   855 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err);

   856 	CleanupStack::Pop(1);

   857 	

   858 	CleanupStack::PopAndDestroy(2);	

   859 	return EPass;

   860 	}

   861 

   862 /**

   863 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4266

   864 @SYMTestCaseDesc     	Check deflateSetHeader() fails when given an invalid stream.

   865 @SYMTestPriority     	High

   866 @SYMTestActions      	1.	Create a stream and initialise it using deflateInit2(), adding 

   867                             16 to windowBits. 

   868                         2.	Call deflateSetHeader() passing it parameter values:

   869                             a.	NULL for the stream argument

   870                             b.	a stream whose state is set to NULL for the stream argument

   871                             c.	a zlib stream for the stream argument

   872                             d.	a raw stream for the stream argument

   873 @SYMTestExpectedResults deflateSetHeader() fails returning Z_STREAM_ERROR in all four cases.

   874 @SYMDEF                 REQ7362

   875 */

   876 

   877 TVerdict CTestZlib::TestDeflateSetHeaderFailsL()

   878 	{

   879 	int err;

   880 	

   881 	// Streams

   882 	z_stream gZipDeflateStream;

   883 	z_stream zLibDeflateStream;

   884 	z_stream rawDeflateStream;

   885 	

   886 	// GZip headers

   887 	gz_header specifiedGZipHeader;

   888 	

   889 	// Buffers

   890 	const char inputData[] = "This is a piece of data to compress.\0";

   891     uLong inputDataLength = (uLong)strlen(inputData) + 1;     

   892     Byte *compressedDataBuffer;

   893     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

   894     

   895     // deflateInit2 arguments

   896 	int level = Z_DEFAULT_COMPRESSION;

   897 	int method = Z_DEFLATED;

   898 	int gZipDeflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

   899 	int memLevel = TEST_MID_MEM_LEVEL;

   900 	int strategy = Z_DEFAULT_STRATEGY;

   901 	

   902 	// GZip header user specified values

   903 	Bytef extra[] = "12345"; 

   904 	Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0";  

   905 	Bytef comment[] = "This is a test comment.\0"; 

   906 	

   907 	// Set the specifiedGZipHeader ready for deflateSetHeader

   908 	specifiedGZipHeader.text = 1;

   909 	specifiedGZipHeader.time = 101;

   910 	specifiedGZipHeader.os = 1;

   911 	specifiedGZipHeader.extra = extra;

   912 	specifiedGZipHeader.extra_len = 5;

   913 	specifiedGZipHeader.extra_max = specifiedGZipHeader.extra_len + 10; // Add extra 10 to check readGZipHeader.extra_len is set properly

   914 	specifiedGZipHeader.name = name;

   915 	specifiedGZipHeader.name_max = strlen((char *)name) + 1;

   916 	specifiedGZipHeader.comment = comment;

   917 	specifiedGZipHeader.comm_max = strlen((char *)comment) + 1;

   918 	specifiedGZipHeader.hcrc = 0;

   919 	

   920 	// Allocate memory for buffers

   921     compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

   922     CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer.");

   923     CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer));

   924 	

   925 	// Initialise the deflate streams

   926 	this->DeflateInit2L(gZipDeflateStream, level, method, gZipDeflateWindowBits, memLevel, strategy);

   927 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &gZipDeflateStream));

   928 	

   929 	this->DeflateInitL(zLibDeflateStream, level);

   930 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &zLibDeflateStream));

   931 

   932 	this->DeflateInit2L(rawDeflateStream, level, method, -MAX_WBITS, memLevel, strategy);

   933 	CleanupStack::PushL(TCleanupItem(DeflateEnd, &rawDeflateStream));

   934 	

   935 	// Try setting a NULL streams header

   936 	err = deflateSetHeader(NULL, &specifiedGZipHeader);

   937 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a NULL stream returned an unexpected value: %d", err);

   938 

   939 	// Try setting the header for a deflate stream that has a NULL state

   940 	// we must keep a pointer to the streams state so we can clean up properly with deflateEnd

   941 	internal_state *deflateState  = gZipDeflateStream.state;

   942 	gZipDeflateStream.state = NULL;

   943 	

   944 	err = deflateSetHeader(&gZipDeflateStream, &specifiedGZipHeader);

   945 	

   946 	gZipDeflateStream.state = deflateState;

   947 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a stream with a NULL state returned an unexpected value: %d", err);

   948 	

   949 	// Try setting a header for a zlib stream

   950 	err = deflateSetHeader(&zLibDeflateStream, &specifiedGZipHeader);

   951 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a zlib stream returned an unexpected value: %d", err);

   952 	

   953 	// Try setting a header for a raw stream

   954 	err = deflateSetHeader(&rawDeflateStream, &specifiedGZipHeader);

   955 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a raw stream returned an unexpected value: %d", err);

   956 	

   957 	// Clean up the deflate streams	

   958 	err = deflateEnd(&gZipDeflateStream);

   959 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "gZipDeflateStream - deflateEnd error: %d", err);

   960 	

   961 	err = deflateEnd(&zLibDeflateStream);

   962 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "zLibDeflateStream - deflateEnd error: %d", err);

   963 	

   964 	// deflateInit2() leaves a raw stream in a busy state. This results in deflateEnd()

   965 	// returning a Z_DATA_ERROR, unless deflate() has been called on the stream.

   966 	err = deflateEnd(&rawDeflateStream);

   967 	CHECK_CONDITION1L(err != Z_DATA_ERROR, KErrGeneral, "rawDeflateStream - deflateEnd error: %d", err);

   968 	

   969 	CleanupStack::Pop(3);

   970 	CleanupStack::PopAndDestroy(1);	

   971 	return EPass;

   972 	}

   973 

   974 /**

   975 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4267

   976 @SYMTestCaseDesc     	Check inflateGetHeader() fails when given an invalid gzip stream.

   977 @SYMTestPriority     	High

   978 @SYMTestActions      	1.	Create a deflate stream and initialise it using deflateInit2(), adding 16 to windowBits. 

   979                         2.	Deflate the input and cleanup using deflateEnd(). 

   980                         3.	Create an inflate stream and initialise it using inflateInit2(), adding 16 to windowBits.

   981                         4.	Call inflateGetHeader() passing it parameter values:

   982                             e.	NULL for the stream argument

   983                             f.	a stream whose state is set to NULL for the stream argument

   984                             g.	a zlib stream for the stream argument

   985                             h.	a raw stream for the stream argument

   986 @SYMTestExpectedResults inflateGetHeader() should fail returning Z_STREAM_ERROR for the 

   987                         first 2 cases and Z_DATA_ERROR for the second 2 case.

   988 @SYMDEF                 REQ7362

   989 */

   990 

   991 TVerdict CTestZlib::TestInflateGetHeaderFailsL()

   992 	{	

   993 	int err = Z_OK;

   994 	

   995 	// Streams

   996 	z_stream gZipDeflateStream;

   997 	z_stream zLibDeflateStream;

   998 	z_stream rawDeflateStream;

   999 	z_stream gZipInflateStream;

  1000 	z_stream zLibInflateStream;

  1001 	z_stream rawInflateStream;

  1002 	

  1003 	// GZip headers

  1004 	gz_header gZipHeader;

  1005 	

  1006 	// Buffers

  1007 	const char inputData[] = "This is a piece of data to compress.\0";

  1008     uLong inputDataLength = (uLong)strlen(inputData) + 1;     

  1009     Byte *gZipCompressedDataBuffer = NULL;

  1010     Byte *zLibCompressedDataBuffer = NULL;

  1011     Byte *rawCompressedDataBuffer = NULL;

  1012     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

  1013     

  1014     // deflateInit2 and inflateInit2 arguments

  1015     StreamSettings gZipStreamSettings;

  1016     gZipStreamSettings.deflateInit2 = true;

  1017     gZipStreamSettings.level = Z_DEFAULT_COMPRESSION;

  1018     gZipStreamSettings.method = Z_DEFLATED;

  1019     gZipStreamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

  1020     gZipStreamSettings.inflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

  1021     gZipStreamSettings.memLevel = TEST_MID_MEM_LEVEL;

  1022     gZipStreamSettings.strategy = Z_DEFAULT_STRATEGY;  

  1023     

  1024     StreamSettings zLibStreamSettings;

  1025     zLibStreamSettings.deflateInit2 = false;

  1026     zLibStreamSettings.level = Z_DEFAULT_COMPRESSION;

  1027     

  1028     StreamSettings rawStreamSettings;

  1029     rawStreamSettings.deflateInit2 = true;

  1030     rawStreamSettings.level = Z_DEFAULT_COMPRESSION;

  1031     rawStreamSettings.method = Z_DEFLATED;

  1032     rawStreamSettings.deflateWindowBits = -MAX_WBITS;

  1033     rawStreamSettings.inflateWindowBits = -MAX_WBITS;

  1034     rawStreamSettings.memLevel = TEST_MID_MEM_LEVEL;

  1035     rawStreamSettings.strategy = Z_DEFAULT_STRATEGY; 

  1036 	

  1037 	// Allocate memory for buffers

  1038 	gZipCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

  1039 	CHECK_CONDITION0L(gZipCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for gZipCompressedDataBuffer.");

  1040     CleanupStack::PushL(TCleanupItem(User::Free, gZipCompressedDataBuffer));

  1041 	

  1042 	zLibCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

  1043 	CHECK_CONDITION0L(zLibCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for zLibCompressedDataBuffer.");

  1044     CleanupStack::PushL(TCleanupItem(User::Free, zLibCompressedDataBuffer));

  1045     

  1046 	rawCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte));

  1047 	CHECK_CONDITION0L(rawCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for rawCompressedDataBuffer.");

  1048     CleanupStack::PushL(TCleanupItem(User::Free, rawCompressedDataBuffer));

  1049     

  1050     // Compress data

  1051     INFO_PRINTF1(_L("Compress gzip:"));

  1052     this->CompressDataL(gZipStreamSettings, gZipDeflateStream, (Byte *)inputData, inputDataLength, gZipCompressedDataBuffer, compressedDataBufferLength);

  1053     INFO_PRINTF1(_L("Compress zlib:"));

  1054     this->CompressDataL(zLibStreamSettings, zLibDeflateStream, (Byte *)inputData, inputDataLength, zLibCompressedDataBuffer, compressedDataBufferLength);

  1055     INFO_PRINTF1(_L("Compress raw:"));

  1056     this->CompressDataL(rawStreamSettings, rawDeflateStream, (Byte *)inputData, inputDataLength, rawCompressedDataBuffer, compressedDataBufferLength);

  1057 

  1058 	// Initialise the inflateStreams

  1059     INFO_PRINTF1(_L("gZipInflateStream:"));

  1060 	this->InflateInit2L(gZipInflateStream, gZipStreamSettings.inflateWindowBits);

  1061 	CleanupStack::PushL(TCleanupItem(InflateEnd, &gZipInflateStream));

  1062 	

  1063 	INFO_PRINTF1(_L("zLibInflateStream:"));

  1064 	this->InflateInitL(zLibInflateStream);

  1065 	CleanupStack::PushL(TCleanupItem(InflateEnd, &zLibInflateStream));

  1066 	

  1067 	INFO_PRINTF1(_L("rawInflateStream:"));

  1068 	this->InflateInit2L(rawInflateStream, rawStreamSettings.inflateWindowBits);

  1069 	CleanupStack::PushL(TCleanupItem(InflateEnd, &rawInflateStream));

  1070 	

  1071 	// Try and get header information from a NULL stream

  1072 	err = inflateGetHeader(NULL, &gZipHeader);

  1073 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a NULL stream returned an unexpected value: %d", err);

  1074 

  1075 	// Try getting the header for a deflate stream that has a NULL state

  1076 	// we must keep a pointer to the streams state so we can clean up properly with deflateEnd

  1077 	internal_state *deflateState  = gZipDeflateStream.state;

  1078 	gZipDeflateStream.state = NULL;

  1079 	

  1080 	err = inflateGetHeader(&gZipDeflateStream, &gZipHeader);

  1081 	

  1082 	gZipDeflateStream.state = deflateState;

  1083 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a stream with a NULL state returned an unexpected value: %d", err);

  1084 	

  1085 	// Try and get header information from a zlib stream

  1086 	err = inflateGetHeader(&zLibDeflateStream, &gZipHeader);

  1087 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a zlib stream returned an unexpected value: %d", err);

  1088 		

  1089 	// Try and get header information from a raw stream

  1090 	err = inflateGetHeader(&rawDeflateStream, &gZipHeader);

  1091 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a raw stream returned an unexpected value: %d", err);

  1092 	

  1093 	// Clean up the inflateStreams

  1094 	err = inflateEnd(&gZipInflateStream);

  1095 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "gZipInflateStream - inflateEnd error: %d", err);

  1096 	

  1097 	err = inflateEnd(&zLibInflateStream);

  1098 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "zLibInflateStream - inflateEnd error: %d", err);

  1099 	

  1100 	err = inflateEnd(&rawInflateStream);

  1101 	CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "rawInflateStream - inflateEnd error: %d", err);

  1102 	

  1103 	CleanupStack::Pop(3);

  1104     CleanupStack::PopAndDestroy(3);

  1105 	return EPass;

  1106 	}

  1107 

  1108 /**

  1109 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4268

  1110 @SYMTestCaseDesc     	Check output can be deflated in raw format and inflated.

  1111 @SYMTestPriority     	High

  1112 @SYMTestActions      	1.	Create a stream and initialise it using deflateInit2(), 

  1113                             setting windowBits between -8 and -15. 

  1114                         2.	Deflate the input and cleanup using deflateEnd(). 

  1115                         3.	Create an inflate stream and initialise it using inflateInit2(), 

  1116                             setting windowBits to be equal or less than the windowBits 

  1117                             value used for deflateInit2(). 

  1118                         4.	Inflate the input using inflate() and cleanup using inflateEnd().

  1119 @SYMTestExpectedResults The data should be compressed with deflateEnd returning Z_OK and 

  1120                         decompressed with inflateEnd returning Z_OK.

  1121 @SYMDEF                 REQ7362

  1122 */

  1123 

  1124 TVerdict CTestZlib::TestDefInfRawL()

  1125 	{

  1126 	int err = Z_OK;

  1127 	

  1128 	// Streams

  1129 	z_stream deflateStream;	

  1130 	z_stream inflateStream;

  1131 	

  1132 	// Buffers

  1133 	const char inputData[] = "This is a piece of data to compress.\0";

  1134     uLong inputDataLength = (uLong)strlen(inputData) + 1;