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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Name        : tzlibadvanced.cpp

 // 

 //

 #include "tzlib.h"

 #include "zutil.h"

 //#include "deflate.h"

 #define COMPRESSED_DATA_BUFFER_LENGTH 200*sizeof(int) 

 #define FAILURE_RATE_LIMIT 100

 #define TEST_MID_MEM_LEVEL 5

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

 #define TEST_GZIP_HEADER 16

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

 #define TEST_AUTO_HEADER_DETECTION 32

 #define CHECK_CONDITION0L(condition, leaveErr, errMessage) \

 	if (condition) \

 		{ \

 		ERR_PRINTF1(_L(errMessage)); \

 		User::Leave(leaveErr); \

     	}

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

 	if (condition) \

 		{ \

 		ERR_PRINTF2(_L(errMessage), p1); \

 		User::Leave(leaveErr); \

     	}

 _LIT(KParam1, "Param1");

 _LIT(KParam2, "Param2");

 _LIT(KParam3, "Param3");

 _LIT(KParam4, "Param4");

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

 struct bufferDescriptor

 	{

 	Byte *buffer;

 	int next;

 	int length;

 	};

 /*

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

  */

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

 	{

 	TInt err = Z_OK;

 	aStream.zalloc = Z_NULL;

 	aStream.zfree = Z_NULL;

 	aStream.opaque = Z_NULL;

 	err = deflateInit(&aStream, aLevel);

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

 	}

 /*

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

  */

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

 	{

 	int err;

 	aStream.zalloc = Z_NULL;

 	aStream.zfree = Z_NULL;

 	aStream.opaque = Z_NULL;

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

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

 	}

 /*

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

  */

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

 	{

 	int err;

 	int flush;

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

 	aStream.next_in  = aInputData;

 	aStream.next_out = aCompressedDataBuffer; 

     do 

     	{

     	if (aStream.total_in < aInputDataLength)

     		{

 			aStream.avail_in = 1; // force small buffer

     		}

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

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

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

 	    do 

 	    	{

 	    	if (aStream.total_out < aCompressedDataBufferLength)

 	    		{

 				aStream.avail_out = 1; // force small buffer

 	    		}

 	        err = deflate(&aStream, flush); 

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

 	    		{ 

 	    		return err; 

 	    	    } 

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

     	} while(err != Z_STREAM_END); 

     return Z_OK;

 	}

 /*

  * Helper member function that cleans up a deflate stream.

  */

 void CTestZlib::DeflateEnd(TAny *aStream)

 	{

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

 		{

 		deflateEnd((z_stream *)aStream);  

 		}

 	}

 /*

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

  */

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

 	{

 	TInt err = Z_OK;

 	aStream.zalloc = Z_NULL;

 	aStream.zfree = Z_NULL;

 	aStream.opaque = Z_NULL;

 	err = inflateInit(&aStream);

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

 	}

 /*

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

  */

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

 	{

 	TInt err = Z_OK;

 	aStream.zalloc = Z_NULL;

 	aStream.zfree = Z_NULL;

 	aStream.opaque = Z_NULL;

 	err = inflateInit2(&aStream, aWindowBits);

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

 	}

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

 	{

 	int err;

 	aStream.zalloc = Z_NULL;

 	aStream.zfree = Z_NULL;

 	aStream.opaque = Z_NULL;

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

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

 	}

 /*

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

  */

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

 	{

 	int err;

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

 	aStream.next_in  = aCompressedDataBuffer;

 	aStream.next_out = aDecompressedDataBuffer;    

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

 	do 

 		{

 		if(aStream.total_in < aCompressedDataLength)

     		{

     		aStream.avail_in = 1; // force small buffer 

     		}

 		if (aStream.total_out < aDecompressedDataBufferLength)

     		{

 			aStream.avail_out = 1; // force small buffer

     		}

         err = inflate(&aStream, Z_NO_FLUSH); 

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

     		{  

     		return err; 

     	    } 

 		} while(err != Z_STREAM_END); 

 	return Z_OK;

 	}

 /*

  * Helper member function that cleans up a inflate stream.

  */

 void CTestZlib::InflateEnd(TAny *aStream)

 	{

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

 		{

 		inflateEnd((z_stream *)aStream);  

 		}

 	}

 /*

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

  */

 void CTestZlib::InflateBackEnd(TAny *aStream)

 	{

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

 		{

 		inflateBackEnd((z_stream *)aStream);  

 		}

 	}

 /*

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

  * sure they are the same.

  */

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

 	{

 	TBool headersEqual = true;

 	if(header1.text != header2.text)

 		{

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

 		headersEqual = false;

 		}

 	if(header1.time != header2.time)

 		{

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

 		headersEqual = false;

 		}

 	if(header1.xflags != header2.xflags)

 		{

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

 		headersEqual = false;

 		}

 	if(header1.os != header2.os)

 		{

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

 		headersEqual = false;

 		}

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

 		{

 		if(header1.extra_len != header2.extra_len)

 			{

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

 			headersEqual = false;

 			}

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

 			{

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

 			headersEqual = false;

 			}

 		}

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

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

 		{

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

 		headersEqual = false;

 		}

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

 		{

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

 			{

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

 			headersEqual = false;

 			}

 		}

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

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

 		{

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

 		headersEqual = false;

 		}

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

 		{

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

 			{

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

 			headersEqual = false;

 			}

 		}

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

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

 		{

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

 		headersEqual = false;

 		}

 	if(header1.hcrc != header2.hcrc)

 		{

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

 		headersEqual = false;

 		}

 	if(header1.done != header2.done)

 		{

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

 		headersEqual = false;

 		}

 	return headersEqual;

 	}

 /*

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

  */

 TBool CTestZlib::IsDefaultGZipHeader(const gz_header &header)

 	{

 	gz_header defaultHeader;

 	// gz_header default values

 	defaultHeader.text = 0;

 	defaultHeader.time = 0;

 	defaultHeader.xflags = 0;

 	defaultHeader.os = OS_CODE;

 	defaultHeader.extra = NULL;

 	defaultHeader.name = NULL;

 	defaultHeader.comment = NULL;

 	defaultHeader.hcrc = 0;

 	defaultHeader.done = 1;

 	return GZipHeadersEqual(defaultHeader, header);

 	}

 /*

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

  */

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

 	{

 	TInt err = Z_OK;

 	// Initialise the deflate stream

 	if(aStreamSettings.deflateInit2 == false)

 		{

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

 		}

 	else

 		{

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

 		}

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

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

 	// start of the output when deflate is called

 	if(aHeader != NULL)

 		{

 		err = deflateSetHeader(&aStream, aHeader);

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

 		}

 	// Compress the input

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

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

 	// Clean up the deflateStream

 	err = deflateEnd(&aStream);

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

 	CleanupStack::Pop(1);

 	}

 /*

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

  * the compressed data.

  */

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

 	{

 	int err = Z_OK;

 	TVerdict verdict = EPass;

 	// Streams

 	z_stream deflateStream;

 	z_stream inflateStream;

 	// Headers

 	gz_header readGZipHeader;

 	readGZipHeader.extra = NULL;

 	readGZipHeader.name = NULL;

 	readGZipHeader.comment = NULL;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;  

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateInit2 arguments

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = true;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

     streamSettings.method = Z_DEFLATED;

     streamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

     streamSettings.inflateWindowBits = MAX_WBITS;

     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

     streamSettings.strategy = Z_DEFAULT_STRATEGY;

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

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

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

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

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

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

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

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

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

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

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

     	{

     	if(aSpecifiedGZipHeader->extra != NULL)

     		{

     		readGZipHeader.extra_max = aSpecifiedGZipHeader->extra_max;

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

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

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

     		}

     	if(aSpecifiedGZipHeader->name != NULL)

     		{

     		readGZipHeader.name_max = aSpecifiedGZipHeader->name_max;

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

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

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

     		}

     	if(aSpecifiedGZipHeader->comment != NULL)

     		{

     		readGZipHeader.comm_max = aSpecifiedGZipHeader->comm_max;

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

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

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

     		}

     	}

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

 	// Initialise the inflateStream

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

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

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

 	// header information when inflate is called

 	if(aIgnoreHeader == false)

 		{

 		err = inflateGetHeader(&inflateStream, &readGZipHeader);

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

 		}

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

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

 	// Clean up the inflateStream

 	err = inflateEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

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

 	// contains the expected information

 	if(aIgnoreHeader == false)

 		{

 		if(aSpecifiedGZipHeader != NULL)

 			{

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

 			}

 		else

 			{

 			verdict = IsDefaultGZipHeader(readGZipHeader) ? EPass : EFail;

 			}

 		}

 	if(readGZipHeader.comment != NULL)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	if(readGZipHeader.name != NULL)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	if(readGZipHeader.extra != NULL)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	// Free buffers

 	CleanupStack::PopAndDestroy(2);

 	return verdict;

 	}

 /*

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

  * and then inflates the compressed data.

  */

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

 	{

 	gz_header specifiedGZipHeader;

 	Bytef extra[] = "12345"; 

 	Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0";  

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

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

 	specifiedGZipHeader.text = 1;

 	specifiedGZipHeader.time = 101;

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

 	specifiedGZipHeader.os = 1; // Amiga

 	specifiedGZipHeader.extra = extra;

 	specifiedGZipHeader.extra_len = TEST_MID_MEM_LEVEL;

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

 	specifiedGZipHeader.name = name;

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

 	specifiedGZipHeader.comment = comment;

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

 	specifiedGZipHeader.hcrc = 0;

 	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

 	return DefInfGZipHeaderL(aIgnoreHeader, aAutoDetectHeader, &specifiedGZipHeader);

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4259

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

                         deflateTune().

 @SYMTestPriority     	Medium

 @SYMTestActions      	1.	Create a stream and initialise it. 

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

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

                             are identical to the specified parameters. Also check that 

                             Z_OK is returned.

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

                             Z_OK is returned.

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

                         •	3 and 4 for level

                         and for deflateTune() parameter values:

                         •	0 and a high value for good_length

                         •	0 and a high value for max_lazy

                         •	0 and a high value for nice_length

                         •	0 and a high value for max_chain                        

                         Appropriate high values can be picked based on the global 

                         configuration_table array in deflate.cpp.

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

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDeflateTuneL()

 	{	

 	int err = Z_OK;

 	TBool ret;

 	// Streams

 	z_stream deflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer;

     // deflateInit arguments

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     int level = Z_DEFAULT_COMPRESSION;	

 	int goodLength = 0;

     int maxLazy = 0;

     int niceLength = 0;

     int maxChain = 0;

     // Allocate memory for output buffer

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

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

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

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

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

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

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

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

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

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

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

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

 	 // Initialise the stream

 	this->DeflateInitL(deflateStream, level);

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

 	// Tune the deflate stream

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

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

 	// Check deflateTune has set the streams state values correctly

 	/*

 	internal_state *s = deflateStream.state;

 	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");

 	*/

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

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

 	// Clean up the deflate stream

 	err = deflateEnd(&deflateStream);

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

 	CleanupStack::Pop(1);

 	// Free buffer

 	CleanupStack::PopAndDestroy(1);  

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4260

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

 @SYMTestPriority     	Medium

 @SYMTestActions      	1.	Create a stream and initialise it.

                         2.	Call deflateTune() passing it parameter values:

                             a.	NULL for the stream argument

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

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

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDeflateTuneFailL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;

 	// deflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;	

 	// Initialise the stream

 	this->DeflateInitL(deflateStream, level);

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

 	// Try tuning a NULL deflate stream

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

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

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

 	internal_state *deflateState  = deflateStream.state;

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

 	deflateStream.state = NULL;

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

 	deflateStream.state = deflateState;

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

 	// Clean up the deflate stream

 	err = deflateEnd(&deflateStream);

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

 	CleanupStack::Pop(1);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4261

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

                         header not being read.

 @SYMTestPriority     	High

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

                             adding 16 to windowBits.

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

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

                             adding 16 to windowBits.

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

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

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

                         header information stored.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfGZipDefaultHeaderIgnoreL()

 	{

 	return DefInfGZipHeaderL(true, false, NULL);

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4262

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

                         header being read using automatic header detection.

 @SYMTestPriority     	High

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

                             adding 16 to windowBits.

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

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

                             adding 32 to windowBits. 

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

                             and make sure the gzip header information is set correctly.

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

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

                         decompressed with inflateEnd() returning Z_OK. There should be 

                         correct header information stored.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfGZipDefaultHeaderAutoL()

 	{

 	return DefInfGZipHeaderL(false, true, NULL);

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4263

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

                         header being read.

 @SYMTestPriority     	High

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

                             adding 16 to windowBits.

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

                             that the gzip header information is set correctly. 

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

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

                             adding 16 to windowBits. 

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

                             sure that it matches the header information originally entered. 

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

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

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

                         decompressed with inflateEnd() returning Z_OK and the header details 

                         matching the original header information. There should also be header 

                         information stored.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderManualL()

 	{

 	return DefInfGZipSpecifiedHeaderL(false, false);

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4264

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

                         header being read using automatic header detection.

 @SYMTestPriority     	High

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

                             adding 16 to windowBits. 

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

                             that the gzip header information is set correctly. 

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

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

                             adding 32 to windowBits. 

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

                             sure that it matches the header information originally entered. 

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

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

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

                         decompressed with inflateEnd() returning Z_OK and the header details 

                         matching the original header information. There should also be header 

                         information stored.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderAutoL()

 	{

 	return DefInfGZipSpecifiedHeaderL(false, true);

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4265

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

                         using automatic header detection.

 @SYMTestPriority     	High

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

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

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

                             adding 32 to windowBits. 

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

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

                         and decompressed with inflateEnd returning Z_OK.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfZlibHeaderAutoL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;

 	z_stream inflateStream;

 	// Stream settings

 	StreamSettings streamSettings;

 	streamSettings.deflateInit2 = false;

 	streamSettings.level = Z_DEFAULT_COMPRESSION;

 	streamSettings.inflateWindowBits = MAX_WBITS + TEST_AUTO_HEADER_DETECTION;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;  

     uLong decompressedDataBufferLength = inputDataLength;

 	// Allocate memory for buffers

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

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

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

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

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

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

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

 	// Initialise the inflateStream

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

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

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

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

 	// Clean up the inflateStream

 	err = inflateEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	CleanupStack::PopAndDestroy(2);	

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4266

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

 @SYMTestPriority     	High

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

                             16 to windowBits. 

                         2.	Call deflateSetHeader() passing it parameter values:

                             a.	NULL for the stream argument

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

                             c.	a zlib stream for the stream argument

                             d.	a raw stream for the stream argument

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

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDeflateSetHeaderFailsL()

 	{

 	int err;

 	// Streams

 	z_stream gZipDeflateStream;

 	z_stream zLibDeflateStream;

 	z_stream rawDeflateStream;

 	// GZip headers

 	gz_header specifiedGZipHeader;

 	// Buffers

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

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

     Byte *compressedDataBuffer;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     // deflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;

 	int method = Z_DEFLATED;

 	int gZipDeflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

 	int memLevel = TEST_MID_MEM_LEVEL;

 	int strategy = Z_DEFAULT_STRATEGY;

 	// GZip header user specified values

 	Bytef extra[] = "12345"; 

 	Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0";  

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

 	// Set the specifiedGZipHeader ready for deflateSetHeader

 	specifiedGZipHeader.text = 1;

 	specifiedGZipHeader.time = 101;

 	specifiedGZipHeader.os = 1;

 	specifiedGZipHeader.extra = extra;

 	specifiedGZipHeader.extra_len = 5;

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

 	specifiedGZipHeader.name = name;

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

 	specifiedGZipHeader.comment = comment;

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

 	specifiedGZipHeader.hcrc = 0;

 	// Allocate memory for buffers

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

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

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

 	// Initialise the deflate streams

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

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

 	this->DeflateInitL(zLibDeflateStream, level);

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

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

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

 	// Try setting a NULL streams header

 	err = deflateSetHeader(NULL, &specifiedGZipHeader);

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

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

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

 	internal_state *deflateState  = gZipDeflateStream.state;

 	gZipDeflateStream.state = NULL;

 	err = deflateSetHeader(&gZipDeflateStream, &specifiedGZipHeader);

 	gZipDeflateStream.state = deflateState;

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

 	// Try setting a header for a zlib stream

 	err = deflateSetHeader(&zLibDeflateStream, &specifiedGZipHeader);

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

 	// Try setting a header for a raw stream

 	err = deflateSetHeader(&rawDeflateStream, &specifiedGZipHeader);

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

 	// Clean up the deflate streams	

 	err = deflateEnd(&gZipDeflateStream);

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

 	err = deflateEnd(&zLibDeflateStream);

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

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

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

 	err = deflateEnd(&rawDeflateStream);

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

 	CleanupStack::Pop(3);

 	CleanupStack::PopAndDestroy(1);	

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4267

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

 @SYMTestPriority     	High

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

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

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

                         4.	Call inflateGetHeader() passing it parameter values:

                             e.	NULL for the stream argument

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

                             g.	a zlib stream for the stream argument

                             h.	a raw stream for the stream argument

 @SYMTestExpectedResults inflateGetHeader() should fail returning Z_STREAM_ERROR for the 

                         first 2 cases and Z_DATA_ERROR for the second 2 case.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateGetHeaderFailsL()

 	{	

 	int err = Z_OK;

 	// Streams

 	z_stream gZipDeflateStream;

 	z_stream zLibDeflateStream;

 	z_stream rawDeflateStream;

 	z_stream gZipInflateStream;

 	z_stream zLibInflateStream;

 	z_stream rawInflateStream;

 	// GZip headers

 	gz_header gZipHeader;

 	// Buffers

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

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

     Byte *gZipCompressedDataBuffer = NULL;

     Byte *zLibCompressedDataBuffer = NULL;

     Byte *rawCompressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     // deflateInit2 and inflateInit2 arguments

     StreamSettings gZipStreamSettings;

     gZipStreamSettings.deflateInit2 = true;

     gZipStreamSettings.level = Z_DEFAULT_COMPRESSION;

     gZipStreamSettings.method = Z_DEFLATED;

     gZipStreamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

     gZipStreamSettings.inflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER;

     gZipStreamSettings.memLevel = TEST_MID_MEM_LEVEL;

     gZipStreamSettings.strategy = Z_DEFAULT_STRATEGY;  

     StreamSettings zLibStreamSettings;

     zLibStreamSettings.deflateInit2 = false;

     zLibStreamSettings.level = Z_DEFAULT_COMPRESSION;

     StreamSettings rawStreamSettings;

     rawStreamSettings.deflateInit2 = true;

     rawStreamSettings.level = Z_DEFAULT_COMPRESSION;

     rawStreamSettings.method = Z_DEFLATED;

     rawStreamSettings.deflateWindowBits = -MAX_WBITS;

     rawStreamSettings.inflateWindowBits = -MAX_WBITS;

     rawStreamSettings.memLevel = TEST_MID_MEM_LEVEL;

     rawStreamSettings.strategy = Z_DEFAULT_STRATEGY; 

 	// Allocate memory for buffers

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

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

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

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

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

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

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

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

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

     // Compress data

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

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

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

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

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

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

 	// Initialise the inflateStreams

     INFO_PRINTF1(_L("gZipInflateStream:"));

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

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

 	INFO_PRINTF1(_L("zLibInflateStream:"));

 	this->InflateInitL(zLibInflateStream);

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

 	INFO_PRINTF1(_L("rawInflateStream:"));

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

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

 	// Try and get header information from a NULL stream

 	err = inflateGetHeader(NULL, &gZipHeader);

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

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

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

 	internal_state *deflateState  = gZipDeflateStream.state;

 	gZipDeflateStream.state = NULL;

 	err = inflateGetHeader(&gZipDeflateStream, &gZipHeader);

 	gZipDeflateStream.state = deflateState;

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

 	// Try and get header information from a zlib stream

 	err = inflateGetHeader(&zLibDeflateStream, &gZipHeader);

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

 	// Try and get header information from a raw stream

 	err = inflateGetHeader(&rawDeflateStream, &gZipHeader);

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

 	// Clean up the inflateStreams

 	err = inflateEnd(&gZipInflateStream);

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

 	err = inflateEnd(&zLibInflateStream);

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

 	err = inflateEnd(&rawInflateStream);

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

 	CleanupStack::Pop(3);

     CleanupStack::PopAndDestroy(3);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4268

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

 @SYMTestPriority     	High

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

                             setting windowBits between -8 and -15. 

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

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

                             setting windowBits to be equal or less than the windowBits 

                             value used for deflateInit2(). 

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

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

                         decompressed with inflateEnd returning Z_OK.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfRawL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	

 	z_stream inflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateInit2 arguments

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = true;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

     streamSettings.method = Z_DEFLATED;

     streamSettings.deflateWindowBits = -MAX_WBITS;

     streamSettings.inflateWindowBits = streamSettings.deflateWindowBits;

     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

     streamSettings.strategy = Z_DEFAULT_STRATEGY;

 	// Allocate memory for buffers

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

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

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

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

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

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

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

 	// Initialise the inflateStream

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

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

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

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

 	// Clean up the inflateStream

 	err = inflateEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	CleanupStack::PopAndDestroy(2);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4269

 @SYMTestCaseDesc     	Check output is not generated in raw format when windowBits < -15 

                         or > -8.

 @SYMTestPriority     	High

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

                             it the specified parameters.

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

                         •	< -15 and > -8 for windowBits

 @SYMTestExpectedResults deflateInit2() should fail returning Z_STREAM_ERROR. Note: if 

                         windowBits is set between 8-15 and 24-31 there will be no error 

                         as the input will be deflated as a zlib/gzip stream.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefRawFailsL()

 	{

 	TBool ret;

 	// Streams

 	z_stream deflateStream;	 

     // deflateInit2 and inflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;

 	int method = Z_DEFLATED;

 	int deflateWindowBits;

 	int memLevel = TEST_MID_MEM_LEVEL;

 	int strategy = Z_DEFAULT_STRATEGY;

     // Read in the value for windowBits from the ini file

 	ret = GetIntFromConfig(ConfigSection(), KParam1, deflateWindowBits);

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

     // Initialise the deflate stream

 	this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy, Z_STREAM_ERROR);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4270

 @SYMTestCaseDesc     	Check raw input is not inflated when windowBits < -15 or > -8.

 @SYMTestPriority     	High

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

                             setting windowBits between -8 and -15. 

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

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

                             passing it the specified parameters.

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

                         •	< -15, > -8 & < 8, >= 8 & <= 15 and >= 24 & <= 31 for windowBits

                         For cases >= 8 & <= 15 and >= 24 & <= 31 inflate the compressed data 

                         and call inflateEnd() to clean up.

 @SYMTestExpectedResults inflateInit2() should fail returning Z_STREAM_ERROR. Note: if 

                         windowBits is set between 8-15 and 24-31 a Z_DATA_ERROR will be 

                         given as it will inflate as a zlib/gzip stream.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDefInfRawFailsL()

 	{

 	int err = Z_OK;

 	TBool ret;

 	// Streams

 	z_stream deflateStream;	

 	z_stream inflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;

 	int method = Z_DEFLATED;

 	int deflateWindowBits = -MAX_WBITS;

 	int inflateWindowBits;

 	int memLevel = TEST_MID_MEM_LEVEL;

 	int strategy = Z_DEFAULT_STRATEGY;

 	// Allocate memory for buffers

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

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

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

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

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

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

     // Read in the value for windowBits from the ini file

 	ret = GetIntFromConfig(ConfigSection(), KParam1, inflateWindowBits);

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

     // Initialise the deflate stream

 	this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy);

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

 	// Compress the input

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

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

 	// Clean up the deflate stream

 	err = deflateEnd(&deflateStream);

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

 	CleanupStack::Pop(1);

 	// Initialise the inflateStream

 	// If windowBits are used that specify a zlib or gzip stream we get a different error

 	if((inflateWindowBits >= 8 && inflateWindowBits <= 15) || (inflateWindowBits >= 24 && inflateWindowBits <= 31))

 		{	

 		this->InflateInit2L(inflateStream, inflateWindowBits);

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

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

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

 		// Clean up the inflateStream

 		err = inflateEnd(&inflateStream);

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

 		CleanupStack::Pop(1);

 		}

 	else 

 		{

 		this->InflateInit2L(inflateStream, inflateWindowBits, Z_STREAM_ERROR);

 		}

 	CleanupStack::PopAndDestroy(2);	

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4271

 @SYMTestCaseDesc     	To check the specified bits are added to the start of a raw stream 

                         correctly using deflatePrime().

 @SYMTestPriority     	Low

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

                             windowBits between -8 and -15. 

                         2.	Call deflatePrime() passing it the specified parameters.

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

                         4.	Check the bits at the front of the output are the expected ones.

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

                         •	0, 8 and 16 for bits

                         •	0, 216  and a number between 0 - 216 for value

 @SYMTestExpectedResults deflatePrime() should return Z_OK and the bits at the front of the 

                         output are the expected ones.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDeflatePrimeL()

 	{

 	int err = Z_OK;

 	TBool ret;

 	// Streams

 	z_stream deflateStream;	

 	// Buffers

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

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

     Byte *compressedDataBuffer;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     // deflateInit2 and inflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;

 	int method = Z_DEFLATED;

 	int deflateWindowBits = -MAX_WBITS;

 	int memLevel = TEST_MID_MEM_LEVEL;

 	int strategy = Z_DEFAULT_STRATEGY;

 	// deflatePrime arguments

 	int bits;

 	int value;

 	// Bits added to the start of the compressed stream

 	Byte bit1 = 0;

 	Byte bit2 = 0;

 	// Allocate memory for buffers

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

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

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

     // Read in the values for bits and value from the ini file

 	ret = GetIntFromConfig(ConfigSection(), KParam1, bits);

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

 	ret = GetIntFromConfig(ConfigSection(), KParam2, value);

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

     // Initialise the deflate stream

 	this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy);

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

 	// Call deflatePrime on the stream

 	err = deflatePrime(&deflateStream, bits, value);

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

 	// Compress the input

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

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

 	// Clean up the deflate stream

 	err = deflateEnd(&deflateStream);

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

 	CleanupStack::Pop(1);

 	// Check the bits at the start of the compressed data are the same as intended

 	// when using deflatePrime()

 	switch(bits)

 	{

 	case 16:

 		bit1 = value & 0xFF;

 		bit2 = (value >> 8) & 0xFF;

 		break;

 	case 8:

 		bit1 = value & 0xFF;

 		bit2 = compressedDataBuffer[1];

 		break;

 	case 0:

 		bit1 = compressedDataBuffer[0];

 		bit2 = compressedDataBuffer[1];

 		break;

 	default:

 		INFO_PRINTF1(_L("The test only works with bits set to 0, 8 or 16."));

 		User::Leave(KErrGeneral);

 	}

 	CHECK_CONDITION0L(compressedDataBuffer[0] != bit1 || compressedDataBuffer[1] != bit2, KErrGeneral, "The bits at the start of the compressed data buffer do not match the specified bits in deflatePrime.");

 	CleanupStack::PopAndDestroy(1);		

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4272

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

 @SYMTestPriority     	Medium

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

                             setting windowBits between -8 and -15. 

                         2.	Call deflatePrime() passing it parameter values:

                             a.	NULL for the stream argument

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

 @SYMTestExpectedResults deflatePrime() fails returning Z_STREAM_ERROR in both cases.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestDeflatePrimeFailsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	 

     // deflateInit2 and inflateInit2 arguments

 	int level = Z_DEFAULT_COMPRESSION;

 	int method = Z_DEFLATED;

 	int deflateWindowBits = -MAX_WBITS;

 	int memLevel = TEST_MID_MEM_LEVEL;

 	int strategy = Z_DEFAULT_STRATEGY;

 	// deflatePrime arguments

 	int bits = 0;

 	int value = 0;

     // Initialise the deflate stream

 	this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy);

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

 	// Call deflatePrime on a NULL stream

 	err = deflatePrime(NULL, bits, value);

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

 	// Try calling deflatePrime on a deflate stream that has a NULL state

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

 	internal_state *deflateState = deflateStream.state;

 	deflateStream.state = NULL;	

 	err = deflatePrime(&deflateStream, bits, value);

 	deflateStream.state = deflateState;

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

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

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

 	// meaning we have to set err back to Z_OK for the test to pass

 	err = deflateEnd(&deflateStream);

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

 	CleanupStack::Pop(1);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4274

 @SYMTestCaseDesc     	Check inflatePrime() fails when given an invalid stream or parameters.

 @SYMTestPriority     	Medium

 @SYMTestActions      	1.	Create an inflate stream and initialise it using inflateInit2(), 

                             setting windowBits to be equal or less than the windowBits value 

                             used for deflateInit2().

                         2.	Call inflatePrime() passing it parameter values:

                             a.	NULL for the stream argument

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

                             c.	> 16 for bits

                             d.	(32 – stream->bits) for bits 

 @SYMTestExpectedResults inflatePrime() fails returning Z_STREAM_ERROR in all cases.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflatePrimeFailsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream inflateStream;

     // inflateInit2 argument

 	int inflateWindowBits = -MAX_WBITS;

 	// deflatePrime arguments

 	int bits = 0;

 	int value = 0;

 	// Initialise the inflate stream

 	this->InflateInit2L(inflateStream, inflateWindowBits);

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

 	// Call inflatePrime on a NULL stream

 	err = inflatePrime(NULL, bits, value);

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

 	// Try calling inflatePrime on a deflate stream that has a NULL state

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

 	struct internal_state FAR *inflateState = inflateStream.state;

 	inflateStream.state = NULL;

 	err = inflatePrime(&inflateStream, bits, value);

 	inflateStream.state = inflateState;

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

 	// Call inflatePrime with bits > 16

 	err = inflatePrime(&inflateStream, 17, value);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime using bits > 16 returned an unexpected value: %d", err);

 	// Call inflatePrime with inflateStream->state->bits + bits > 32

 	// This test cannot be implemented due to inflate_state requiring the definition for

 	// the code struct which is in a header file that is included by one of the zlib

 	// cpp files.

 	/*

 	inflateState = inflateStream.state;

 	inflateState->bits(33 - bits);

 	err = inflatePrime(&inflateStream, bits, value);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime, setting inflateStream->state->bits, returned an unexpected value: %d", err);

 	*/

 	// Clean up the inflate stream

 	err = inflateEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4275

 @SYMTestCaseDesc     	Check that a stream is duplicated correctly when using inflateCopy().

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create a stream and initialise it using deflateInit(). 

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

                         3.	Create an inflate stream and initialise it using inflateInit(). 

                         4.	Create a second inflate stream and copy the first stream to the 

                             second stream using inflateCopy(). 

                         5.	Call inflate() and inflateEnd() on both streams. 

                         6.	Compare the output of both streams.

 @SYMTestExpectedResults inflateCopy() should return Z_OK and the output of both streams will 

                         be identical.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateCopyL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	 

 	z_stream inflateStream;

 	z_stream inflateStreamCopy;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     Byte *copiedDecompressedDataBuffer = NULL;

     uLong copiedDecompressedDataBufferLength = decompressedDataBufferLength;

     // deflateInit argument

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = false;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

 	// Allocate memory for buffers

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

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

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

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

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

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

     copiedDecompressedDataBuffer = (Byte *)User::AllocZ(copiedDecompressedDataBufferLength * sizeof(Byte));

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

     CleanupStack::PushL(TCleanupItem(User::Free, copiedDecompressedDataBuffer));

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

 	// Initialise the inflate streams

 	this->InflateInitL(inflateStream);

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

 	// Copy the inflateStream

 	err = inflateCopy(&inflateStreamCopy, &inflateStream);

 	CHECK_CONDITION1L(err != Z_OK, KErrNoMemory, "inflateCopy error: %d", err);

 	CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStreamCopy));

 	// Decompress the data in the compressedDataBuffer

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

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

 	// Decompress the data in the copiedDecompressedDataBuffer

 	err = this->InflateDecompress(inflateStreamCopy, compressedDataBuffer, deflateStream.total_out, copiedDecompressedDataBuffer, copiedDecompressedDataBufferLength);

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

 	// Clean up the inflate streams

 	err = inflateEnd(&inflateStream);

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

 	err = inflateEnd(&inflateStreamCopy);

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

 	CleanupStack::Pop(2);

 	// Check that both inflate streams produced identical output

 	CHECK_CONDITION0L(memcmp((char *)copiedDecompressedDataBuffer, (char *)decompressedDataBuffer, decompressedDataBufferLength) != 0, KErrGeneral, "The copied stream did not produce the same decompressed output as the original stream.");

 	CleanupStack::PopAndDestroy(3);		

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4276

 @SYMTestCaseDesc     	Check inflateCopy() fails when given an invalid stream or parameters.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create an inflate stream and initialise it using inflateInit(). 

                         2.	Create a second inflate stream and call inflateCopy() passing 

                             it parameter values:

                             a.	NULL for the dest stream argument

                             b.	NULL for the source stream argument

                             c.	a stream whose state is NULL for the source stream argument

                             d.	a stream whose zalloc is Z_NULL for the source stream argument

                             e.	a stream whose zfree is Z_NULL for the source stream argument

 @SYMTestExpectedResults inflateCopy() fails returning Z_STREAM_ERROR in all cases.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateCopyFailsParamsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream inflateStream;

 	z_stream inflateStreamCopy;

 	// Initialise the inflate streams

 	this->InflateInitL(inflateStream);

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

 	// Try to copy from a NULL stream

 	err = inflateCopy(&inflateStreamCopy, NULL);

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

 	// Try to copy to a NULL stream

 	err = inflateCopy(NULL, &inflateStream);

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

 	// Try calling deflateCopy on a deflate stream that has a NULL state

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

 	struct internal_state FAR *state = inflateStream.state;

 	inflateStream.state = NULL;

 	err = inflateCopy(&inflateStreamCopy, &inflateStream);

 	inflateStream.state = state;

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream whose state is NULL returned an unexpected value: %d", err);

 	// Try to copy from a stream with zalloc set to Z_NULL

 	inflateStream.zalloc = Z_NULL;

 	err = inflateCopy(&inflateStreamCopy, &inflateStream);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream with zalloc set to NULL returned an unexpected value: %d", err);

 	// Try to copy from a stream with zfree set to Z_NULL

 	free_func zfree = inflateStream.zfree;

 	inflateStream.zfree = Z_NULL;

 	err = inflateCopy(&inflateStreamCopy, &inflateStream);

 	inflateStream.zfree = zfree;

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream with zfree set to NULL returned an unexpected value: %d", err);

 	// Clean up the inflate streams

 	err = inflateEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4277

 @SYMTestCaseDesc     	Check inflateCopy() fails when there is not enough memory to copy 

                         the stream.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create an inflate stream and initialise it using inflateInit(). 

                         2.	Create a second inflate stream and set memory allocation to 

                             fail on the first attempt. 

                         3.	Copy the first stream to the second stream using inflateCopy(). 

                         4.	Check that the memory is the same before and after calling 

                             inflateCopy(). Note: If Z_OK is returned it will be necessary 

                             to call inflateEnd() before checking the amount of memory.

                         5.	Repeat this process until inflateCopy() returns Z_OK, increasing 

                             the number of allocations that can be performed before failing.

 @SYMTestExpectedResults inflateCopy() fails at first, returning Z_MEM_ERROR, and then it 

                         will succeed with Z_OK. No memory should be leaked.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateCopyFailsMemL()

 	{

 	int err;

 	TVerdict verdict = EPass;	

 	// Streams

 	z_stream inflateStream;

 	z_stream inflateStreamCopy;	

 	// Initialise the inflate streams

 	this->InflateInitL(inflateStream);

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

 	TInt failureRate;

 	for(failureRate = 1, err = Z_MEM_ERROR; err != Z_OK && failureRate <= FAILURE_RATE_LIMIT; failureRate++)

 		{

 		__UHEAP_SETFAIL(RHeap::EDeterministic, failureRate);

 		__UHEAP_MARK;

 		// Copy the inflateStream

 		err = inflateCopy(&inflateStreamCopy, &inflateStream);

 		// Memory has been allocated so we need to clean up

 		if(err == Z_OK)

 			{

 			err = inflateEnd(&inflateStreamCopy);

 			if(err != Z_OK) 

 				{ 

 			    INFO_PRINTF2(_L("inflateStreamCopy - inflateEnd error: %d"), err);

 			    verdict = EAbort;

 			    break;

 			    }		

 			}	

 		else if(err != Z_MEM_ERROR)

 			{

 			INFO_PRINTF2(_L("inflateStreamCopy - unexpected error: %d"), err);

 			verdict = EFail;

 		    break;

 			}

 		__UHEAP_MARKEND;

 		__UHEAP_RESET;		

 		}

 	if(err == Z_OK)

 		{

 		INFO_PRINTF2(_L("The test succeeded at heap failure rate = %d."), --failureRate);

 		}

 	else if(failureRate > FAILURE_RATE_LIMIT)

 		{

 		INFO_PRINTF1(_L("Exceeded FAILURE_RATE_LIMIT. Either the test has failed or the limit needs increasing."));

 		verdict = EFail;

 		}	

 	CleanupStack::PopAndDestroy(1);

 	return verdict;

 	}

 /*

  * in function required by inflateBack.

  * Provides a pointer to the next piece of input data and returns the length of the data

  */

 unsigned in OF((void FAR *in_desc, unsigned char FAR * FAR *in_buf))

 	{	

 	struct bufferDescriptor *compressedDataBufferDescriptor = (struct bufferDescriptor *)in_desc;			

 	*in_buf = &compressedDataBufferDescriptor->buffer[compressedDataBufferDescriptor->next];

 	// Check that there is more input

 	if(compressedDataBufferDescriptor->next + 1 < compressedDataBufferDescriptor->length)

 		{

 		compressedDataBufferDescriptor->next++;

 		return 1;

 		}

 	return 0;

 	}

 /*

  * out function required by inflateBack.

  * Provides a pointer to which the next space in memory data can be output and returns the length of this space

  */

 int out OF((void FAR *out_desc, unsigned char FAR *out_buf, unsigned len))

 	{

 	struct bufferDescriptor *decompressedDataBufferDescriptor = (struct bufferDescriptor *)out_desc;

 	// Make sure there is output space

 	if(decompressedDataBufferDescriptor->next + len <= decompressedDataBufferDescriptor->length)

 		{	

 		memcpy(decompressedDataBufferDescriptor->buffer + decompressedDataBufferDescriptor->next, out_buf, len);

 		decompressedDataBufferDescriptor->next += len;	

 		}

 	else 

 		{

 		int leftOver = decompressedDataBufferDescriptor->length - decompressedDataBufferDescriptor->next;

 		memcpy(decompressedDataBufferDescriptor->buffer + decompressedDataBufferDescriptor->next, out_buf, leftOver);

 		}

 	return 0;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4278

 @SYMTestCaseDesc     	Check a stream can be inflated using inflateBackInit(), 

                         inflateBack() and inflateBackEnd().

 @SYMTestPriority     	High

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

                             setting windowBits between -8 and -15. 

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

                         3.	Create an inflate stream and initialise it using 

                             inflateBackInit() setting windowBits to be equal to or greater 

                             than the windowBits value used for deflateInit2(). 

                         4.	Call inflateBack() to uncompress the stream and call 

                             inflateBackEnd() to clean up. 

                         5.	Compare the original stream with the uncompressed stream.

 @SYMTestExpectedResults inflateBackInit() and inflateBackEnd() should both return Z_OK. 

                         inflateBack() should return Z_STREAM_END when it has finished 

                         inflating the input stream. The original stream should be 

                         identical to the final uncompressed stream.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateBackL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	 

 	z_stream inflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateBackInit arguments

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = true;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

     streamSettings.method = Z_DEFLATED;

     streamSettings.deflateWindowBits = -MAX_WBITS;

     streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits;

     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

     streamSettings.strategy = Z_DEFAULT_STRATEGY;

 	Bytef inflateWindow[32 * 1024];

 	// Allocate memory for buffers

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

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

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

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

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

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

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

 	// Initialise the inflate stream

 	InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow);

 	CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream));

 	// This must be set to NULL otherwise inflateBack will assume there is input and try to decompress it

 	inflateStream.next_in = NULL;

 	struct bufferDescriptor compressedDataBufferDescriptor;	

 	compressedDataBufferDescriptor.buffer = compressedDataBuffer;

 	compressedDataBufferDescriptor.next = 0;

 	compressedDataBufferDescriptor.length = compressedDataBufferLength;

 	struct bufferDescriptor decompressedDataBufferDescriptor;	

 	decompressedDataBufferDescriptor.buffer = decompressedDataBuffer;

 	decompressedDataBufferDescriptor.next = 0;

 	decompressedDataBufferDescriptor.length = decompressedDataBufferLength;

 	// Decompress the input

 	err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

 	CHECK_CONDITION1L(err != Z_STREAM_END, KErrGeneral, "inflateBack error: %d", err);

 	// Clean up the inflate stream

 	err = inflateBackEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	// Check that the decompressed data is identical to the original data

 	CHECK_CONDITION0L(strcmp(inputData, (char *)decompressedDataBuffer) != 0, KErrGeneral, "The deflated data did no match the original data.");

 	CleanupStack::PopAndDestroy(2);	

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4279

 @SYMTestCaseDesc     	Check inflateBackEnd() fails when given an invalid stream or parameters.

 @SYMTestPriority     	High

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

                             setting windowBits between -8 and -15.

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

                         3.	Create an inflate stream and initialise it using 

                             nflateBackInit() setting windowBits to be equal to or greater 

                             than the windowBits value used for deflateInit2(). 

                         4.	Call inflateBack() to uncompress the stream. 

                         5.	Call inflateBackEnd() passing it parameter values:

                             a.	NULL for the stream argument

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

                             c.	a stream whose zfree is Z_NULL for the stream argument

 @SYMTestExpectedResults inflateBackEnd() fails returning Z_STREAM_ERROR in all cases.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateBackEndFailsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	 

 	z_stream inflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateBackInit arguments

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = true;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

     streamSettings.method = Z_DEFLATED;

     streamSettings.deflateWindowBits = -MAX_WBITS;

     streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits;

     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

     streamSettings.strategy = Z_DEFAULT_STRATEGY;

 	Bytef inflateWindow[32 * 1024];

 	// Allocate memory for buffers

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

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

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

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

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

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

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

 	// Initialise the inflate stream

 	InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow);

 	CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream));

 	inflateStream.next_in = (unsigned char *)compressedDataBuffer;

 	inflateStream.avail_in = compressedDataBufferLength;

 	inflateStream.next_out = (unsigned char *)decompressedDataBuffer;

 	inflateStream.avail_out = decompressedDataBufferLength;

 	struct bufferDescriptor compressedDataBufferDescriptor;	

 	compressedDataBufferDescriptor.buffer = compressedDataBuffer;

 	compressedDataBufferDescriptor.next = 0;

 	compressedDataBufferDescriptor.length = compressedDataBufferLength;

 	struct bufferDescriptor decompressedDataBufferDescriptor;	

 	decompressedDataBufferDescriptor.buffer = decompressedDataBuffer;

 	decompressedDataBufferDescriptor.next = 0;

 	decompressedDataBufferDescriptor.length = decompressedDataBufferLength;

 	// Decompress the input

 	err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

 	CHECK_CONDITION1L(err != Z_STREAM_END, KErrGeneral, "inflateBack error: %d", err);

 	// Try cleaning up a NULL stream

 	err = inflateBackEnd(NULL);

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

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

 	struct internal_state FAR *inflateState = inflateStream.state;

 	// Try cleaning up an inflate stream with a NULL state

 	inflateStream.state = NULL;

 	err = inflateBackEnd(&inflateStream);

 	inflateStream.state = inflateState;

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

 	// Try cleaning up an inflate stream with no free function

 	free_func zfree = inflateStream.zfree;

 	inflateStream.zfree = Z_NULL;

 	err = inflateBackEnd(NULL);

 	inflateStream.zfree = zfree;

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackEnd on a stream with zfree set to NULL returned an unexpected value: %d", err);

 	// Clean up the inflate stream

 	err = inflateBackEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	CleanupStack::PopAndDestroy(2);	

 	return EPass;

 	}

 /*

  * in function required by inflateBack.

  * Returning 0 indicates failure.

  */

 unsigned inNoInput OF((void FAR *, unsigned char FAR * FAR *))

 	{

 	return 0;

 	}

 /*

  * out function required by inflateBack.

  * Returning non 0 indicates failure.

  */

 int outNoOutput OF((void FAR *, unsigned char FAR *, unsigned))

 	{

 	return 1;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4280

 @SYMTestCaseDesc     	Check inflateBack() fails when given an invalid stream or parameters.

 @SYMTestPriority     	High

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

                             setting windowBits between -8 and-15. 

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

                         3.	Create an inflate stream and initialise it using 

                             inflateBackInit() setting windowBits to be equal to or greater 

                             than the windowBits value used for deflateInit2(). 

                         4.	Call inflateBack() passing it parameter values:

                             a.	NULL for the stream argument

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

                             c.	an input function that returns 0 for the in argument

                             d.	an output function that doesn’t return 0 for the out argument

                             e.	corrupted deflate output

                         5.	Call inflateBackEnd() to clean up

 @SYMTestExpectedResults inflateBack() fails returning Z_STREAM_ERROR for the first two 

                         cases, Z_BUF_ERROR for the second two cases and Z_DATA_ERROR 

                         for the final case.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateBackFailsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream deflateStream;	 

 	z_stream inflateStream;

 	// Buffers

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

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

     Byte *compressedDataBuffer = NULL;

     uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH;

     Byte *decompressedDataBuffer = NULL;

     uLong decompressedDataBufferLength = inputDataLength;

     // deflateInit2 and inflateBackInit arguments

     StreamSettings streamSettings;

     streamSettings.deflateInit2 = true;

     streamSettings.level = Z_DEFAULT_COMPRESSION;

     streamSettings.method = Z_DEFLATED;

     streamSettings.deflateWindowBits = -MAX_WBITS;

     streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits; // inflateBackInit expects the positive equivalent of the windowBits used to make a raw stream

     streamSettings.memLevel = TEST_MID_MEM_LEVEL;

     streamSettings.strategy = Z_DEFAULT_STRATEGY;

 	Bytef inflateWindow[32 * 1024];

 	// Allocate memory for buffers

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

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

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

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

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

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

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

 	// Initialise the inflate stream

 	InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow);

 	CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream));

 	// This must be set to NULL otherwise inflateBack will assume there is input and try to decompress it

 	inflateStream.next_in = NULL;

 	struct bufferDescriptor compressedDataBufferDescriptor;	

 	compressedDataBufferDescriptor.buffer = compressedDataBuffer;

 	compressedDataBufferDescriptor.next = 0;

 	compressedDataBufferDescriptor.length = compressedDataBufferLength;

 	struct bufferDescriptor decompressedDataBufferDescriptor;	

 	decompressedDataBufferDescriptor.buffer = decompressedDataBuffer;

 	decompressedDataBufferDescriptor.next = 0;

 	decompressedDataBufferDescriptor.length = decompressedDataBufferLength;

 	// Try inflating a NULL stream

 	err = inflateBack(NULL, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

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

 	// Try calling inflateBack on a deflate stream that has a NULL state

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

 	struct internal_state FAR *inflateState = inflateStream.state;

 	inflateStream.state = NULL;

 	err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

 	inflateStream.state = inflateState;

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

 	// Try inflating a stream with an in_func that returns no input data

 	err = inflateBack(&inflateStream, &inNoInput, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

 	CHECK_CONDITION1L(err != Z_BUF_ERROR, KErrGeneral, "Calling inflateBack with an in function that returns no input returned an unexpected value: %d", err);

 	// Try inflating a stream with an out_func that does not output any data

 	err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &outNoOutput, &decompressedDataBufferDescriptor);

 	CHECK_CONDITION1L(err != Z_BUF_ERROR, KErrGeneral, "Calling inflateBack with an in function that returns no input returned an unexpected value: %d", err);

 	// Try inflating a corrupt stream

 	compressedDataBuffer[1] = 'a';

 	compressedDataBuffer[2] = 'a';

 	compressedDataBuffer[3] = 'a';

 	err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor);

 	CHECK_CONDITION1L(err != Z_DATA_ERROR, KErrGeneral, "Calling inflateBack on a corrupt stream returned an unexpected value: %d", err);

 	// Clean up the inflate stream

 	err = inflateBackEnd(&inflateStream);

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

 	CleanupStack::Pop(1);

 	CleanupStack::PopAndDestroy(2);	

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4281

 @SYMTestCaseDesc     	Check inflateBackInit() fails when given an invalid stream or parameters.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create an inflate stream and initialise it using 

                             inflateBackInit() passing it parameter values:

                             a.	NULL for the stream argument

                             b.	a stream whose window is NULL for the stream argument

                             c.	< 8 for the windowBits argument

                             d.	> 5 for the windowBits argument

 @SYMTestExpectedResults inflateBackInit() should fail returning Z_STREAM_ERROR for all cases.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateBackInitFailsParamsL()

 	{

 	int err = Z_OK;

 	// Streams

 	z_stream inflateStream;

     // inflateBackInit arguments

 	int inflateBackWindowBits = MAX_WBITS;

 	Bytef inflateWindow[32 * 1024];

 	// Try initialising a NULL stream

 	inflateStream.zalloc = Z_NULL;

 	inflateStream.zfree = Z_NULL;

 	inflateStream.opaque = Z_NULL;

 	err = inflateBackInit(NULL, inflateBackWindowBits, inflateWindow);

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

 	// Try initialising a stream with a NULL inflate window

 	err = inflateBackInit(&inflateStream, inflateBackWindowBits, NULL);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with a NULL window returned an unexpected value: %d", err);

 	// Try initialising a stream with window bits < 8

 	err = inflateBackInit(&inflateStream, 7, inflateWindow);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with windowBits < 8 returned an unexpected value: %d", err);

 	// Try initialising a stream with window bits > 15

 	err = inflateBackInit(&inflateStream, 16, inflateWindow);

 	CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with windowBits > 15 returned an unexpected value: %d", err);

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4282

 @SYMTestCaseDesc     	Check inflateBackInit() fails when there is not enough memory.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create an inflate stream and set the next memory allocation to fail. 

                         2.	Initialise the stream using inflateBackInit() setting 

                             windowBits to be between 8 and 15. 

                         3.	Check that the memory is the same before and after calling 

                             inflateBackInit(). Note: If Z_OK is returned it will be 

                             necessary to call inflateEnd() before checking the amount of memory.

                         4.	Repeat this process until inflateBackInit() returns Z_OK, 

                             increasing the number of allocations that can be performed before failing.

 @SYMTestExpectedResults inflateBackInit () fails at first, returning Z_MEM_ERROR, and then 

                         it will succeed with Z_OK. No memory should be leaked.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestInflateBackInitFailsMem()

 	{

 	TInt err;

 	TVerdict verdict = EPass;

 	// Streams

 	z_stream inflateStream;

     // inflateBackInit arguments

 	int inflateBackWindowBits = MAX_WBITS;

 	Bytef inflateWindow[32 * 1024];

 	inflateStream.zalloc = Z_NULL;

 	inflateStream.zfree = Z_NULL;

 	inflateStream.opaque = Z_NULL;

 	TInt failureRate;

 	for(failureRate = 1, err = Z_MEM_ERROR; err != Z_OK && failureRate <= FAILURE_RATE_LIMIT; failureRate++)

 		{

 		__UHEAP_SETFAIL(RHeap::EDeterministic, failureRate);

 		__UHEAP_MARK;

 		err = inflateBackInit(&inflateStream, inflateBackWindowBits, inflateWindow);

 		// Memory has been allocated so we need to clean up

 		if(err == Z_OK)

 			{

 			err = inflateBackEnd(&inflateStream);

 			if(err != Z_OK) 

 				{ 

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

 			    verdict = EAbort;

 			    break;

 			    }		

 			}	

 		else if(err != Z_MEM_ERROR)

 			{

 			INFO_PRINTF2(_L("inflateBackInit unexpected error: %d"), err);

 			verdict = EFail;

 		    break;

 			}

 		__UHEAP_MARKEND;

 		__UHEAP_RESET;		

 		}

 	if(err == Z_OK)

 		{

 		INFO_PRINTF2(_L("The test succeeded at heap failure rate = %d."), --failureRate);

 		}

 	else if(failureRate > FAILURE_RATE_LIMIT)

 		{

 		INFO_PRINTF1(_L("Exceeded FAILURE_RATE_LIMIT. Either the test has failed or the limit needs increasing."));

 		verdict = EFail;

 		}

 	return verdict;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4283

 @SYMTestCaseDesc     	Check adler32_combine() generates the correct adler32 checksum.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create two byte buffers, both containing different data, and 

                             use these to create two checksums using adler32(). 

                         2.	Create a third checksum using adler32_combine(), providing it 

                             with the first two checksums and the length of the second checksum. 

                         3.	Concatenate the two byte buffers and create a fourth checksum 

                             using adler32() and the concatenated buffer as input. 

                         4.	Compare the third and fourth checksums.

 @SYMTestExpectedResults The third and fourth checksums should be identical.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestAdler32CombineL()

 	{

 	// Byte buffers from which the adler32 checksums will be generated

 	const Byte *string1 = (Byte *)"Hello";

 	const Byte *string2 = (Byte *)"World";

 	const int string1Length = 5;	

 	const int string2Length = 5;	

     const int string3Length = 10;	

 	// Initialise the adler32 variables

 	uLong adlerString1 = adler32(0L, NULL, 0);

 	uLong adlerString2 = adler32(0L, NULL, 0);

 	uLong adlerString3 = adler32(0L, NULL, 0);

 	uLong adlerCombined;

 	// Generate the checksums from the byte buffers

 	adlerString1 = adler32(adlerString1, string1, string1Length);

 	adlerString2 = adler32(adlerString2, string2, string2Length);

 	// Generate the checksum from combining adlerString1 and adlerString2

 	adlerCombined = adler32_combine(adlerString1, adlerString2, string2Length);

 	// Concatenate the byte buffers so that a checksum can be generated

 	Byte string3[string3Length];

 	memcpy((char *)string3, (char *)string1, string1Length);            

 	memcpy((char *)string3 + string1Length, (char *)string2, string2Length);

 	// Generate checksum

 	adlerString3 = adler32(adlerString3, string3, string3Length);

 	// Compare the checksums to see if they are the same

 	CHECK_CONDITION0L(adlerString3 != adlerCombined, KErrGeneral, "The combined checksum is not correct.");

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4284

 @SYMTestCaseDesc     	Check crc32_combine() generates the correct crc32 checksum.

 @SYMTestPriority     	High

 @SYMTestActions      	1.	Create two byte buffers, both containing different data, and 

                             use these to create two checksums using crc32(). 

                         2.	Create a third checksum using crc32_combine(), providing it 

                             with the first two checksums and the length of the second checksum. 

                         3.	Concatenate the two byte buffers and create a fourth checksum 

                             using crc32() and the concatenated buffer as input. 

                         4.	Compare the third and fourth checksums.

 @SYMTestExpectedResults The third and fourth checksums should be identical.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestCrc32CombineL()

 	{

 	// Byte buffers from which the crc32 checksums will be generated

 	const Byte *string1 = (Byte *)"Hello";

 	const Byte *string2 = (Byte *)"World";

 	const int string1Length = 5;	

 	const int string2Length = 5;	

     const int string3Length = 10;	

 	// Initialise the crc32 variables

 	uLong crcString1 = crc32(0L, NULL, 0);

 	uLong crcString2 = crc32(0L, NULL, 0);

 	uLong crcString3 = crc32(0L, NULL, 0);

 	uLong crcCombined;

 	// Generate the checksums from the byte buffers

 	crcString1 = crc32(crcString1, string1, string1Length);

 	crcString2 = crc32(crcString2, string2, string2Length);

 	// Generate the checksum from combining adlerString1 and adlerString2

 	crcCombined = crc32_combine(crcString1, crcString2, string2Length);

 	// Concatenate the byte buffers so that a checksum can be generated

 	Byte string3[string3Length];

 	memcpy((char *)string3, (char *)string1, string1Length);            

 	memcpy((char *)string3 + string1Length, (char *)string2, string2Length);

 	// Generate checksum

 	crcString3 = crc32(crcString3, string3, string3Length);

 	// Compare the checksums to see if they are the same

 	CHECK_CONDITION0L(crcString3 != crcCombined, KErrGeneral, "The combined checksum is not correct.");

 	return EPass;

 	}

 /**

 @SYMTestCaseID       	SYSLIB-EZLIB2-UT-4284

 @SYMTestCaseDesc     	Check zlibCompileFlags() returns a uLong with the correct 

                         compile flags set.

 @SYMTestPriority     	Medium

 @SYMTestActions      	1.	Call zlibCompileFlags() and compare the first 2 bits with the 

                             size of uInt, the second 2 bits with the size of uLong and 

                             bits 16 and 17 with 0 (GZip APIs are being used).

 @SYMTestExpectedResults zlibCompileFlags() will return a uLong and all the comparisons 

                         will return true.

 @SYMDEF                 REQ7362

 */

 TVerdict CTestZlib::TestZlibCompileFlagsL()

 	{

 	// Get the compilerFlags

 	uLong compileFlags = zlibCompileFlags();

 	int compileFlagsUInt = compileFlags & 0x3;

 	int compileFlagsULong = (compileFlags >> 2) & 0x3;

 	int compileFlagsGZip = (compileFlags >> 15) & 0x3;

 	int machineUInt;

 	int machineULong;

 	// Get the size of uInt

 	switch(sizeof(uInt))

 		{

 		case 2: machineUInt = 0;

 				break;

 		case 4: machineUInt = 1;

 				 break;

 		case 8: machineUInt = 2;

 				 break;

 		default: machineUInt = 3;

 		}

 	// Check the compiler flag for uInt is correct

 	CHECK_CONDITION0L(machineUInt != compileFlagsUInt, KErrGeneral, "zlibCompileFlags reports an incorrect size for uInt.");

 	// Get the size of uLong

 	switch(sizeof(uLong))

 		{

 		case 2: machineULong = 0;

 				break;

 		case 4: machineULong = 1;

 				 break;

 		case 8: machineULong = 2;

 				 break;

 		default: machineULong = 3;

 		}

 	// Check the compiler flag for uLong is correct

 	CHECK_CONDITION0L(machineULong != compileFlagsULong, KErrGeneral, "zlibCompileFlags reports an incorrect size for uLong.");

 	// Check the compiler flags for GZip compression are correct

 	CHECK_CONDITION0L(compileFlagsGZip != 0, KErrGeneral, "zlibCompileFlags reports GZip functionality is disabled.");

 	return EPass;

 	}