// 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        : tzlibcases.cpp

// 

//

#include "tzlib.h"

//uLong dictId;

#define CHECK_ERR(err, msg) { \

	if (err != Z_OK) { \

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

	return err; \

	} \

}

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

	{

	z_stream c_stream; // compression stream 

	int err;

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

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

	c_stream.zalloc = (alloc_func)0;

	c_stream.zfree = (free_func)0;

	c_stream.opaque = (voidpf)0;

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

	if (err != Z_OK) 

		{ 

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

		return err; 

		} 

	c_stream.next_in  = (Bytef*)hello;

	c_stream.next_out = compr;

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

		{

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

		err = deflate(&c_stream, flush);

		if (err != Z_OK) 

			{ 

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

			deflateEnd(&c_stream);

			return err; 

			} 

		}

	// Finish the stream, still forcing small buffers: 

	for (;;) 

		{

		c_stream.avail_out = 1;

		err = deflate(&c_stream, Z_FINISH);

		if (err == Z_STREAM_END) break;

		if (err != Z_OK)

			{ 

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

			deflateEnd(&c_stream);

			return err; 

			} 

		}

	deflateEnd(&c_stream);

	return KErrNone;

	}

/**

 * Function Name : TestDeflateTest01

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

 *						2. Reads negative flush value 

 */

TInt CTestZlib::TestDeflateTest01( )

	{

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

	TInt flush, compression, expRet;

	Byte *comp;

	uLong compLen;

	compLen = 30;

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

	ReadIntParam(flush);

	ReadIntParam(compression);

	ReadIntParam(expRet);

	z_stream c_stream; // compression stream 

	int err;

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

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

	c_stream.zalloc = (alloc_func)0;

	c_stream.zfree = (free_func)0;

	c_stream.opaque = (voidpf)0;

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

	if (err != Z_OK) 

		{ 

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

		free(comp);

		return err; 

		}  

	c_stream.next_in  = (Bytef*)hello;

	c_stream.next_out = comp;

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

		{

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

		err = deflate(&c_stream, flush);

		if (err == Z_STREAM_ERROR) 

			{ 

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

			deflateEnd(&c_stream);

			free(comp);

			return KErrNone; 

			}

		}

	return KErrNone;

	}

/**

 * Function Name : TestDeflatecopyDestNull

 * TestCase Description: Deflate copy with Destination as NULL

 */

TInt CTestZlib::TestDeflatecopyDestNull()

	{

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

	TInt retVal=0;

	Byte *compr, *uncompr;

	uLong comprLen = 20*sizeof(int); 

	uLong uncomprLen = comprLen;

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

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

	if (uncompr == Z_NULL) 

		{

		free(compr);

		return KErrNoMemory;

		}	

	z_stream stream;

	int err;

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

	stream.next_in = (Bytef*)hello;

	stream.avail_in = (uInt)len;

	stream.next_out = compr;

	stream.avail_out = (uInt)comprLen;

	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);

	err=deflateCopy(NULL , &stream); 

	if (err == Z_STREAM_ERROR )  

		{

		deflateEnd(&stream);

		free(compr);

		free(uncompr);

		retVal = KErrNone; 

		} 

	return retVal;   

	}

/**

 * Function Name : TestDeflateCopyStreamStateNull

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

 * Return value: KErrNone on deflateCopy retruning Z_STREAM_ERROR

 */

TInt CTestZlib::TestDeflateCopyStreamStateNull()

	{

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

	TInt retVal=0;

	Byte *compr, *uncompr;

	uLong comprLen = 20*sizeof(int); 

	uLong uncomprLen = comprLen;

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

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

	if (uncompr == Z_NULL) 

		{

		free(compr);

		return KErrNoMemory;

		}	    	

	z_stream stream;

	z_stream stream1;

	int err = KErrNone;

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

	stream.next_in = (Bytef*)hello;

	stream.avail_in = (uInt)len;

	stream.next_out = compr;

	stream.avail_out = (uInt)comprLen;

	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);

	err=deflateCopy(&stream1, &stream);

	deflateEnd(&stream);

	deflateEnd(&stream1);

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

	stream.state = Z_NULL;

	err=deflateCopy(&stream1 , &stream); 

	if (err == Z_STREAM_ERROR )

		{

		retVal = KErrNone; 

		}

	free(compr);

	free(uncompr);

	return retVal;   

	}

/**

 * Function Name : TestDeflateInit2_WindowBits

 * TestCase Description: 1. WindowBits value more than 15

 *						2. WindowBits value less than 8

 *						3. WindowBits 8

 */

TInt CTestZlib::TestDeflateInit2_WindowBits()

	{

	TInt res = KErrNone;

	z_stream stream;

	int err;

	int level=Z_DEFAULT_COMPRESSION;

	int WindowBits=0;

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadIntParam(WindowBits);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

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

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

	if (err == Z_STREAM_ERROR) 

		{

		res = KErrNone;

		}

	else if (err == Z_OK)

		{

		deflateEnd(&stream);

		res = KErrNone;

		}

	else  

		{    	

		res = KErrGeneral; 

		}       

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_StreamSize

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

 */

TInt CTestZlib::TestDeflateInit2_StreamSize()

	{

	TInt res = KErrNone ;

	z_stream stream;

	int err;

	int level=Z_DEFAULT_COMPRESSION;

	int WindowBits=0;

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadIntParam(WindowBits);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

	// passing stream size < sizeof(z_stream)

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

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

	if (err == Z_VERSION_ERROR) 

		{

		res = KErrNone;

		}

	else  

		{    	

		res = KErrGeneral; 

		}       

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_MemLevel

 * TestCase Description: 1. MemLevel value less than 1

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

 */

TInt CTestZlib::TestDeflateInit2_MemLevel()

	{

	TInt res = KErrNone ;

	z_stream stream;

	int err;

	int level=Z_DEFAULT_COMPRESSION;

	int MemLevel=0;

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadIntParam(MemLevel);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

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

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

	if (err == Z_STREAM_ERROR) 

		{

		res = KErrNone;

		} 

	else  

		{    	

		res = KErrGeneral; 

		}       

	//deflateEnd(&stream);

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_Level

 * TestCase Description: 1. Level value less than 0

 *						2. Level value more than 9

 */

TInt CTestZlib::TestDeflateInit2_Level()

	{

	TInt res = KErrNone ;

	z_stream stream;

	int err;

	int level=0;

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadIntParam(level);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

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

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

	if (err == Z_STREAM_ERROR) 

		{

		res = KErrNone;

		} 

	else  

		{    	

		res = KErrGeneral; 

		}       

	//deflateEnd(&stream);

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_Strategy

 * TestCase Description: 1. Strategy value less than 0

 *						2. Strategy value more than Z_FIXED

 */

TInt CTestZlib::TestDeflateInit2_Strategy()

	{

	TInt res = KErrNone ;

	z_stream stream;

	int err;

	int level=Z_DEFAULT_COMPRESSION;

	int strategy=0;

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadIntParam(strategy);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

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

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

	if (err == Z_STREAM_ERROR) 

		{

		res = KErrNone;

		} 

	else  

		{    	

		res = KErrGeneral; 

		}       

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_Version

 * TestCase Description: Invalid version value

 * Return Value: returns Z_VERSION_ERROR

 */

TInt CTestZlib::TestDeflateInit2_Version()

	{

	TInt res = KErrNone ;

	z_stream stream;

	int err;

	int level=Z_DEFAULT_COMPRESSION;

	char version[5];

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

	Byte *compr;

	uLong comprLen = 10*sizeof(int); 

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

	if (compr == Z_NULL)

		{

		return KErrNoMemory;

		}

	ReadStringParam(version);

	stream.zalloc = (alloc_func)0;

	stream.zfree = (free_func)0;

	stream.opaque = (voidpf)0;

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

			0, version, sizeof(z_stream));

	if (err == Z_VERSION_ERROR) 

		{

		res = KErrNone;

		} 

	else  

		{

		res = KErrGeneral; 

		}       

	free(compr);

	return res;

	}

/**

 * Function Name : TestDeflateInit2_VersionNull

 * TestCase Description: version value is Z_NULL

 * Return Value: Z_VERSION_ERROR

 */

TInt CTestZlib::TestDeflateInit2_VersionNull()

	{

	TInt res = KErrNone ;

	z_stream stream;