Symaptic: os/ossrv/compressionlibs/ziplib/test/tef/tlibz/src/tzlibblocks.cpp@260cb5ec6c19 (annotated)

sl@0	1	// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	// Name : tzlibcases.cpp
sl@0	15	//
sl@0	16	//
sl@0	17
sl@0	18	#include "tzlib.h"
sl@0	19
sl@0	20	//uLong dictId;
sl@0	21
sl@0	22	#define CHECK_ERR(err, msg) { \
sl@0	23	if (err != Z_OK) { \
sl@0	24	INFO_PRINTF2(_L("Error: %d"), err); \
sl@0	25	return err; \
sl@0	26	} \
sl@0	27	}
sl@0	28
sl@0	29
sl@0	30	TInt CTestZlib::PreDeflateInit( Byte * compr, uLong comprLen, TInt flush, TInt compression)
sl@0	31	{
sl@0	32	z_stream c_stream; // compression stream
sl@0	33	int err;
sl@0	34	const char hello[] = "hello, hello!";
sl@0	35	uLong len = (uLong)strlen(hello)+1;
sl@0	36
sl@0	37	c_stream.zalloc = (alloc_func)0;
sl@0	38	c_stream.zfree = (free_func)0;
sl@0	39	c_stream.opaque = (voidpf)0;
sl@0	40
sl@0	41	err = deflateInit(&c_stream,compression);// Z_DEFAULT_COMPRESSION);
sl@0	42
sl@0	43	if (err != Z_OK)
sl@0	44	{
sl@0	45	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	46	return err;
sl@0	47	}
sl@0	48
sl@0	49	c_stream.next_in = (Bytef*)hello;
sl@0	50	c_stream.next_out = compr;
sl@0	51
sl@0	52	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	53	{
sl@0	54	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	55	err = deflate(&c_stream, flush);
sl@0	56	if (err != Z_OK)
sl@0	57	{
sl@0	58	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	59	deflateEnd(&c_stream);
sl@0	60	return err;
sl@0	61	}
sl@0	62	}
sl@0	63	// Finish the stream, still forcing small buffers:
sl@0	64	for (;;)
sl@0	65	{
sl@0	66	c_stream.avail_out = 1;
sl@0	67	err = deflate(&c_stream, Z_FINISH);
sl@0	68	if (err == Z_STREAM_END) break;
sl@0	69	if (err != Z_OK)
sl@0	70	{
sl@0	71	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	72	deflateEnd(&c_stream);
sl@0	73	return err;
sl@0	74	}
sl@0	75	}
sl@0	76
sl@0	77	deflateEnd(&c_stream);
sl@0	78	return KErrNone;
sl@0	79	}
sl@0	80
sl@0	81	/**
sl@0	82	* Function Name : TestDeflateTest01
sl@0	83	* TestCase Description: 1. Reads flush value more than Z_FINISH [i.e, 4]
sl@0	84	* 2. Reads negative flush value
sl@0	85	*/
sl@0	86	TInt CTestZlib::TestDeflateTest01( )
sl@0	87	{
sl@0	88	INFO_PRINTF1(_L("Zlib Test deflate"));
sl@0	89	TInt flush, compression, expRet;
sl@0	90
sl@0	91	Byte *comp;
sl@0	92	uLong compLen;
sl@0	93	compLen = 30;
sl@0	94	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	95
sl@0	96	ReadIntParam(flush);
sl@0	97	ReadIntParam(compression);
sl@0	98	ReadIntParam(expRet);
sl@0	99
sl@0	100	z_stream c_stream; // compression stream
sl@0	101	int err;
sl@0	102	const char hello[] = "hello, hello!";
sl@0	103	uLong len = (uLong)strlen(hello)+1;
sl@0	104
sl@0	105	c_stream.zalloc = (alloc_func)0;
sl@0	106	c_stream.zfree = (free_func)0;
sl@0	107	c_stream.opaque = (voidpf)0;
sl@0	108
sl@0	109	err = deflateInit(&c_stream,compression);// Z_DEFAULT_COMPRESSION);
sl@0	110
sl@0	111	if (err != Z_OK)
sl@0	112	{
sl@0	113	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	114	free(comp);
sl@0	115	return err;
sl@0	116	}
sl@0	117
sl@0	118	c_stream.next_in = (Bytef*)hello;
sl@0	119	c_stream.next_out = comp;
sl@0	120
sl@0	121	while (c_stream.total_in != len && c_stream.total_out < compLen)
sl@0	122	{
sl@0	123	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	124	err = deflate(&c_stream, flush);
sl@0	125	if (err == Z_STREAM_ERROR)
sl@0	126	{
sl@0	127	INFO_PRINTF1(_L("Negative test case passed"));
sl@0	128	deflateEnd(&c_stream);
sl@0	129	free(comp);
sl@0	130	return KErrNone;
sl@0	131	}
sl@0	132	}
sl@0	133
sl@0	134	return KErrNone;
sl@0	135
sl@0	136	}
sl@0	137
sl@0	138	/**
sl@0	139	* Function Name : TestDeflatecopyDestNull
sl@0	140	* TestCase Description: Deflate copy with Destination as NULL
sl@0	141	*/
sl@0	142	TInt CTestZlib::TestDeflatecopyDestNull()
sl@0	143	{
sl@0	144	uLong len = (uLong)strlen(hello)+1;
sl@0	145	TInt retVal=0;
sl@0	146	Byte compr, uncompr;
sl@0	147	uLong comprLen = 20*sizeof(int);
sl@0	148	uLong uncomprLen = comprLen;
sl@0	149	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	150	if (compr == Z_NULL)
sl@0	151	{
sl@0	152	return KErrNoMemory;
sl@0	153	}
sl@0	154
sl@0	155	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	156	if (uncompr == Z_NULL)
sl@0	157	{
sl@0	158	free(compr);
sl@0	159	return KErrNoMemory;
sl@0	160	}
sl@0	161
sl@0	162
sl@0	163	z_stream stream;
sl@0	164	int err;
sl@0	165
sl@0	166	stream.zalloc = (alloc_func)0;
sl@0	167	stream.zfree = (free_func)0;
sl@0	168	stream.opaque = (voidpf)0;
sl@0	169
sl@0	170	stream.next_in = (Bytef*)hello;
sl@0	171	stream.avail_in = (uInt)len;
sl@0	172
sl@0	173	stream.next_out = compr;
sl@0	174	stream.avail_out = (uInt)comprLen;
sl@0	175
sl@0	176	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
sl@0	177
sl@0	178	err=deflateCopy(NULL , &stream);
sl@0	179
sl@0	180	if (err == Z_STREAM_ERROR )
sl@0	181	{
sl@0	182	deflateEnd(&stream);
sl@0	183	free(compr);
sl@0	184	free(uncompr);
sl@0	185	retVal = KErrNone;
sl@0	186	}
sl@0	187
sl@0	188	return retVal;
sl@0	189	}
sl@0	190
sl@0	191	/**
sl@0	192	* Function Name : TestDeflateCopyStreamStateNull
sl@0	193	* TestCase Description: Deflate copy with source stream state as Z_NULL
sl@0	194	* Return value: KErrNone on deflateCopy retruning Z_STREAM_ERROR
sl@0	195	*/
sl@0	196	TInt CTestZlib::TestDeflateCopyStreamStateNull()
sl@0	197	{
sl@0	198	uLong len = (uLong)strlen(hello)+1;
sl@0	199	TInt retVal=0;
sl@0	200	Byte compr, uncompr;
sl@0	201	uLong comprLen = 20*sizeof(int);
sl@0	202	uLong uncomprLen = comprLen;
sl@0	203	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	204	if (compr == Z_NULL)
sl@0	205	{
sl@0	206	return KErrNoMemory;
sl@0	207	}
sl@0	208
sl@0	209	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	210	if (uncompr == Z_NULL)
sl@0	211	{
sl@0	212	free(compr);
sl@0	213	return KErrNoMemory;
sl@0	214	}
sl@0	215
sl@0	216	z_stream stream;
sl@0	217	z_stream stream1;
sl@0	218	int err = KErrNone;
sl@0	219
sl@0	220	stream.zalloc = (alloc_func)0;
sl@0	221	stream.zfree = (free_func)0;
sl@0	222	stream.opaque = (voidpf)0;
sl@0	223
sl@0	224	stream.next_in = (Bytef*)hello;
sl@0	225	stream.avail_in = (uInt)len;
sl@0	226
sl@0	227	stream.next_out = compr;
sl@0	228	stream.avail_out = (uInt)comprLen;
sl@0	229
sl@0	230	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
sl@0	231
sl@0	232	err=deflateCopy(&stream1, &stream);
sl@0	233	deflateEnd(&stream);
sl@0	234	deflateEnd(&stream1);
sl@0	235
sl@0	236	// Make stream state Z_NULL and call deflateCopy for coverage imrprovement
sl@0	237	stream.state = Z_NULL;
sl@0	238	err=deflateCopy(&stream1 , &stream);
sl@0	239
sl@0	240	if (err == Z_STREAM_ERROR )
sl@0	241	{
sl@0	242	retVal = KErrNone;
sl@0	243	}
sl@0	244	free(compr);
sl@0	245	free(uncompr);
sl@0	246	return retVal;
sl@0	247	}
sl@0	248
sl@0	249	/**
sl@0	250	* Function Name : TestDeflateInit2_WindowBits
sl@0	251	* TestCase Description: 1. WindowBits value more than 15
sl@0	252	* 2. WindowBits value less than 8
sl@0	253	* 3. WindowBits 8
sl@0	254	*/
sl@0	255	TInt CTestZlib::TestDeflateInit2_WindowBits()
sl@0	256	{
sl@0	257	TInt res = KErrNone;
sl@0	258	z_stream stream;
sl@0	259	int err;
sl@0	260	int level=Z_DEFAULT_COMPRESSION;
sl@0	261	int WindowBits=0;
sl@0	262
sl@0	263	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	264	Byte *compr;
sl@0	265	uLong comprLen = 10*sizeof(int);
sl@0	266	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	267	if (compr == Z_NULL)
sl@0	268	{
sl@0	269	return KErrNoMemory;
sl@0	270	}
sl@0	271
sl@0	272	ReadIntParam(WindowBits);
sl@0	273	stream.zalloc = (alloc_func)0;
sl@0	274	stream.zfree = (free_func)0;
sl@0	275	stream.opaque = (voidpf)0;
sl@0	276
sl@0	277
sl@0	278	err= deflateInit2_(&stream, level, 8, WindowBits, 8,
sl@0	279	0, zlibVersion(), sizeof(z_stream));
sl@0	280
sl@0	281	if (err == Z_STREAM_ERROR)
sl@0	282	{
sl@0	283	res = KErrNone;
sl@0	284	}
sl@0	285	else if (err == Z_OK)
sl@0	286	{
sl@0	287	deflateEnd(&stream);
sl@0	288	res = KErrNone;
sl@0	289	}
sl@0	290	else
sl@0	291	{
sl@0	292	res = KErrGeneral;
sl@0	293	}
sl@0	294
sl@0	295	free(compr);
sl@0	296	return res;
sl@0	297	}
sl@0	298
sl@0	299
sl@0	300
sl@0	301	/**
sl@0	302	* Function Name : TestDeflateInit2_StreamSize
sl@0	303	* TestCase Description: Stream size less than sizeof(z_stream)
sl@0	304	*/
sl@0	305	TInt CTestZlib::TestDeflateInit2_StreamSize()
sl@0	306	{
sl@0	307	TInt res = KErrNone ;
sl@0	308	z_stream stream;
sl@0	309	int err;
sl@0	310	int level=Z_DEFAULT_COMPRESSION;
sl@0	311	int WindowBits=0;
sl@0	312
sl@0	313	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	314	Byte *compr;
sl@0	315	uLong comprLen = 10*sizeof(int);
sl@0	316	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	317	if (compr == Z_NULL)
sl@0	318	{
sl@0	319	return KErrNoMemory;
sl@0	320	}
sl@0	321
sl@0	322	ReadIntParam(WindowBits);
sl@0	323	stream.zalloc = (alloc_func)0;
sl@0	324	stream.zfree = (free_func)0;
sl@0	325	stream.opaque = (voidpf)0;
sl@0	326
sl@0	327	// passing stream size < sizeof(z_stream)
sl@0	328	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	329	0, zlibVersion(), sizeof(z_stream)-10);
sl@0	330
sl@0	331	if (err == Z_VERSION_ERROR)
sl@0	332	{
sl@0	333	res = KErrNone;
sl@0	334	}
sl@0	335	else
sl@0	336	{
sl@0	337	res = KErrGeneral;
sl@0	338	}
sl@0	339
sl@0	340	free(compr);
sl@0	341	return res;
sl@0	342	}
sl@0	343
sl@0	344	/**
sl@0	345	* Function Name : TestDeflateInit2_MemLevel
sl@0	346	* TestCase Description: 1. MemLevel value less than 1
sl@0	347	* 2. MemLevel value more than MAX_MEM_LEVEL [i.e., 8]
sl@0	348	*/
sl@0	349	TInt CTestZlib::TestDeflateInit2_MemLevel()
sl@0	350	{
sl@0	351	TInt res = KErrNone ;
sl@0	352	z_stream stream;
sl@0	353	int err;
sl@0	354	int level=Z_DEFAULT_COMPRESSION;
sl@0	355	int MemLevel=0;
sl@0	356
sl@0	357	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	358	Byte *compr;
sl@0	359	uLong comprLen = 10*sizeof(int);
sl@0	360	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	361	if (compr == Z_NULL)
sl@0	362	{
sl@0	363	return KErrNoMemory;
sl@0	364	}
sl@0	365
sl@0	366	ReadIntParam(MemLevel);
sl@0	367	stream.zalloc = (alloc_func)0;
sl@0	368	stream.zfree = (free_func)0;
sl@0	369	stream.opaque = (voidpf)0;
sl@0	370
sl@0	371
sl@0	372	err= deflateInit2_(&stream, level, 3, 15, MemLevel,
sl@0	373	0, zlibVersion(), sizeof(z_stream));
sl@0	374
sl@0	375	if (err == Z_STREAM_ERROR)
sl@0	376	{
sl@0	377	res = KErrNone;
sl@0	378	}
sl@0	379	else
sl@0	380	{
sl@0	381	res = KErrGeneral;
sl@0	382	}
sl@0	383
sl@0	384	//deflateEnd(&stream);
sl@0	385	free(compr);
sl@0	386	return res;
sl@0	387	}
sl@0	388
sl@0	389	/**
sl@0	390	* Function Name : TestDeflateInit2_Level
sl@0	391	* TestCase Description: 1. Level value less than 0
sl@0	392	* 2. Level value more than 9
sl@0	393	*/
sl@0	394	TInt CTestZlib::TestDeflateInit2_Level()
sl@0	395	{
sl@0	396	TInt res = KErrNone ;
sl@0	397	z_stream stream;
sl@0	398	int err;
sl@0	399	int level=0;
sl@0	400
sl@0	401	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	402	Byte *compr;
sl@0	403	uLong comprLen = 10*sizeof(int);
sl@0	404	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	405	if (compr == Z_NULL)
sl@0	406	{
sl@0	407	return KErrNoMemory;
sl@0	408	}
sl@0	409
sl@0	410	ReadIntParam(level);
sl@0	411	stream.zalloc = (alloc_func)0;
sl@0	412	stream.zfree = (free_func)0;
sl@0	413	stream.opaque = (voidpf)0;
sl@0	414
sl@0	415
sl@0	416	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	417	0, zlibVersion(), sizeof(z_stream));
sl@0	418
sl@0	419	if (err == Z_STREAM_ERROR)
sl@0	420	{
sl@0	421	res = KErrNone;
sl@0	422	}
sl@0	423	else
sl@0	424	{
sl@0	425	res = KErrGeneral;
sl@0	426	}
sl@0	427
sl@0	428	//deflateEnd(&stream);
sl@0	429	free(compr);
sl@0	430	return res;
sl@0	431	}
sl@0	432
sl@0	433	/**
sl@0	434	* Function Name : TestDeflateInit2_Strategy
sl@0	435	* TestCase Description: 1. Strategy value less than 0
sl@0	436	* 2. Strategy value more than Z_FIXED
sl@0	437	*/
sl@0	438	TInt CTestZlib::TestDeflateInit2_Strategy()
sl@0	439	{
sl@0	440	TInt res = KErrNone ;
sl@0	441	z_stream stream;
sl@0	442	int err;
sl@0	443	int level=Z_DEFAULT_COMPRESSION;
sl@0	444	int strategy=0;
sl@0	445
sl@0	446	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	447	Byte *compr;
sl@0	448	uLong comprLen = 10*sizeof(int);
sl@0	449	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	450	if (compr == Z_NULL)
sl@0	451	{
sl@0	452	return KErrNoMemory;
sl@0	453	}
sl@0	454
sl@0	455	ReadIntParam(strategy);
sl@0	456	stream.zalloc = (alloc_func)0;
sl@0	457	stream.zfree = (free_func)0;
sl@0	458	stream.opaque = (voidpf)0;
sl@0	459
sl@0	460
sl@0	461	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	462	strategy, zlibVersion(), sizeof(z_stream));
sl@0	463
sl@0	464	if (err == Z_STREAM_ERROR)
sl@0	465	{
sl@0	466	res = KErrNone;
sl@0	467	}
sl@0	468	else
sl@0	469	{
sl@0	470	res = KErrGeneral;
sl@0	471	}
sl@0	472
sl@0	473	free(compr);
sl@0	474	return res;
sl@0	475	}
sl@0	476
sl@0	477	/**
sl@0	478	* Function Name : TestDeflateInit2_Version
sl@0	479	* TestCase Description: Invalid version value
sl@0	480	* Return Value: returns Z_VERSION_ERROR
sl@0	481	*/
sl@0	482	TInt CTestZlib::TestDeflateInit2_Version()
sl@0	483	{
sl@0	484	TInt res = KErrNone ;
sl@0	485	z_stream stream;
sl@0	486	int err;
sl@0	487	int level=Z_DEFAULT_COMPRESSION;
sl@0	488	char version[5];
sl@0	489
sl@0	490	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	491	Byte *compr;
sl@0	492	uLong comprLen = 10*sizeof(int);
sl@0	493	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	494	if (compr == Z_NULL)
sl@0	495	{
sl@0	496	return KErrNoMemory;
sl@0	497	}
sl@0	498
sl@0	499	ReadStringParam(version);
sl@0	500	stream.zalloc = (alloc_func)0;
sl@0	501	stream.zfree = (free_func)0;
sl@0	502	stream.opaque = (voidpf)0;
sl@0	503
sl@0	504
sl@0	505	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	506	0, version, sizeof(z_stream));
sl@0	507
sl@0	508	if (err == Z_VERSION_ERROR)
sl@0	509	{
sl@0	510	res = KErrNone;
sl@0	511	}
sl@0	512	else
sl@0	513	{
sl@0	514	res = KErrGeneral;
sl@0	515	}
sl@0	516
sl@0	517	free(compr);
sl@0	518	return res;
sl@0	519	}
sl@0	520
sl@0	521	/**
sl@0	522	* Function Name : TestDeflateInit2_VersionNull
sl@0	523	* TestCase Description: version value is Z_NULL
sl@0	524	* Return Value: Z_VERSION_ERROR
sl@0	525	*/
sl@0	526	TInt CTestZlib::TestDeflateInit2_VersionNull()
sl@0	527	{
sl@0	528	TInt res = KErrNone ;
sl@0	529	z_stream stream;
sl@0	530	int err;
sl@0	531	int level=Z_DEFAULT_COMPRESSION;
sl@0	532
sl@0	533	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	534	Byte *compr;
sl@0	535	uLong comprLen = 10*sizeof(int);
sl@0	536	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	537	if (compr == Z_NULL)
sl@0	538	{
sl@0	539	return KErrNoMemory;
sl@0	540	}
sl@0	541
sl@0	542	stream.zalloc = (alloc_func)0;
sl@0	543	stream.zfree = (free_func)0;
sl@0	544	stream.opaque = (voidpf)0;
sl@0	545
sl@0	546
sl@0	547	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	548	0, Z_NULL, sizeof(z_stream));
sl@0	549
sl@0	550	if (err == Z_VERSION_ERROR)
sl@0	551	{
sl@0	552	res = KErrNone;
sl@0	553	}
sl@0	554	else
sl@0	555	{
sl@0	556	res = KErrGeneral;
sl@0	557	}
sl@0	558
sl@0	559	free(compr);
sl@0	560	return res;
sl@0	561	}
sl@0	562
sl@0	563
sl@0	564	/**
sl@0	565	* Function Name : TestDeflateInit2_StreamNull
sl@0	566	* TestCase Description: Pass Z_NULL stream
sl@0	567	*/
sl@0	568	TInt CTestZlib::TestDeflateInit2_StreamNull()
sl@0	569	{
sl@0	570	TInt res = KErrNone ;
sl@0	571	//z_stream stream;
sl@0	572	int err;
sl@0	573	int level=Z_DEFAULT_COMPRESSION;
sl@0	574
sl@0	575	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	576	Byte *compr;
sl@0	577	uLong comprLen = 10*sizeof(int);
sl@0	578	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	579	if (compr == Z_NULL)
sl@0	580	{
sl@0	581	return KErrNoMemory;
sl@0	582	}
sl@0	583
sl@0	584	//stream.zalloc = (alloc_func)0;
sl@0	585	//stream.zfree = (free_func)0;
sl@0	586	//stream.opaque = (voidpf)0;
sl@0	587
sl@0	588	err= deflateInit2_(Z_NULL, level, 8, 15, 8,
sl@0	589	0, zlibVersion(), sizeof(z_stream));
sl@0	590
sl@0	591	if (err == Z_STREAM_ERROR)
sl@0	592	{
sl@0	593	res = KErrNone;
sl@0	594	}
sl@0	595	else
sl@0	596	{
sl@0	597	res = KErrGeneral;
sl@0	598	}
sl@0	599
sl@0	600	free(compr);
sl@0	601	return res;
sl@0	602	}
sl@0	603
sl@0	604	/**
sl@0	605	* Function Name : TestInflateInit2_Version
sl@0	606	* TestCase Description: Invalid version value
sl@0	607	* Return Value: returns Z_VERSION_ERROR
sl@0	608	*/
sl@0	609	TInt CTestZlib::TestInflateInit2_Version()
sl@0	610	{
sl@0	611	TInt res = KErrNone ;
sl@0	612
sl@0	613	z_stream d_stream; // decompression stream
sl@0	614	char version[5];
sl@0	615	d_stream.zalloc = (alloc_func)0;
sl@0	616	d_stream.zfree = (free_func)0;
sl@0	617	d_stream.opaque = (voidpf)0;
sl@0	618
sl@0	619	Byte compr, uncompr;
sl@0	620	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	621	uLong uncomprLen = comprLen;
sl@0	622	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	623	if (compr == Z_NULL)
sl@0	624	{
sl@0	625	return KErrNoMemory;
sl@0	626	}
sl@0	627	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	628	if (uncompr == Z_NULL)
sl@0	629	{
sl@0	630	free(compr);
sl@0	631	return KErrNoMemory;
sl@0	632	}
sl@0	633	res = Test_deflate(compr, comprLen);
sl@0	634	if(res<0)
sl@0	635	{
sl@0	636	free(compr);
sl@0	637	free(uncompr);
sl@0	638	return KErrNoMemory;
sl@0	639	}
sl@0	640	d_stream.next_in = compr;
sl@0	641	d_stream.avail_in = 0;
sl@0	642	d_stream.next_out = uncompr;
sl@0	643
sl@0	644	//Reading invalid version from ini file
sl@0	645	ReadStringParam(version);
sl@0	646
sl@0	647	int ret = inflateInit2_(&d_stream, 15, version, sizeof(d_stream));
sl@0	648	if(ret == Z_VERSION_ERROR)
sl@0	649	{
sl@0	650	res = KErrNone;
sl@0	651	}
sl@0	652	else
sl@0	653	{
sl@0	654	res = KErrGeneral;
sl@0	655	}
sl@0	656	free(compr);
sl@0	657	free(uncompr);
sl@0	658	return res;
sl@0	659	}
sl@0	660
sl@0	661	/**
sl@0	662	* Function Name : TestInflateInit2_VersionNull
sl@0	663	* TestCase Description: version value is Z_NULL
sl@0	664	* Return Value: Z_VERSION_ERROR
sl@0	665	*/
sl@0	666	TInt CTestZlib::TestInflateInit2_VersionNull()
sl@0	667	{
sl@0	668	TInt res = KErrNone ;
sl@0	669
sl@0	670	z_stream d_stream; // decompression stream
sl@0	671	d_stream.zalloc = (alloc_func)0;
sl@0	672	d_stream.zfree = (free_func)0;
sl@0	673	d_stream.opaque = (voidpf)0;
sl@0	674
sl@0	675	Byte compr, uncompr;
sl@0	676	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	677	uLong uncomprLen = comprLen;
sl@0	678	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	679	if (compr == Z_NULL)
sl@0	680	{
sl@0	681	return KErrNoMemory;
sl@0	682	}
sl@0	683	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	684	if (uncompr == Z_NULL)
sl@0	685	{
sl@0	686	free(compr);
sl@0	687	return KErrNoMemory;
sl@0	688	}
sl@0	689	res = Test_deflate(compr, comprLen);
sl@0	690	if(res<0)
sl@0	691	{
sl@0	692	free(compr);
sl@0	693	free(uncompr);
sl@0	694	return KErrNoMemory;
sl@0	695	}
sl@0	696	d_stream.next_in = compr;
sl@0	697	d_stream.avail_in = 0;
sl@0	698	d_stream.next_out = uncompr;
sl@0	699
sl@0	700	int ret = inflateInit2_(&d_stream, 15, Z_NULL, sizeof(d_stream));
sl@0	701	if(ret == Z_VERSION_ERROR)
sl@0	702	{
sl@0	703	res = KErrNone;
sl@0	704	}
sl@0	705	else
sl@0	706	{
sl@0	707	res = KErrGeneral;
sl@0	708	}
sl@0	709	free(compr);
sl@0	710	free(uncompr);
sl@0	711	return res;
sl@0	712	}
sl@0	713
sl@0	714	/**
sl@0	715	* Function Name : TestInflateInit2_WindowBits
sl@0	716	* TestCase Description: Window bits more than 48 to increase the conditional coverage
sl@0	717	* Return Value: returns Z_STREAM_ERROR
sl@0	718	*/
sl@0	719	TInt CTestZlib::TestInflateInit2_WindowBits()
sl@0	720	{
sl@0	721	TInt res = KErrNone ;
sl@0	722
sl@0	723	z_stream d_stream; // decompression stream
sl@0	724	int WindowBits = 0;
sl@0	725	d_stream.zalloc = (alloc_func)0;
sl@0	726	d_stream.zfree = (free_func)0;
sl@0	727	d_stream.opaque = (voidpf)0;
sl@0	728
sl@0	729	Byte compr, uncompr;
sl@0	730	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	731	uLong uncomprLen = comprLen;
sl@0	732	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	733	if (compr == Z_NULL)
sl@0	734	{
sl@0	735	return KErrNoMemory;
sl@0	736	}
sl@0	737	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	738	if (uncompr == Z_NULL)
sl@0	739	{
sl@0	740	free(compr);
sl@0	741	return KErrNoMemory;
sl@0	742	}
sl@0	743	res = Test_deflate(compr, comprLen);
sl@0	744	if(res<0)
sl@0	745	{
sl@0	746	free(compr);
sl@0	747	free(uncompr);
sl@0	748	return KErrNoMemory;
sl@0	749	}
sl@0	750	d_stream.next_in = compr;
sl@0	751	d_stream.avail_in = 0;
sl@0	752	d_stream.next_out = uncompr;
sl@0	753
sl@0	754	//Reading window bits from ini file
sl@0	755	ReadIntParam(WindowBits);
sl@0	756
sl@0	757	int ret = inflateInit2_(&d_stream, WindowBits, "1.2.4", sizeof(d_stream));
sl@0	758	if(ret == Z_STREAM_ERROR)
sl@0	759	{
sl@0	760	res = KErrNone;
sl@0	761	}
sl@0	762	else
sl@0	763	{
sl@0	764	res = KErrGeneral;
sl@0	765	}
sl@0	766	free(compr);
sl@0	767	free(uncompr);
sl@0	768	return res;
sl@0	769	}
sl@0	770
sl@0	771	/**
sl@0	772	* Function Name : TestInflateInit2_StreamNull
sl@0	773	* TestCase Description: Stream NULL
sl@0	774	* Return Value: returns Z_STREAM_ERROR
sl@0	775	*/
sl@0	776	TInt CTestZlib::TestInflateInit2_StreamNull()
sl@0	777	{
sl@0	778	TInt res = KErrNone ;
sl@0	779
sl@0	780	z_stream d_stream; // decompression stream
sl@0	781	//d_stream.zalloc = (alloc_func)0;
sl@0	782	//d_stream.zfree = (free_func)0;
sl@0	783	//d_stream.opaque = (voidpf)0;
sl@0	784
sl@0	785	Byte compr, uncompr;
sl@0	786	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	787	uLong uncomprLen = comprLen;
sl@0	788	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	789	if (compr == Z_NULL)
sl@0	790	{
sl@0	791	return KErrNoMemory;
sl@0	792	}
sl@0	793	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	794	if (uncompr == Z_NULL)
sl@0	795	{
sl@0	796	free(compr);
sl@0	797	return KErrNoMemory;
sl@0	798	}
sl@0	799	res = Test_deflate(compr, comprLen);
sl@0	800	if(res<0)
sl@0	801	{
sl@0	802	free(compr);
sl@0	803	free(uncompr);
sl@0	804	return KErrNoMemory;
sl@0	805	}
sl@0	806	//d_stream.next_in = compr;
sl@0	807	//d_stream.avail_in = 0;
sl@0	808	//d_stream.next_out = uncompr;
sl@0	809
sl@0	810	int ret = inflateInit2_(Z_NULL, 15, "1.2.4", sizeof(d_stream));
sl@0	811	if(ret == Z_STREAM_ERROR)
sl@0	812	{
sl@0	813	res = KErrNone;
sl@0	814	}
sl@0	815	else
sl@0	816	{
sl@0	817	res = KErrGeneral;
sl@0	818	}
sl@0	819	free(compr);
sl@0	820	free(uncompr);
sl@0	821	return res;
sl@0	822	}
sl@0	823
sl@0	824	/**
sl@0	825	* Function Name : TestDeflate_HuffmanStrategy
sl@0	826	* TestCase Description: Strategy is HUFFMAN
sl@0	827	* Return Value: Z_OK
sl@0	828	*/
sl@0	829	TInt CTestZlib::TestDeflate_HuffmanStrategy()
sl@0	830	{
sl@0	831	TInt res = KErrNone ;
sl@0	832	z_stream stream;
sl@0	833	int err;
sl@0	834	int level=Z_DEFAULT_COMPRESSION;
sl@0	835
sl@0	836	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	837	Byte *compr;
sl@0	838	uLong comprLen = 20*sizeof(int);
sl@0	839	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	840	if (compr == Z_NULL)
sl@0	841	{
sl@0	842	return KErrNoMemory;
sl@0	843	}
sl@0	844
sl@0	845	stream.zalloc = (alloc_func)0;
sl@0	846	stream.zfree = (free_func)0;
sl@0	847	stream.opaque = (voidpf)0;
sl@0	848
sl@0	849
sl@0	850	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	851	2, zlibVersion(), sizeof(z_stream));
sl@0	852
sl@0	853	if (err == Z_OK)
sl@0	854	{
sl@0	855	res = KErrNone;
sl@0	856	}
sl@0	857	else
sl@0	858	{
sl@0	859	res = KErrGeneral;
sl@0	860	}
sl@0	861
sl@0	862	stream.next_in = (Bytef*)hello;
sl@0	863	stream.next_out = compr;
sl@0	864
sl@0	865	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	866	{
sl@0	867	stream.avail_in = stream.avail_out = 1; /* force small buffers */
sl@0	868	err = deflate(&stream, Z_NO_FLUSH);
sl@0	869	}
sl@0	870	/* Finish the stream, still forcing small buffers: */
sl@0	871	for (;;)
sl@0	872	{
sl@0	873	stream.avail_out = 1;
sl@0	874	err = deflate(&stream, Z_FINISH);
sl@0	875	if (err == Z_STREAM_END) break;
sl@0	876	if(err!=Z_OK)
sl@0	877	{
sl@0	878	res = KErrGeneral;
sl@0	879	}
sl@0	880	}
sl@0	881
sl@0	882	err = deflateEnd(&stream);
sl@0	883	if(err!=Z_OK)
sl@0	884	{
sl@0	885	res = KErrGeneral;
sl@0	886	}
sl@0	887
sl@0	888	free(compr);
sl@0	889	return res;
sl@0	890	}
sl@0	891
sl@0	892	/**
sl@0	893	* Function Name : TestDeflate_AvailInZero
sl@0	894	* TestCase Description: avail_in value is set to 0
sl@0	895	* Return Value: Z_STREAM_ERROR
sl@0	896	*/
sl@0	897	TInt CTestZlib::TestDeflate_AvailInZero()
sl@0	898	{
sl@0	899	TInt res = KErrNone ;
sl@0	900	z_stream stream;
sl@0	901	int err;
sl@0	902	int level=Z_DEFAULT_COMPRESSION;
sl@0	903
sl@0	904	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	905	Byte *compr;
sl@0	906	uLong comprLen = 20*sizeof(int);
sl@0	907	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	908	if (compr == Z_NULL)
sl@0	909	{
sl@0	910	return KErrNoMemory;
sl@0	911	}
sl@0	912
sl@0	913	stream.zalloc = (alloc_func)0;
sl@0	914	stream.zfree = (free_func)0;
sl@0	915	stream.opaque = (voidpf)0;
sl@0	916
sl@0	917
sl@0	918	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	919	0, zlibVersion(), sizeof(z_stream));
sl@0	920
sl@0	921	if (err == Z_OK)
sl@0	922	{
sl@0	923	res = KErrNone;
sl@0	924	}
sl@0	925	else
sl@0	926	{
sl@0	927	res = KErrGeneral;
sl@0	928	}
sl@0	929
sl@0	930	stream.next_in = Z_NULL;
sl@0	931	stream.next_out = Z_NULL;
sl@0	932
sl@0	933	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	934	{
sl@0	935	stream.avail_in = 0; // Setting avail_in to zero
sl@0	936	stream.avail_out = 1; // force small buffers
sl@0	937	err = deflate(&stream, Z_NO_FLUSH);
sl@0	938	if (err != Z_OK)
sl@0	939	break;
sl@0	940	}
sl@0	941
sl@0	942	if (err == Z_STREAM_ERROR)
sl@0	943	{
sl@0	944	res = KErrNone;
sl@0	945	deflateEnd(&stream);
sl@0	946	free(compr);
sl@0	947	return res;
sl@0	948	}
sl@0	949	else
sl@0	950	{
sl@0	951	res = KErrGeneral;
sl@0	952	free(compr);
sl@0	953	}
sl@0	954
sl@0	955	return res;
sl@0	956	}
sl@0	957
sl@0	958	/**
sl@0	959	* Function Name : TestGzsetparamDefaultCompression
sl@0	960	* TestCase Description: This test case is intended to cover the condition in
sl@0	961	* deflateParams_r. Z_DEFAULT_COMPRESSION and strategy>4 is passed
sl@0	962	* Return Value: Z_STREAM_ERROR
sl@0	963	*/
sl@0	964	TInt CTestZlib::TestGzsetparamDefaultCompression()
sl@0	965	{
sl@0	966	TInt res = KErrNone ;
sl@0	967
sl@0	968	int len = (int)strlen(hello)+1;
sl@0	969	gzFile file;
sl@0	970
sl@0	971	const char * fname = TESTFILE;
sl@0	972
sl@0	973	file = gzopen(fname, "wb");
sl@0	974	gzputc(file, 'h');
sl@0	975
sl@0	976	int u = gzsetparams(file, Z_DEFAULT_COMPRESSION, 8);
sl@0	977	if(u == Z_STREAM_ERROR)
sl@0	978	{
sl@0	979	res=KErrNone;
sl@0	980	}
sl@0	981	int err= gzclose(file);
sl@0	982	if (err != Z_OK)
sl@0	983	{
sl@0	984	res = KErrGeneral;
sl@0	985	}
sl@0	986
sl@0	987	return res;
sl@0	988	}
sl@0	989
sl@0	990	/**
sl@0	991	* Function Name : TestDeflateResetNullStream
sl@0	992	* TestCase Description: Pass NULL stream
sl@0	993	* Return Value: Z_STREAM_ERROR
sl@0	994	*/
sl@0	995	TInt CTestZlib::TestDeflateResetNullStream()
sl@0	996	{
sl@0	997	INFO_PRINTF1(_L("DeflateReset test with NULL input"));
sl@0	998	TInt res = KErrNone ;
sl@0	999	int level = Z_DEFAULT_COMPRESSION ;
sl@0	1000	uLong len = (uLong)strlen(hello)+1;
sl@0	1001	Byte compr, uncompr;
sl@0	1002	uLong comprLen = 20*sizeof(int);
sl@0	1003	uLong uncomprLen = comprLen;
sl@0	1004	int err;
sl@0	1005	z_stream stream;
sl@0	1006	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1007	if (compr == Z_NULL)
sl@0	1008	{
sl@0	1009	return KErrNoMemory;
sl@0	1010	}
sl@0	1011	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1012	if (uncompr == Z_NULL)
sl@0	1013	{
sl@0	1014	free(compr);
sl@0	1015	return KErrNoMemory;
sl@0	1016	}
sl@0	1017
sl@0	1018	stream.zalloc = (alloc_func)0;
sl@0	1019	stream.zfree = (free_func)0;
sl@0	1020	stream.opaque = (voidpf)0;
sl@0	1021
sl@0	1022	err = deflateInit(&stream, level);
sl@0	1023	if (err != Z_OK)
sl@0	1024	{
sl@0	1025	free(compr);
sl@0	1026	free(uncompr);
sl@0	1027	return err;
sl@0	1028	}
sl@0	1029
sl@0	1030	Bytef *dest = compr ;
sl@0	1031	uLongf *destLen = &comprLen;
sl@0	1032	const Bytef source = (const Bytef)hello;
sl@0	1033	uLong sourceLen = len;
sl@0	1034
sl@0	1035	stream.next_in = (Bytef*)source;
sl@0	1036	stream.avail_in = (uInt)sourceLen;
sl@0	1037
sl@0	1038	#ifdef MAXSEG_64K
sl@0	1039	/* Check for source > 64K on 16-bit machine: */
sl@0	1040	if ((uLong)stream.avail_in != sourceLen)
sl@0	1041	{
sl@0	1042	res = KErrGeneral;
sl@0	1043	}
sl@0	1044	#endif
sl@0	1045
sl@0	1046	stream.next_out = dest;
sl@0	1047	stream.avail_out = (uInt)*destLen;
sl@0	1048
sl@0	1049	if ((uLong)stream.avail_out != *destLen)
sl@0	1050	{
sl@0	1051	res = KErrGeneral;
sl@0	1052	}
sl@0	1053
sl@0	1054	err=deflateReset(Z_NULL/&stream/);
sl@0	1055	if (err == Z_STREAM_ERROR)
sl@0	1056	{
sl@0	1057	res = KErrNone;
sl@0	1058	}
sl@0	1059	else
sl@0	1060	{
sl@0	1061	res = KErrGeneral;
sl@0	1062	}
sl@0	1063	deflateEnd(&stream);
sl@0	1064	free(compr);
sl@0	1065	free(uncompr);
sl@0	1066	return res;
sl@0	1067	}
sl@0	1068
sl@0	1069	/**
sl@0	1070	* Function Name : TestDeflateResetStreamStateNull
sl@0	1071	* TestCase Description: Pass NULL stream state
sl@0	1072	* Return Value: Z_STREAM_ERROR
sl@0	1073	*/
sl@0	1074	TInt CTestZlib::TestDeflateResetStreamStateNull()
sl@0	1075	{
sl@0	1076	TInt res = KErrNone ;
sl@0	1077	int level = Z_DEFAULT_COMPRESSION ;
sl@0	1078	uLong len = (uLong)strlen(hello)+1;
sl@0	1079	Byte compr, uncompr;
sl@0	1080	uLong comprLen = 20*sizeof(int);
sl@0	1081	uLong uncomprLen = comprLen;
sl@0	1082	int err;
sl@0	1083	z_stream stream;
sl@0	1084	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1085	if (compr == Z_NULL)
sl@0	1086	{
sl@0	1087	return KErrNoMemory;
sl@0	1088	}
sl@0	1089	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1090	if (uncompr == Z_NULL)
sl@0	1091	{
sl@0	1092	free(compr);
sl@0	1093	return KErrNoMemory;
sl@0	1094	}
sl@0	1095
sl@0	1096	stream.zalloc = (alloc_func)0;
sl@0	1097	stream.zfree = (free_func)0;
sl@0	1098	stream.opaque = (voidpf)0;
sl@0	1099
sl@0	1100	err = deflateInit(&stream, level);
sl@0	1101	if (err != Z_OK)
sl@0	1102	{
sl@0	1103	free(compr);
sl@0	1104	free(uncompr);
sl@0	1105	return err;
sl@0	1106	}
sl@0	1107
sl@0	1108	Bytef *dest = compr ;
sl@0	1109	uLongf *destLen = &comprLen;
sl@0	1110	const Bytef source = (const Bytef)hello;
sl@0	1111	uLong sourceLen = len;
sl@0	1112
sl@0	1113	stream.next_in = (Bytef*)source;
sl@0	1114	stream.avail_in = (uInt)sourceLen;
sl@0	1115
sl@0	1116	#ifdef MAXSEG_64K
sl@0	1117	/* Check for source > 64K on 16-bit machine: */
sl@0	1118	if ((uLong)stream.avail_in != sourceLen)
sl@0	1119	{
sl@0	1120	res = KErrGeneral;
sl@0	1121	}
sl@0	1122	#endif
sl@0	1123
sl@0	1124	stream.next_out = dest;
sl@0	1125	stream.avail_out = (uInt)*destLen;
sl@0	1126
sl@0	1127	if ((uLong)stream.avail_out != *destLen)
sl@0	1128	{
sl@0	1129	res = KErrGeneral;
sl@0	1130	}
sl@0	1131
sl@0	1132	err=deflateReset(&stream);
sl@0	1133	deflateEnd(&stream);
sl@0	1134
sl@0	1135	//equate stream state to Z_NULL for coverage improvement
sl@0	1136	stream.state = Z_NULL;
sl@0	1137	err=deflateReset(&stream);
sl@0	1138
sl@0	1139	if (err == Z_STREAM_ERROR)
sl@0	1140	{
sl@0	1141	res = KErrNone;
sl@0	1142	}
sl@0	1143	else
sl@0	1144	{
sl@0	1145	res = KErrGeneral;
sl@0	1146	}
sl@0	1147	free(compr);
sl@0	1148	free(uncompr);
sl@0	1149	return res;
sl@0	1150	}
sl@0	1151
sl@0	1152	/**
sl@0	1153	* Function Name : TestDeflate_Scenarios
sl@0	1154	* TestCase Description: 1. Compression level is Z_DEFAULT_COMPRESSION, strategy is Z_RLE
sl@0	1155	* 2. Compression level is Z_BEST_SPEED, strategy is Z_HUFFMAN_ONLY
sl@0	1156	* 3. Compression level is Z_BEST_COMPRESSION, strategy is Z_FILTERED
sl@0	1157	* 4. Compression level is Z_BEST_COMPRESSION, strategy is Z_HUFFMAN_ONLY
sl@0	1158	* 5. Compression level is Z_BEST_COMPRESSION, strategy is Z_FIXED
sl@0	1159	* Return Value: Z_OK
sl@0	1160	*/
sl@0	1161	TInt CTestZlib::TestDeflate_Scenarios()
sl@0	1162	{
sl@0	1163	TInt res = KErrNone ;
sl@0	1164	z_stream stream;
sl@0	1165	int err;
sl@0	1166	int level=0;
sl@0	1167	int strategy=0;
sl@0	1168
sl@0	1169	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1170	Byte *compr;
sl@0	1171	uLong comprLen = 20*sizeof(int);
sl@0	1172	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1173	if (compr == Z_NULL)
sl@0	1174	{
sl@0	1175	return KErrNoMemory;
sl@0	1176	}
sl@0	1177
sl@0	1178	stream.zalloc = (alloc_func)0;
sl@0	1179	stream.zfree = (free_func)0;
sl@0	1180	stream.opaque = (voidpf)0;
sl@0	1181
sl@0	1182	ReadIntParam(level);
sl@0	1183	ReadIntParam(strategy);
sl@0	1184	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	1185	strategy, zlibVersion(), sizeof(z_stream));
sl@0	1186
sl@0	1187	if (err == Z_OK)
sl@0	1188	{
sl@0	1189	res = KErrNone;
sl@0	1190	}
sl@0	1191	else
sl@0	1192	{
sl@0	1193	res = KErrGeneral;
sl@0	1194	}
sl@0	1195
sl@0	1196	stream.next_in = (Bytef*)hello;
sl@0	1197	stream.next_out = compr;
sl@0	1198
sl@0	1199	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1200	{
sl@0	1201	stream.avail_in = stream.avail_out = 1; /* force small buffers */
sl@0	1202	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1203	}
sl@0	1204	/* Finish the stream, still forcing small buffers: */
sl@0	1205	for (;;)
sl@0	1206	{
sl@0	1207	stream.avail_out = 1;
sl@0	1208	err = deflate(&stream, Z_FINISH);
sl@0	1209	if (err == Z_STREAM_END) break;
sl@0	1210	if(err!=Z_OK)
sl@0	1211	{
sl@0	1212	res = KErrGeneral;
sl@0	1213	}
sl@0	1214	}
sl@0	1215
sl@0	1216	err = deflateEnd(&stream);
sl@0	1217	if(err!=Z_OK)
sl@0	1218	{
sl@0	1219	res = KErrGeneral;
sl@0	1220	}
sl@0	1221
sl@0	1222	free(compr);
sl@0	1223	return res;
sl@0	1224	}
sl@0	1225
sl@0	1226	/**
sl@0	1227	* Function Name : TestDeflate_NullStream
sl@0	1228	* TestCase Description: NULL stream is passed for deflate
sl@0	1229	* Return Value: Z_STREAM_ERROR
sl@0	1230	*/
sl@0	1231	TInt CTestZlib::TestDeflate_NullStream()
sl@0	1232	{
sl@0	1233	TInt res = KErrNone ;
sl@0	1234	z_stream stream;
sl@0	1235	int err;
sl@0	1236	int level=Z_DEFAULT_COMPRESSION;
sl@0	1237
sl@0	1238	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1239	Byte *compr;
sl@0	1240	uLong comprLen = 20*sizeof(int);
sl@0	1241	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1242	if (compr == Z_NULL)
sl@0	1243	{
sl@0	1244	return KErrNoMemory;
sl@0	1245	}
sl@0	1246
sl@0	1247	stream.zalloc = (alloc_func)0;
sl@0	1248	stream.zfree = (free_func)0;
sl@0	1249	stream.opaque = (voidpf)0;
sl@0	1250
sl@0	1251
sl@0	1252	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	1253	0, zlibVersion(), sizeof(z_stream));
sl@0	1254
sl@0	1255	if (err == Z_OK)
sl@0	1256	{
sl@0	1257	res = KErrNone;
sl@0	1258	}
sl@0	1259	else
sl@0	1260	{
sl@0	1261	res = KErrGeneral;
sl@0	1262	}
sl@0	1263
sl@0	1264	stream.next_in = (Bytef*)hello;
sl@0	1265	stream.next_out = compr;
sl@0	1266
sl@0	1267	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1268	{
sl@0	1269	stream.avail_in = stream.avail_out = 1; // force small buffers
sl@0	1270	err = deflate(Z_NULL, Z_NO_FLUSH);
sl@0	1271	if (err != Z_OK)
sl@0	1272	break;
sl@0	1273	}
sl@0	1274
sl@0	1275	if (err == Z_STREAM_ERROR)
sl@0	1276	{
sl@0	1277	res = KErrNone;
sl@0	1278	deflateEnd(&stream);
sl@0	1279	free(compr);
sl@0	1280	return res;
sl@0	1281	}
sl@0	1282	else
sl@0	1283	{
sl@0	1284	res = KErrGeneral;
sl@0	1285	}
sl@0	1286
sl@0	1287	return res;
sl@0	1288	}
sl@0	1289
sl@0	1290	/**
sl@0	1291	* Function Name : TestDeflate_StreamStateNull
sl@0	1292	* TestCase Description: stream state is made Z_NULL before calling deflate
sl@0	1293	* Return Value: Z_STREAM_ERROR
sl@0	1294	*/
sl@0	1295	TInt CTestZlib::TestDeflate_StreamStateNull()
sl@0	1296	{
sl@0	1297	TInt res = KErrNone ;
sl@0	1298	z_stream stream;
sl@0	1299	int err;
sl@0	1300	int level=Z_DEFAULT_COMPRESSION;
sl@0	1301
sl@0	1302	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1303	Byte *compr;
sl@0	1304	uLong comprLen = 20*sizeof(int);
sl@0	1305	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1306	if (compr == Z_NULL)
sl@0	1307	{
sl@0	1308	return KErrNoMemory;
sl@0	1309	}
sl@0	1310
sl@0	1311	stream.zalloc = (alloc_func)0;
sl@0	1312	stream.zfree = (free_func)0;
sl@0	1313	stream.opaque = (voidpf)0;
sl@0	1314
sl@0	1315	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	1316	0, zlibVersion(), sizeof(z_stream));
sl@0	1317
sl@0	1318	if (err == Z_OK)
sl@0	1319	{
sl@0	1320	res = KErrNone;
sl@0	1321	}
sl@0	1322	else
sl@0	1323	{
sl@0	1324	res = KErrGeneral;
sl@0	1325	}
sl@0	1326
sl@0	1327	stream.next_in = (Bytef*)hello;
sl@0	1328	stream.next_out = compr;
sl@0	1329
sl@0	1330	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1331	{
sl@0	1332	stream.avail_in = stream.avail_out = 1; // force small buffers
sl@0	1333	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1334	}
sl@0	1335	deflateEnd(&stream);
sl@0	1336
sl@0	1337	//equate stream state to Z_NULL for voverage improvement
sl@0	1338	stream.state = Z_NULL;
sl@0	1339	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1340
sl@0	1341	if (err == Z_STREAM_ERROR)
sl@0	1342	{
sl@0	1343	res = KErrNone;
sl@0	1344	}
sl@0	1345	else
sl@0	1346	{
sl@0	1347	res = KErrGeneral;
sl@0	1348	}
sl@0	1349	free(compr);
sl@0	1350	return res;
sl@0	1351	}
sl@0	1352
sl@0	1353	/**
sl@0	1354	* Function Name : TestDeflateEndNull
sl@0	1355	* TestCase Description: Pass Z_NULL to deflateEnd
sl@0	1356	* Return Value: Z_STREAM_ERROR
sl@0	1357	*/
sl@0	1358	TInt CTestZlib::TestDeflateEndNull()
sl@0	1359	{
sl@0	1360	TInt res = KErrNone ;
sl@0	1361	z_stream stream;
sl@0	1362	int err;
sl@0	1363	int level=Z_DEFAULT_COMPRESSION;
sl@0	1364	int strategy=Z_DEFAULT_STRATEGY;
sl@0	1365
sl@0	1366	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1367	Byte *compr;
sl@0	1368	uLong comprLen = 20*sizeof(int);
sl@0	1369	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1370	if (compr == Z_NULL)
sl@0	1371	{
sl@0	1372	return KErrNoMemory;
sl@0	1373	}
sl@0	1374
sl@0	1375	stream.zalloc = (alloc_func)0;
sl@0	1376	stream.zfree = (free_func)0;
sl@0	1377	stream.opaque = (voidpf)0;
sl@0	1378
sl@0	1379	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	1380	strategy, zlibVersion(), sizeof(z_stream));
sl@0	1381
sl@0	1382	if (err == Z_OK)
sl@0	1383	{
sl@0	1384	res = KErrNone;
sl@0	1385	}
sl@0	1386	else
sl@0	1387	{
sl@0	1388	res = KErrGeneral;
sl@0	1389	}
sl@0	1390
sl@0	1391	stream.next_in = (Bytef*)hello;
sl@0	1392	stream.next_out = compr;
sl@0	1393
sl@0	1394	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1395	{
sl@0	1396	stream.avail_in = stream.avail_out = 1; /* force small buffers */
sl@0	1397	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1398	}
sl@0	1399	/* Finish the stream, still forcing small buffers: */
sl@0	1400	for (;;)
sl@0	1401	{
sl@0	1402	stream.avail_out = 1;
sl@0	1403	err = deflate(&stream, Z_FINISH);
sl@0	1404	if (err == Z_STREAM_END) break;
sl@0	1405	if(err!=Z_OK)
sl@0	1406	{
sl@0	1407	res = KErrGeneral;
sl@0	1408	}
sl@0	1409	}
sl@0	1410
sl@0	1411	// Pass Z_NULL
sl@0	1412	err = deflateEnd(&stream);
sl@0	1413	err = deflateEnd(Z_NULL); // for coverage improvement
sl@0	1414	if(err == Z_STREAM_ERROR)
sl@0	1415	{
sl@0	1416	res = KErrNone;
sl@0	1417	}
sl@0	1418	else
sl@0	1419	{
sl@0	1420	res = KErrGeneral;
sl@0	1421	}
sl@0	1422
sl@0	1423	free(compr);
sl@0	1424	return res;
sl@0	1425	}
sl@0	1426
sl@0	1427	/**
sl@0	1428	* Function Name : TestDeflateEndStreamStateNull
sl@0	1429	* TestCase Description: Make stream.state = Z_NULL
sl@0	1430	* Return Value: Z_STREAM_ERROR
sl@0	1431	*/
sl@0	1432	TInt CTestZlib::TestDeflateEndStreamStateNull()
sl@0	1433	{
sl@0	1434	TInt res = KErrNone ;
sl@0	1435	z_stream stream;
sl@0	1436	int err;
sl@0	1437	int level=Z_DEFAULT_COMPRESSION;
sl@0	1438	int strategy=Z_DEFAULT_STRATEGY;
sl@0	1439
sl@0	1440	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1441	Byte *compr;
sl@0	1442	uLong comprLen = 20*sizeof(int);
sl@0	1443	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1444	if (compr == Z_NULL)
sl@0	1445	{
sl@0	1446	return KErrNoMemory;
sl@0	1447	}
sl@0	1448
sl@0	1449	stream.zalloc = (alloc_func)0;
sl@0	1450	stream.zfree = (free_func)0;
sl@0	1451	stream.opaque = (voidpf)0;
sl@0	1452
sl@0	1453	err= deflateInit2_(&stream, level, 8, 15, 8,
sl@0	1454	strategy, zlibVersion(), sizeof(z_stream));
sl@0	1455
sl@0	1456	if (err == Z_OK)
sl@0	1457	{
sl@0	1458	res = KErrNone;
sl@0	1459	}
sl@0	1460	else
sl@0	1461	{
sl@0	1462	res = KErrGeneral;
sl@0	1463	}
sl@0	1464
sl@0	1465	stream.next_in = (Bytef*)hello;
sl@0	1466	stream.next_out = compr;
sl@0	1467
sl@0	1468	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1469	{
sl@0	1470	stream.avail_in = stream.avail_out = 1; /* force small buffers */
sl@0	1471	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1472	}
sl@0	1473	/* Finish the stream, still forcing small buffers: */
sl@0	1474	for (;;)
sl@0	1475	{
sl@0	1476	stream.avail_out = 1;
sl@0	1477	err = deflate(&stream, Z_FINISH);
sl@0	1478	if (err == Z_STREAM_END) break;
sl@0	1479	if(err!=Z_OK)
sl@0	1480	{
sl@0	1481	res = KErrGeneral;
sl@0	1482	}
sl@0	1483	}
sl@0	1484	err = deflateEnd(&stream);
sl@0	1485
sl@0	1486	// Make state Z_NULL
sl@0	1487	stream.state = Z_NULL;
sl@0	1488	err = deflateEnd(&stream);
sl@0	1489
sl@0	1490	if(err == Z_STREAM_ERROR)
sl@0	1491	{
sl@0	1492	res = KErrNone;
sl@0	1493	}
sl@0	1494	else
sl@0	1495	{
sl@0	1496	res = KErrGeneral;
sl@0	1497	}
sl@0	1498
sl@0	1499	free(compr);
sl@0	1500	return res;
sl@0	1501	}
sl@0	1502
sl@0	1503	/**
sl@0	1504	* Function Name : TestDeflate_WindowBits
sl@0	1505	* TestCase Description: Window bits more than 15 is supplied for deflate init
sl@0	1506	* Return Value: Z_OK
sl@0	1507	*/
sl@0	1508	TInt CTestZlib::TestDeflate_WindowBits()
sl@0	1509	{
sl@0	1510	TInt res = KErrNone ;
sl@0	1511	z_stream stream;
sl@0	1512	int err;
sl@0	1513	int level=Z_BEST_COMPRESSION;
sl@0	1514
sl@0	1515	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1516	Byte *compr;
sl@0	1517	uLong comprLen = 20*sizeof(int);
sl@0	1518	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1519	if (compr == Z_NULL)
sl@0	1520	{
sl@0	1521	return KErrNoMemory;
sl@0	1522	}
sl@0	1523
sl@0	1524	stream.zalloc = (alloc_func)0;
sl@0	1525	stream.zfree = (free_func)0;
sl@0	1526	stream.opaque = (voidpf)0;
sl@0	1527
sl@0	1528
sl@0	1529	err= deflateInit2_(&stream, level, 8, 25, 8,
sl@0	1530	0, zlibVersion(), sizeof(z_stream));
sl@0	1531
sl@0	1532	if (err == Z_OK)
sl@0	1533	{
sl@0	1534	res = KErrNone;
sl@0	1535	}
sl@0	1536	else
sl@0	1537	{
sl@0	1538	res = KErrGeneral;
sl@0	1539	}
sl@0	1540
sl@0	1541	stream.next_in = (Bytef*)hello;
sl@0	1542	stream.next_out = compr;
sl@0	1543
sl@0	1544	while (stream.total_in != sourceLen && stream.total_out < comprLen)
sl@0	1545	{
sl@0	1546	stream.avail_in = stream.avail_out = 1; /* force small buffers */
sl@0	1547	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1548	}
sl@0	1549	/* Finish the stream, still forcing small buffers: */
sl@0	1550	for (;;)
sl@0	1551	{
sl@0	1552	stream.avail_out = 1;
sl@0	1553	err = deflate(&stream, Z_FINISH);
sl@0	1554	if (err == Z_STREAM_END) break;
sl@0	1555	if(err!=Z_OK)
sl@0	1556	{
sl@0	1557	res = KErrGeneral;
sl@0	1558	}
sl@0	1559	}
sl@0	1560
sl@0	1561	err = deflateEnd(&stream);
sl@0	1562	if(err!=Z_OK)
sl@0	1563	{
sl@0	1564	res = KErrGeneral;
sl@0	1565	}
sl@0	1566
sl@0	1567	free(compr);
sl@0	1568	return res;
sl@0	1569	}
sl@0	1570
sl@0	1571	/**
sl@0	1572	* Function Name : TestDeflateBoundStreamNotNull
sl@0	1573	* TestCase Description: Pass valid stream to deflatebound with memlevel=7, which
sl@0	1574	* in turn covers the decision for (s->hash_bits != 8 + 7)
sl@0	1575	*/
sl@0	1576	TInt CTestZlib::TestDeflateBoundStreamNotNull()
sl@0	1577	{
sl@0	1578	TInt res = KErrNone;
sl@0	1579	z_stream stream;
sl@0	1580	int err;
sl@0	1581	int level=Z_DEFAULT_COMPRESSION;
sl@0	1582
sl@0	1583	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1584	Byte *compr;
sl@0	1585	uLong comprLen = 20*sizeof(int);
sl@0	1586	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1587	if (compr == Z_NULL)
sl@0	1588	{
sl@0	1589	return KErrNoMemory;
sl@0	1590	}
sl@0	1591
sl@0	1592	stream.next_in = (Bytef*)hello;
sl@0	1593	stream.next_out = compr;
sl@0	1594	stream.avail_in = (uInt)sourceLen;
sl@0	1595	stream.avail_out = (uInt)comprLen;
sl@0	1596	if ((uLong)stream.avail_out != comprLen)
sl@0	1597	{
sl@0	1598	res = KErrGeneral;
sl@0	1599	}
sl@0	1600
sl@0	1601	stream.zalloc = (alloc_func)0;
sl@0	1602	stream.zfree = (free_func)0;
sl@0	1603	stream.opaque = (voidpf)0;
sl@0	1604
sl@0	1605	err= deflateInit2_(&stream, level, 8, 14, 7,
sl@0	1606	0, zlibVersion(), sizeof(z_stream));
sl@0	1607
sl@0	1608	if (err == Z_OK)
sl@0	1609	{
sl@0	1610	int y= deflateBound(&stream, sourceLen);
sl@0	1611	if(y > sourceLen)
sl@0	1612	{
sl@0	1613	res = KErrNone ;
sl@0	1614	}
sl@0	1615	else
sl@0	1616	{
sl@0	1617	res = KErrGeneral;
sl@0	1618	}
sl@0	1619	}
sl@0	1620	else
sl@0	1621	{
sl@0	1622	res = KErrGeneral;
sl@0	1623	return res;
sl@0	1624	}
sl@0	1625
sl@0	1626	err=deflateEnd(&stream);
sl@0	1627	if (err != Z_OK)
sl@0	1628	{
sl@0	1629	res = KErrGeneral;
sl@0	1630	}
sl@0	1631	free(compr);
sl@0	1632	return res;
sl@0	1633	}
sl@0	1634
sl@0	1635	/**
sl@0	1636	* Function Name : TestDeflateBoundStreamNull
sl@0	1637	* TestCase Description: Pass Z_NULL to deflatebound
sl@0	1638	*/
sl@0	1639	TInt CTestZlib::TestDeflateBoundStreamNull()
sl@0	1640	{
sl@0	1641	TInt res = KErrNone;
sl@0	1642	z_stream stream;
sl@0	1643	int err;
sl@0	1644	int level=Z_DEFAULT_COMPRESSION;
sl@0	1645
sl@0	1646	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1647	Byte *compr;
sl@0	1648	uLong comprLen = 20*sizeof(int);
sl@0	1649	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1650	if (compr == Z_NULL)
sl@0	1651	{
sl@0	1652	return KErrNoMemory;
sl@0	1653	}
sl@0	1654
sl@0	1655	stream.next_in = (Bytef*)hello;
sl@0	1656	stream.next_out = compr;
sl@0	1657	stream.avail_in = (uInt)sourceLen;
sl@0	1658	stream.avail_out = (uInt)comprLen;
sl@0	1659	if ((uLong)stream.avail_out != comprLen)
sl@0	1660	{
sl@0	1661	res = KErrGeneral;
sl@0	1662	}
sl@0	1663
sl@0	1664	stream.zalloc = (alloc_func)0;
sl@0	1665	stream.zfree = (free_func)0;
sl@0	1666	stream.opaque = (voidpf)0;
sl@0	1667
sl@0	1668	err= deflateInit2_(&stream, level, 8, 15, 7,
sl@0	1669	0, zlibVersion(), sizeof(z_stream));
sl@0	1670
sl@0	1671	if (err == Z_OK)
sl@0	1672	{
sl@0	1673	int y= deflateBound(Z_NULL, sourceLen);
sl@0	1674	if(y > sourceLen)
sl@0	1675	{
sl@0	1676	res = KErrNone ;
sl@0	1677	}
sl@0	1678	else
sl@0	1679	{
sl@0	1680	res = KErrGeneral;
sl@0	1681	}
sl@0	1682	}
sl@0	1683	else
sl@0	1684	{
sl@0	1685	res = KErrGeneral;
sl@0	1686	return res;
sl@0	1687	}
sl@0	1688
sl@0	1689	err=deflateEnd(&stream);
sl@0	1690	if (err != Z_OK)
sl@0	1691	{
sl@0	1692	res = KErrGeneral;
sl@0	1693	}
sl@0	1694	free(compr);
sl@0	1695	return res;
sl@0	1696	}
sl@0	1697
sl@0	1698	/**
sl@0	1699	* Function Name : TestDeflateBoundStreamStateNull
sl@0	1700	* TestCase Description: Stream state is equated to Z_NULL
sl@0	1701	* and passed to deflatebound
sl@0	1702	*/
sl@0	1703	TInt CTestZlib::TestDeflateBoundStreamStateNull()
sl@0	1704	{
sl@0	1705	TInt res = KErrNone;
sl@0	1706	z_stream stream;
sl@0	1707	int err;
sl@0	1708	int level=Z_DEFAULT_COMPRESSION;
sl@0	1709
sl@0	1710	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	1711	Byte *compr;
sl@0	1712	uLong comprLen = 20*sizeof(int);
sl@0	1713	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1714	if (compr == Z_NULL)
sl@0	1715	{
sl@0	1716	return KErrNoMemory;
sl@0	1717	}
sl@0	1718
sl@0	1719	stream.next_in = (Bytef*)hello;
sl@0	1720	stream.next_out = compr;
sl@0	1721	stream.avail_in = (uInt)sourceLen;
sl@0	1722	stream.avail_out = (uInt)comprLen;
sl@0	1723	if ((uLong)stream.avail_out != comprLen)
sl@0	1724	{
sl@0	1725	res = KErrGeneral;
sl@0	1726	}
sl@0	1727
sl@0	1728	stream.zalloc = (alloc_func)0;
sl@0	1729	stream.zfree = (free_func)0;
sl@0	1730	stream.opaque = (voidpf)0;
sl@0	1731
sl@0	1732	err= deflateInit2_(&stream, level, 8, 15, 7,
sl@0	1733	0, zlibVersion(), sizeof(z_stream));
sl@0	1734
sl@0	1735	if (err == Z_OK)
sl@0	1736	{
sl@0	1737	//stream.state = Z_NULL;
sl@0	1738	int y= deflateBound(&stream, sourceLen);
sl@0	1739	if(y > sourceLen)
sl@0	1740	{
sl@0	1741	res = KErrNone ;
sl@0	1742	}
sl@0	1743	else
sl@0	1744	{
sl@0	1745	res = KErrGeneral;
sl@0	1746	}
sl@0	1747	err=deflateEnd(&stream);
sl@0	1748	if (err != Z_OK)
sl@0	1749	{
sl@0	1750	INFO_PRINTF1(_L("Error encountered in deflateEnd"));
sl@0	1751	free(compr);
sl@0	1752	return KErrNone;
sl@0	1753	}
sl@0	1754
sl@0	1755	// for coverage improvement
sl@0	1756	stream.state = Z_NULL;
sl@0	1757	y = deflateBound(&stream, sourceLen);
sl@0	1758	} // end of if
sl@0	1759	else
sl@0	1760	{
sl@0	1761	res = KErrGeneral;
sl@0	1762	return res;
sl@0	1763	}
sl@0	1764
sl@0	1765	free(compr);
sl@0	1766	return res;
sl@0	1767	}
sl@0	1768
sl@0	1769	/**
sl@0	1770	* Function Name : TestDeflateSetDictionaryWrap
sl@0	1771	* TestCase Description: 1. Pass window bits > 15 to set the stream->wrap = 2
sl@0	1772	* 2. Pass window bits < 0 to set the stream->wrap = 0
sl@0	1773	* Return Value: Z_STREAM_ERROR
sl@0	1774	*/
sl@0	1775	TInt CTestZlib::TestDeflateSetDictionaryWrap()
sl@0	1776	{
sl@0	1777	int level=Z_DEFAULT_COMPRESSION;
sl@0	1778	int WindowBits = 0;
sl@0	1779
sl@0	1780	Byte *comp;
sl@0	1781	uLong compLen;
sl@0	1782	compLen = 30;
sl@0	1783	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1784
sl@0	1785	ReadIntParam(WindowBits);
sl@0	1786
sl@0	1787	z_stream stream; // compression stream
sl@0	1788	int err;
sl@0	1789	const char hello[] = "hello, hello!";
sl@0	1790	uLong len = (uLong)strlen(hello)+1;
sl@0	1791	const Bytef* dictionary=(const Bytef *) hello;
sl@0	1792	stream.zalloc = (alloc_func)0;
sl@0	1793	stream.zfree = (free_func)0;
sl@0	1794	stream.opaque = (voidpf)0;
sl@0	1795
sl@0	1796	err= deflateInit2_(&stream, level, 8, WindowBits, 8, 0, zlibVersion(), sizeof(z_stream));
sl@0	1797
sl@0	1798	if (err != Z_OK)
sl@0	1799	{
sl@0	1800	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	1801	free(comp);
sl@0	1802	return err;
sl@0	1803	}
sl@0	1804	err = deflateSetDictionary(&stream,dictionary,3);
sl@0	1805	if(err == Z_STREAM_ERROR)
sl@0	1806	{
sl@0	1807	free(comp);
sl@0	1808	deflateEnd(&stream);
sl@0	1809	return KErrNone;
sl@0	1810	}
sl@0	1811	stream.next_in = (Bytef*)hello;
sl@0	1812	stream.next_out = comp;
sl@0	1813
sl@0	1814	while (stream.total_in != len && stream.total_out < compLen)
sl@0	1815	{
sl@0	1816	stream.avail_in = stream.avail_out = 1; //* force small buffers
sl@0	1817	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1818	if (err != Z_OK)
sl@0	1819	{
sl@0	1820	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	1821	deflateEnd(&stream);
sl@0	1822	free(comp);
sl@0	1823	return err;
sl@0	1824	}
sl@0	1825	}
sl@0	1826	// Finish the stream, still forcing small buffers:
sl@0	1827	for (;;)
sl@0	1828	{
sl@0	1829	stream.avail_out = 1;
sl@0	1830	err = deflate(&stream, Z_FINISH);
sl@0	1831	if (err == Z_STREAM_END) break;
sl@0	1832	if (err != Z_OK)
sl@0	1833	{
sl@0	1834	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	1835	deflateEnd(&stream);
sl@0	1836	free(comp);
sl@0	1837	return err;
sl@0	1838	}
sl@0	1839	}
sl@0	1840
sl@0	1841	deflateEnd(&stream);
sl@0	1842	free(comp);
sl@0	1843	return KErrNone;
sl@0	1844
sl@0	1845	}
sl@0	1846
sl@0	1847	/**
sl@0	1848	* Function Name : TestDeflateSetDictionaryLen
sl@0	1849	* TestCase Description: Supply dictLength > MAX_DIST(s)
sl@0	1850	* Return Value: Z_OK
sl@0	1851	*/
sl@0	1852	TInt CTestZlib::TestDeflateSetDictionaryLen()
sl@0	1853	{
sl@0	1854	int level=Z_DEFAULT_COMPRESSION;
sl@0	1855
sl@0	1856	Byte *comp;
sl@0	1857	uLong compLen;
sl@0	1858	compLen = 30;
sl@0	1859	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1860
sl@0	1861	z_stream stream; // compression stream
sl@0	1862	int err;
sl@0	1863	const char hello[] = "hello, hello!";
sl@0	1864	uLong len = (uLong)strlen(hello)+1;
sl@0	1865	const Bytef* dictionary=(const Bytef *) hello;
sl@0	1866	stream.zalloc = (alloc_func)0;
sl@0	1867	stream.zfree = (free_func)0;
sl@0	1868	stream.opaque = (voidpf)0;
sl@0	1869
sl@0	1870	err= deflateInit2_(&stream, level, 8, 9, 8, 0, zlibVersion(), sizeof(z_stream));
sl@0	1871
sl@0	1872	if (err != Z_OK)
sl@0	1873	{
sl@0	1874	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	1875	free(comp);
sl@0	1876	return err;
sl@0	1877	}
sl@0	1878
sl@0	1879	// Pass dictLength=251 which is > MAX_DIST(s) for window bits=9
sl@0	1880	err = deflateSetDictionary(&stream,dictionary,251);
sl@0	1881	if(err != Z_OK)
sl@0	1882	{
sl@0	1883	free(comp);
sl@0	1884	deflateEnd(&stream);
sl@0	1885	return err;
sl@0	1886	}
sl@0	1887	stream.next_in = (Bytef*)hello;
sl@0	1888	stream.next_out = comp;
sl@0	1889
sl@0	1890	while (stream.total_in != len && stream.total_out < compLen)
sl@0	1891	{
sl@0	1892	stream.avail_in = stream.avail_out = 1; //* force small buffers
sl@0	1893	err = deflate(&stream, Z_NO_FLUSH);
sl@0	1894	if (err != Z_OK)
sl@0	1895	{
sl@0	1896	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	1897	deflateEnd(&stream);
sl@0	1898	free(comp);
sl@0	1899	return err;
sl@0	1900	}
sl@0	1901	}
sl@0	1902	// Finish the stream, still forcing small buffers:
sl@0	1903	for (;;)
sl@0	1904	{
sl@0	1905	stream.avail_out = 1;
sl@0	1906	err = deflate(&stream, Z_FINISH);
sl@0	1907	if (err == Z_STREAM_END) break;
sl@0	1908	if (err != Z_OK)
sl@0	1909	{
sl@0	1910	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	1911	deflateEnd(&stream);
sl@0	1912	free(comp);
sl@0	1913	return err;
sl@0	1914	}
sl@0	1915	}
sl@0	1916
sl@0	1917	deflateEnd(&stream);
sl@0	1918	free(comp);
sl@0	1919	return KErrNone;
sl@0	1920
sl@0	1921	}
sl@0	1922
sl@0	1923	/**
sl@0	1924	* Function Name : TestInflateSetDictionaryBadMode
sl@0	1925	* TestCase Description: Supply window bits=9 making state->mode = BAD
sl@0	1926	* Return Value: Z_STREAM_ERROR
sl@0	1927	*/
sl@0	1928	TInt CTestZlib::TestInflateSetDictionaryBadMode()
sl@0	1929	{
sl@0	1930	TInt res = KErrNone ;
sl@0	1931	Byte compr, uncompr;
sl@0	1932	uLong comprLen = 100*sizeof(int);
sl@0	1933	uLong uncomprLen = comprLen;
sl@0	1934
sl@0	1935	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1936	if (compr == Z_NULL)
sl@0	1937	{
sl@0	1938	return KErrNoMemory;
sl@0	1939	}
sl@0	1940	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1941	if (uncompr == Z_NULL)
sl@0	1942	{
sl@0	1943	free(compr);
sl@0	1944	return KErrNoMemory;
sl@0	1945	}
sl@0	1946	res = Test_dict_deflate(compr, comprLen);
sl@0	1947
sl@0	1948	if(res < 0)
sl@0	1949	{
sl@0	1950	free(compr);
sl@0	1951	free(uncompr);
sl@0	1952	return res;
sl@0	1953	}
sl@0	1954	if(res == 0)
sl@0	1955	{
sl@0	1956
sl@0	1957	int err;
sl@0	1958	z_stream d_stream; // decompression stream
sl@0	1959
sl@0	1960	strcpy((char*)uncompr, "garbage");
sl@0	1961
sl@0	1962	d_stream.zalloc = (alloc_func)0;
sl@0	1963	d_stream.zfree = (free_func)0;
sl@0	1964	d_stream.opaque = (voidpf)0;
sl@0	1965
sl@0	1966	d_stream.next_in = compr;
sl@0	1967	d_stream.avail_in = (uInt)comprLen;
sl@0	1968
sl@0	1969	err = inflateInit2_(&d_stream, 9, "1.2.4", sizeof(d_stream));
sl@0	1970	if(err < 0 )
sl@0	1971	{
sl@0	1972	free(compr);
sl@0	1973	free(uncompr);
sl@0	1974	return Z_MEM_ERROR;
sl@0	1975	}
sl@0	1976
sl@0	1977	d_stream.next_out = uncompr;
sl@0	1978	d_stream.avail_out = (uInt)uncomprLen;
sl@0	1979
sl@0	1980	for (;;)
sl@0	1981	{
sl@0	1982	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	1983	err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,sizeof(dictionary));
sl@0	1984	if(err == Z_STREAM_ERROR)
sl@0	1985	{
sl@0	1986	res = KErrNone;
sl@0	1987	break;
sl@0	1988	}
sl@0	1989	} // end of for
sl@0	1990
sl@0	1991	err = inflateEnd(&d_stream);
sl@0	1992	} // end of outer if
sl@0	1993	else
sl@0	1994	{
sl@0	1995	res=KErrGeneral;
sl@0	1996	}
sl@0	1997
sl@0	1998	free(compr);
sl@0	1999	free(uncompr);
sl@0	2000	return res;
sl@0	2001	}
sl@0	2002
sl@0	2003	/**
sl@0	2004	* Function Name : TestInflateSetDictionaryStreamStateNull
sl@0	2005	* TestCase Description: Make stream->state = Z_NULL
sl@0	2006	* Return Value: Z_STREAM_ERROR
sl@0	2007	*/
sl@0	2008	TInt CTestZlib::TestInflateSetDictionaryStreamStateNull()
sl@0	2009	{
sl@0	2010	TInt res = KErrNone ;
sl@0	2011	Byte compr, uncompr;
sl@0	2012	uLong comprLen = 100*sizeof(int);
sl@0	2013	uLong uncomprLen = comprLen;
sl@0	2014
sl@0	2015	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2016	if (compr == Z_NULL)
sl@0	2017	{
sl@0	2018	return KErrNoMemory;
sl@0	2019	}
sl@0	2020	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2021	if (uncompr == Z_NULL)
sl@0	2022	{
sl@0	2023	free(compr);
sl@0	2024	return KErrNoMemory;
sl@0	2025	}
sl@0	2026	res = Test_dict_deflate(compr, comprLen);
sl@0	2027
sl@0	2028	if(res < 0)
sl@0	2029	{
sl@0	2030	free(compr);
sl@0	2031	free(uncompr);
sl@0	2032	return res;
sl@0	2033	}
sl@0	2034	if(res == 0)
sl@0	2035	{
sl@0	2036
sl@0	2037	int err;
sl@0	2038	z_stream d_stream; // decompression stream
sl@0	2039
sl@0	2040	strcpy((char*)uncompr, "garbage");
sl@0	2041
sl@0	2042	d_stream.zalloc = (alloc_func)0;
sl@0	2043	d_stream.zfree = (free_func)0;
sl@0	2044	d_stream.opaque = (voidpf)0;
sl@0	2045
sl@0	2046	d_stream.next_in = compr;
sl@0	2047	d_stream.avail_in = (uInt)comprLen;
sl@0	2048
sl@0	2049	err = inflateInit2_(&d_stream, 15, "1.2.4", sizeof(d_stream));
sl@0	2050	if(err < 0 )
sl@0	2051	{
sl@0	2052	free(compr);
sl@0	2053	free(uncompr);
sl@0	2054	return Z_MEM_ERROR;
sl@0	2055	}
sl@0	2056
sl@0	2057	d_stream.next_out = uncompr;
sl@0	2058	d_stream.avail_out = (uInt)uncomprLen;
sl@0	2059
sl@0	2060	for (;;)
sl@0	2061	{
sl@0	2062	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	2063	if (err < Z_OK)
sl@0	2064	{
sl@0	2065	INFO_PRINTF1(_L("Inflate failed"));
sl@0	2066	res = KErrGeneral;
sl@0	2067	break;
sl@0	2068	}
sl@0	2069	err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,sizeof(dictionary));
sl@0	2070	if(err == Z_STREAM_ERROR)
sl@0	2071	{
sl@0	2072	res = KErrNone;
sl@0	2073	break;
sl@0	2074	}
sl@0	2075	}
sl@0	2076	err = inflateEnd(&d_stream);
sl@0	2077
sl@0	2078	//for coverage improvement
sl@0	2079	d_stream.state = Z_NULL;
sl@0	2080	err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,sizeof(dictionary));
sl@0	2081	if(err == Z_STREAM_ERROR)
sl@0	2082	{
sl@0	2083	res = KErrNone;
sl@0	2084	}
sl@0	2085	} // end of outer if
sl@0	2086	else
sl@0	2087	{
sl@0	2088	res=KErrGeneral;
sl@0	2089	}
sl@0	2090
sl@0	2091	free(compr);
sl@0	2092	free(uncompr);
sl@0	2093	return res;
sl@0	2094	}
sl@0	2095
sl@0	2096	/**
sl@0	2097	* Function Name : TestDeflateParamsStreamStateNull
sl@0	2098	* TestCase Description: Make stream state Z_NULL
sl@0	2099	* Return Value: Z_STREAM_ERROR
sl@0	2100	*/
sl@0	2101	TInt CTestZlib::TestDeflateParamsStreamStateNull()
sl@0	2102	{
sl@0	2103	TInt res = KErrNone ;
sl@0	2104	z_stream c_stream; // compression stream
sl@0	2105	int err;
sl@0	2106	Byte * compr;
sl@0	2107
sl@0	2108	uLong comprLen = 20*sizeof(int);
sl@0	2109
sl@0	2110	compr=(Byte*)calloc((uInt)comprLen, 1);
sl@0	2111	if (compr == Z_NULL)
sl@0	2112	{
sl@0	2113	return KErrNoMemory;
sl@0	2114	}
sl@0	2115
sl@0	2116	uLong len = (uLong)strlen(hello)+1;
sl@0	2117
sl@0	2118	c_stream.zalloc = (alloc_func)0;
sl@0	2119	c_stream.zfree = (free_func)0;
sl@0	2120	c_stream.opaque = (voidpf)0;
sl@0	2121
sl@0	2122	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	2123	if(err <0)
sl@0	2124	{
sl@0	2125	free(compr);
sl@0	2126	return err;
sl@0	2127	}
sl@0	2128
sl@0	2129	c_stream.next_in = (Bytef*)hello;
sl@0	2130	c_stream.next_out = compr;
sl@0	2131
sl@0	2132	err= deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
sl@0	2133	deflateEnd(&c_stream);
sl@0	2134
sl@0	2135	// Equate the stream state to Z_NULL for coverage improvement
sl@0	2136	c_stream.state = Z_NULL;
sl@0	2137	err= deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
sl@0	2138
sl@0	2139	if(err == Z_STREAM_ERROR)
sl@0	2140	{
sl@0	2141	res=KErrNone;
sl@0	2142	}
sl@0	2143	else
sl@0	2144	{
sl@0	2145	res=KErrGeneral;
sl@0	2146	}
sl@0	2147
sl@0	2148	free(compr);
sl@0	2149	return res;
sl@0	2150	}
sl@0	2151
sl@0	2152	/**
sl@0	2153	* Function Name : TestInflateSyncAvailInNull
sl@0	2154	* TestCase Description: Make avail in Z_NULL
sl@0	2155	* Return Value: Z_BUF_ERROR
sl@0	2156	*/
sl@0	2157	TInt CTestZlib::TestInflateSyncAvailInNull()
sl@0	2158	{
sl@0	2159	TInt res = KErrNone ;
sl@0	2160	uLong len = (uLong)strlen(hello)+1;
sl@0	2161
sl@0	2162	Byte compr, uncompr;
sl@0	2163	uLong comprLen = 20*sizeof(int);
sl@0	2164	uLong uncomprLen = comprLen;
sl@0	2165	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2166	if (compr == Z_NULL)
sl@0	2167	{
sl@0	2168	return KErrNoMemory;
sl@0	2169	}
sl@0	2170	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2171	if (uncompr == Z_NULL)
sl@0	2172	{
sl@0	2173	free(compr);
sl@0	2174	return KErrNoMemory;
sl@0	2175	}
sl@0	2176
sl@0	2177	int err;
sl@0	2178	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	2179	if(err < 0)
sl@0	2180	{
sl@0	2181	res = KErrNoMemory;
sl@0	2182	}
sl@0	2183	else if(err == 0)
sl@0	2184	{
sl@0	2185	res = KErrNone ;
sl@0	2186	}
sl@0	2187	else
sl@0	2188	{
sl@0	2189	res = KErrGeneral;
sl@0	2190	}
sl@0	2191
sl@0	2192	if(res<0)
sl@0	2193	{
sl@0	2194	free(compr);
sl@0	2195	free(uncompr);
sl@0	2196	return KErrNoMemory;
sl@0	2197	}
sl@0	2198
sl@0	2199	Test_flush(compr, &comprLen);
sl@0	2200
sl@0	2201	z_stream d_stream; /* decompression stream */
sl@0	2202
sl@0	2203	strcpy((char*)uncompr, "garbage");
sl@0	2204
sl@0	2205	d_stream.zalloc = (alloc_func)0;
sl@0	2206	d_stream.zfree = (free_func)0;
sl@0	2207	d_stream.opaque = (voidpf)0;
sl@0	2208
sl@0	2209	d_stream.next_in = compr;
sl@0	2210	d_stream.avail_in = 2; /* just read the zlib header */
sl@0	2211
sl@0	2212	err = inflateInit(&d_stream);
sl@0	2213	if(err!=0)
sl@0	2214	{
sl@0	2215	res=KErrGeneral;
sl@0	2216	}
sl@0	2217
sl@0	2218
sl@0	2219	d_stream.next_out = uncompr;
sl@0	2220	d_stream.avail_out = (uInt)uncomprLen;
sl@0	2221
sl@0	2222	err=inflate(&d_stream, Z_NO_FLUSH);
sl@0	2223	if(err!=0)
sl@0	2224	{
sl@0	2225	res=KErrGeneral;
sl@0	2226	}
sl@0	2227
sl@0	2228	// Make avail_in Z_NULL
sl@0	2229	d_stream.avail_in = Z_NULL;
sl@0	2230	err = inflateSync(&d_stream); /* but skip the damaged part */
sl@0	2231	if(err == Z_BUF_ERROR)
sl@0	2232	{
sl@0	2233	res=KErrNone;
sl@0	2234	}
sl@0	2235
sl@0	2236	free(compr);
sl@0	2237	free(uncompr);
sl@0	2238	err = inflateEnd(&d_stream);
sl@0	2239	if(Z_OK != err)
sl@0	2240	{
sl@0	2241	INFO_PRINTF1(_L("Error encountered in inflateEnd"));
sl@0	2242	return KErrGeneral;
sl@0	2243	}
sl@0	2244	return res;
sl@0	2245	}
sl@0	2246
sl@0	2247	/**
sl@0	2248	* Function Name : TestInflateSyncStreamNull
sl@0	2249	* TestCase Description: Pass NULL stream to InflateSync
sl@0	2250	* Return Value: Z_STREAM_ERROR
sl@0	2251	*/
sl@0	2252	TInt CTestZlib::TestInflateSyncStreamNull()
sl@0	2253	{
sl@0	2254	TInt res = KErrNone ;
sl@0	2255	uLong len = (uLong)strlen(hello)+1;
sl@0	2256
sl@0	2257	Byte compr, uncompr;
sl@0	2258	uLong comprLen = 20*sizeof(int);
sl@0	2259	uLong uncomprLen = comprLen;
sl@0	2260	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2261	if (compr == Z_NULL)
sl@0	2262	{
sl@0	2263	return KErrNoMemory;
sl@0	2264	}
sl@0	2265	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2266	if (uncompr == Z_NULL)
sl@0	2267	{
sl@0	2268	free(compr);
sl@0	2269	return KErrNoMemory;
sl@0	2270	}
sl@0	2271
sl@0	2272	int err;
sl@0	2273	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	2274	if(err < 0)
sl@0	2275	{
sl@0	2276	res = KErrNoMemory;
sl@0	2277	}
sl@0	2278	else if(err == 0)
sl@0	2279	{
sl@0	2280	res = KErrNone ;
sl@0	2281	}
sl@0	2282	else
sl@0	2283	{
sl@0	2284	res = KErrGeneral;
sl@0	2285	}
sl@0	2286
sl@0	2287	if(res<0)
sl@0	2288	{
sl@0	2289	free(compr);
sl@0	2290	free(uncompr);
sl@0	2291	return KErrNoMemory;
sl@0	2292	}
sl@0	2293
sl@0	2294	Test_flush(compr, &comprLen);
sl@0	2295
sl@0	2296	z_stream d_stream; /* decompression stream */
sl@0	2297
sl@0	2298	strcpy((char*)uncompr, "garbage");
sl@0	2299
sl@0	2300	d_stream.zalloc = (alloc_func)0;
sl@0	2301	d_stream.zfree = (free_func)0;
sl@0	2302	d_stream.opaque = (voidpf)0;
sl@0	2303
sl@0	2304	d_stream.next_in = compr;
sl@0	2305	d_stream.avail_in = 2; /* just read the zlib header */
sl@0	2306
sl@0	2307	err = inflateInit(&d_stream);
sl@0	2308	if(err!=0)
sl@0	2309	{
sl@0	2310	res=KErrGeneral;
sl@0	2311	}
sl@0	2312
sl@0	2313	d_stream.next_out = uncompr;
sl@0	2314	d_stream.avail_out = (uInt)uncomprLen;
sl@0	2315
sl@0	2316	err=inflate(&d_stream, Z_NO_FLUSH);
sl@0	2317	if(err!=0)
sl@0	2318	{
sl@0	2319	res=KErrGeneral;
sl@0	2320	}
sl@0	2321
sl@0	2322	d_stream.avail_in = (uInt)comprLen-2;
sl@0	2323
sl@0	2324	// Make stream Z_NULL
sl@0	2325	err = inflateSync(Z_NULL);
sl@0	2326	if(err == Z_STREAM_ERROR)
sl@0	2327	{
sl@0	2328	res=KErrNone;
sl@0	2329	}
sl@0	2330	err = inflateEnd(&d_stream);
sl@0	2331	if(Z_OK != err)
sl@0	2332	{
sl@0	2333	INFO_PRINTF1(_L("Error encountered in inflateEnd"));
sl@0	2334	return KErrGeneral;
sl@0	2335	}
sl@0	2336	free(compr);
sl@0	2337	free(uncompr);
sl@0	2338	return res;
sl@0	2339	}
sl@0	2340
sl@0	2341	/**
sl@0	2342	* Function Name : TestInflateSyncStreamStateNull
sl@0	2343	* TestCase Description: Make stream state = Z_NULL
sl@0	2344	* Return Value: Z_STREAM_ERROR
sl@0	2345	*/
sl@0	2346	TInt CTestZlib::TestInflateSyncStreamStateNull()
sl@0	2347	{
sl@0	2348	TInt res = KErrNone ;
sl@0	2349	uLong len = (uLong)strlen(hello)+1;
sl@0	2350
sl@0	2351	Byte compr, uncompr;
sl@0	2352	uLong comprLen = 20*sizeof(int);
sl@0	2353	uLong uncomprLen = comprLen;
sl@0	2354	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2355	if (compr == Z_NULL)
sl@0	2356	{
sl@0	2357	return KErrNoMemory;
sl@0	2358	}
sl@0	2359	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2360	if (uncompr == Z_NULL)
sl@0	2361	{
sl@0	2362	free(compr);
sl@0	2363	return KErrNoMemory;
sl@0	2364	}
sl@0	2365
sl@0	2366	int err;
sl@0	2367	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	2368	if(err < 0)
sl@0	2369	{
sl@0	2370	res = KErrNoMemory;
sl@0	2371	}
sl@0	2372	else if(err == 0)
sl@0	2373	{
sl@0	2374	res = KErrNone ;
sl@0	2375	}
sl@0	2376	else
sl@0	2377	{
sl@0	2378	res = KErrGeneral;
sl@0	2379	}
sl@0	2380
sl@0	2381	if(res<0)
sl@0	2382	{
sl@0	2383	free(compr);
sl@0	2384	free(uncompr);
sl@0	2385	return KErrNoMemory;
sl@0	2386	}
sl@0	2387
sl@0	2388	Test_flush(compr, &comprLen);
sl@0	2389
sl@0	2390	z_stream d_stream; /* decompression stream */
sl@0	2391
sl@0	2392	strcpy((char*)uncompr, "garbage");
sl@0	2393
sl@0	2394	d_stream.zalloc = (alloc_func)0;
sl@0	2395	d_stream.zfree = (free_func)0;
sl@0	2396	d_stream.opaque = (voidpf)0;
sl@0	2397
sl@0	2398	d_stream.next_in = compr;
sl@0	2399	d_stream.avail_in = 2; /* just read the zlib header */
sl@0	2400
sl@0	2401	err = inflateInit(&d_stream);
sl@0	2402	if(err!=0)
sl@0	2403	{
sl@0	2404	res=KErrGeneral;
sl@0	2405	}
sl@0	2406	d_stream.next_out = uncompr;
sl@0	2407	d_stream.avail_out = (uInt)uncomprLen;
sl@0	2408	err=inflate(&d_stream, Z_NO_FLUSH);
sl@0	2409	if(err!=0)
sl@0	2410	{
sl@0	2411	res=KErrGeneral;
sl@0	2412	}
sl@0	2413
sl@0	2414	d_stream.avail_in = (uInt)comprLen-2;
sl@0	2415	err = inflateSync(&d_stream);
sl@0	2416	err = inflateEnd(&d_stream);
sl@0	2417	if(Z_OK != err)
sl@0	2418	{
sl@0	2419	INFO_PRINTF1(_L("Error encountered in inflateEnd"));
sl@0	2420	return KErrGeneral;
sl@0	2421	}
sl@0	2422
sl@0	2423	// for coverage improvement
sl@0	2424	d_stream.state = Z_NULL;
sl@0	2425	err = inflateSync(&d_stream);
sl@0	2426
sl@0	2427	if(err == Z_STREAM_ERROR)
sl@0	2428	{
sl@0	2429	res=KErrNone;
sl@0	2430	}
sl@0	2431	free(compr);
sl@0	2432	free(uncompr);
sl@0	2433	return res;
sl@0	2434	}
sl@0	2435
sl@0	2436	/**
sl@0	2437	* Function Name : TestInflateSyncPointStreamStateNull
sl@0	2438	* TestCase Description: Make stream state = Z_NULL
sl@0	2439	* Return Value: Z_STREAM_ERROR
sl@0	2440	*/
sl@0	2441	TInt CTestZlib::TestInflateSyncPointStreamStateNull()
sl@0	2442	{
sl@0	2443	TInt res = KErrNone ;
sl@0	2444	uLong len = (uLong)strlen(hello)+1;
sl@0	2445
sl@0	2446	Byte compr, uncompr;
sl@0	2447	uLong comprLen = 20*sizeof(int);
sl@0	2448	uLong uncomprLen = comprLen;
sl@0	2449	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2450	if (compr == Z_NULL)
sl@0	2451	{
sl@0	2452	return KErrNoMemory;
sl@0	2453	}
sl@0	2454	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2455	if (uncompr == Z_NULL)
sl@0	2456	{
sl@0	2457	free(compr);
sl@0	2458	return KErrNoMemory;
sl@0	2459	}
sl@0	2460
sl@0	2461	z_stream stream;
sl@0	2462	int err;
sl@0	2463
sl@0	2464	stream.next_in = (Bytef*)hello;
sl@0	2465	stream.avail_in = (uInt)len;
sl@0	2466
sl@0	2467	stream.next_out = compr;
sl@0	2468	stream.avail_out = (uInt)comprLen;
sl@0	2469
sl@0	2470	stream.zalloc = (alloc_func)0;
sl@0	2471	stream.zfree = (free_func)0;
sl@0	2472	stream.opaque = (voidpf)0;
sl@0	2473
sl@0	2474	err = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
sl@0	2475	if (err != Z_OK)
sl@0	2476	{
sl@0	2477	free(compr);
sl@0	2478	free(uncompr);
sl@0	2479	return err;
sl@0	2480	}
sl@0	2481
sl@0	2482	err = deflate(&stream, Z_FINISH);
sl@0	2483	if (err != Z_STREAM_END)
sl@0	2484	{
sl@0	2485	deflateEnd(&stream);
sl@0	2486	free(compr);
sl@0	2487	free(uncompr);
sl@0	2488	return err == Z_OK ? Z_BUF_ERROR : err;
sl@0	2489	}
sl@0	2490	comprLen = stream.total_out;
sl@0	2491
sl@0	2492	err = inflateSyncPoint(&stream);
sl@0	2493	err = deflateEnd(&stream);
sl@0	2494	if(err == Z_STREAM_ERROR)
sl@0	2495	{
sl@0	2496	INFO_PRINTF1(_L("Error encountered in inflateEnd"));
sl@0	2497	free(compr);
sl@0	2498	free(uncompr);
sl@0	2499	return KErrNone;
sl@0	2500	}
sl@0	2501
sl@0	2502	//Make stream state NULL
sl@0	2503	stream.state = Z_NULL;
sl@0	2504	err = inflateSyncPoint(&stream);
sl@0	2505	//err = inflateEnd(&stream);
sl@0	2506	if(err == Z_STREAM_ERROR)
sl@0	2507	{
sl@0	2508	res=KErrNone;
sl@0	2509	}
sl@0	2510
sl@0	2511	free(compr);
sl@0	2512	free(uncompr);
sl@0	2513	return res;
sl@0	2514	}
sl@0	2515
sl@0	2516
sl@0	2517	/**
sl@0	2518	* Function Name : TestAdlerScenarios
sl@0	2519	* TestCase Description: 1. len = 1, adler > BASE
sl@0	2520	* 2. len < 16, adler > BASE
sl@0	2521	* 3. len > NMAX
sl@0	2522	* Return Value: Adler value
sl@0	2523	*/
sl@0	2524	TInt CTestZlib::TestAdlerScenarios()
sl@0	2525	{
sl@0	2526	TInt res = KErrNone ;
sl@0	2527	//unsigned char buffer[5]="1234";
sl@0	2528	unsigned char buffer[5552];
sl@0	2529	int len=0;
sl@0	2530	int adler1=0;
sl@0	2531
sl@0	2532	_LIT(KParam1, "Param1");
sl@0	2533	TBool ret = GetIntFromConfig(ConfigSection(), KParam1, adler1);
sl@0	2534	if(!ret)
sl@0	2535	{
sl@0	2536	INFO_PRINTF1(_L("Failed to read the values from ini file"));
sl@0	2537	}
sl@0	2538
sl@0	2539	_LIT(KParam2, "Param2");
sl@0	2540	ret = GetIntFromConfig(ConfigSection(), KParam2, len);
sl@0	2541	if(!ret)
sl@0	2542	{
sl@0	2543	INFO_PRINTF1(_L("Failed to read the values from ini file"));
sl@0	2544	}
sl@0	2545
sl@0	2546	long long adler = adler32((long)adler1, &buffer[0], (unsigned int)len);
sl@0	2547	INFO_PRINTF2(_L("buf %x"),adler);
sl@0	2548
sl@0	2549	if(adler > 0)
sl@0	2550	{
sl@0	2551	res=KErrNone ;
sl@0	2552	}
sl@0	2553	else
sl@0	2554	{
sl@0	2555	res = KErrGeneral;
sl@0	2556	}
sl@0	2557	return res;
sl@0	2558	}
sl@0	2559
sl@0	2560	/**
sl@0	2561	* Function Name : TestGzsetparamsFileNull
sl@0	2562	* TestCase Description: Pass NULL pointer to gzsetparams
sl@0	2563	* Return Value: Z_STREAM_ERROR
sl@0	2564	*/
sl@0	2565	TInt CTestZlib::TestGzsetparamsFileNull()
sl@0	2566	{
sl@0	2567	TInt res = KErrNone ;
sl@0	2568
sl@0	2569	int len = (int)strlen(hello)+1;
sl@0	2570	gzFile file;
sl@0	2571
sl@0	2572	const char * fname = TESTFILE;
sl@0	2573
sl@0	2574	file = gzopen(fname, "wb");
sl@0	2575	gzputc(file, 'h');
sl@0	2576
sl@0	2577	int err = gzsetparams(NULL, Z_BEST_SPEED, Z_DEFAULT_STRATEGY);
sl@0	2578	if(err == Z_STREAM_ERROR)
sl@0	2579	{
sl@0	2580	gzclose(file);
sl@0	2581	res = KErrNone;
sl@0	2582	}
sl@0	2583
sl@0	2584	return res;
sl@0	2585	}
sl@0	2586
sl@0	2587	/**
sl@0	2588	* Function Name : TestGzopenWrite
sl@0	2589	* TestCase Description: Open a gz file in write mode, close it and
sl@0	2590	* and then open again in read mode
sl@0	2591	*/
sl@0	2592	TInt CTestZlib::TestGzopenWrite()
sl@0	2593	{
sl@0	2594	gzFile file;
sl@0	2595	const char * fname = "c:\\file.txt";
sl@0	2596	file = gzopen(fname, "wb");
sl@0	2597
sl@0	2598	gzputs(file, "Coverage Improvement");
sl@0	2599
sl@0	2600	gzclose(file);
sl@0	2601
sl@0	2602	file = gzopen(fname, "rb");
sl@0	2603
sl@0	2604	if (file == NULL)
sl@0	2605	{
sl@0	2606	ERR_PRINTF1(_L("gzopen error"));
sl@0	2607	return KErrGeneral;
sl@0	2608	}
sl@0	2609
sl@0	2610	gzclose(file);
sl@0	2611
sl@0	2612	return KErrNone;
sl@0	2613	}
sl@0	2614
sl@0	2615	/**
sl@0	2616	* Function Name : TestGzreadLargeFile
sl@0	2617	* TestCase Description: Open a large gz file in read mode and read from it
sl@0	2618	*/
sl@0	2619	TInt CTestZlib::TestGzreadLargeFile()
sl@0	2620	{
sl@0	2621	gzFile file;
sl@0	2622	const char *s="\0";
sl@0	2623	uInt len = strlen(s);
sl@0	2624
sl@0	2625	char buf1 = (char)malloc(1024);
sl@0	2626	if (buf1 == Z_NULL)
sl@0	2627	{
sl@0	2628	return KErrNoMemory;
sl@0	2629	}
sl@0	2630
sl@0	2631	file = gzopen(FILETESTGZLARGE, "rb");
sl@0	2632	if (file == NULL)
sl@0	2633	{
sl@0	2634	ERR_PRINTF1(_L("gzopen error"));
sl@0	2635	free(buf1);
sl@0	2636	return KErrGeneral;
sl@0	2637	}
sl@0	2638
sl@0	2639	for (;;)
sl@0	2640	{
sl@0	2641	len = gzread(file, buf1, sizeof(buf1));
sl@0	2642	if(len<=0) break;
sl@0	2643	}
sl@0	2644
sl@0	2645	gzclose(file);
sl@0	2646	free(buf1);
sl@0	2647	return KErrNone;
sl@0	2648	}
sl@0	2649
sl@0	2650	/**
sl@0	2651	* Function Name : TestGzopenWriteNoPath
sl@0	2652	* TestCase Description: Open a gz file in write mode,
sl@0	2653	* close it and then open again in read mode
sl@0	2654	*/
sl@0	2655	TInt CTestZlib::TestGzopenWriteNoPath()
sl@0	2656	{
sl@0	2657	gzFile file;
sl@0	2658	const char * fname = "c:\\file.txt";
sl@0	2659	file = gzopen(fname, "wb");
sl@0	2660
sl@0	2661	gzputs(file, "Coverage Improvement");
sl@0	2662
sl@0	2663	gzclose(file);
sl@0	2664
sl@0	2665	file = gzopen(fname, "rb");
sl@0	2666
sl@0	2667	if (file == NULL)
sl@0	2668	{
sl@0	2669	ERR_PRINTF1(_L("gzopen error"));
sl@0	2670	return KErrGeneral;
sl@0	2671	}
sl@0	2672
sl@0	2673	gzclose(file);
sl@0	2674	return KErrNone;
sl@0	2675	}
sl@0	2676	/**
sl@0	2677	* Function Name : TestGzreadLenZero
sl@0	2678	* TestCase Description: 1. Read from a gz file specifying read buffer length=0
sl@0	2679	*/
sl@0	2680	TInt CTestZlib::TestGzreadLenZero()
sl@0	2681	{
sl@0	2682	char * buf1 = (char*)malloc(1024);
sl@0	2683	if (buf1 == Z_NULL)
sl@0	2684	{
sl@0	2685	ERR_PRINTF1(_L("Heap out of memory"));
sl@0	2686	return KErrNoMemory;
sl@0	2687	}
sl@0	2688
sl@0	2689	TInt res = KErrNone ;
sl@0	2690	gzFile file;
sl@0	2691	uInt len=0;
sl@0	2692	const char * fname = "c:\\file.txt";
sl@0	2693
sl@0	2694	// Write some text in gz file and close it
sl@0	2695	file = gzopen(fname, "wb");
sl@0	2696	if (file == NULL)
sl@0	2697	{
sl@0	2698	free(buf1);
sl@0	2699	ERR_PRINTF1(_L("Could not open the file"));
sl@0	2700	res = KErrGeneral;
sl@0	2701	return res;
sl@0	2702	}
sl@0	2703	gzputs(file, "Coverage Improvement");
sl@0	2704	gzclose(file);
sl@0	2705
sl@0	2706	file = gzopen(fname, "rb");
sl@0	2707	if (file == NULL)
sl@0	2708	{
sl@0	2709	free(buf1);
sl@0	2710	ERR_PRINTF1(_L("Could not open the file"));
sl@0	2711	res = KErrGeneral;
sl@0	2712	return res;
sl@0	2713	}
sl@0	2714
sl@0	2715	for (;;)
sl@0	2716	{
sl@0	2717	len = gzread(file, buf1, len);
sl@0	2718	if(len<=0) break;
sl@0	2719	}
sl@0	2720
sl@0	2721	if (gzclose(file) != Z_OK)
sl@0	2722	{
sl@0	2723	ERR_PRINTF1(_L("Could not close the file"));
sl@0	2724	res=KErrGeneral;
sl@0	2725	}
sl@0	2726	free(buf1);
sl@0	2727	return res;
sl@0	2728	}
sl@0	2729
sl@0	2730
sl@0	2731	/**
sl@0	2732	* Function Name : TestGzreadBufZero
sl@0	2733	* TestCase Description: 1. Read from a gz file passing a NULL for read buffer
sl@0	2734	*/
sl@0	2735	TInt CTestZlib::TestGzreadBufZero()
sl@0	2736	{
sl@0	2737	char * buf1 = (char*)malloc(1024);
sl@0	2738	if (buf1 == Z_NULL)
sl@0	2739	{
sl@0	2740	ERR_PRINTF1(_L("Heap out of memory"));
sl@0	2741	return KErrNoMemory;
sl@0	2742	}
sl@0	2743
sl@0	2744	TInt res = KErrNone ;
sl@0	2745	gzFile file;
sl@0	2746	uInt len=0;
sl@0	2747	const char * fname = "c:\\file.txt";
sl@0	2748
sl@0	2749	// Write some text in gz file and close it
sl@0	2750	file = gzopen(fname, "wb");
sl@0	2751	if (file == NULL)
sl@0	2752	{
sl@0	2753	free(buf1);
sl@0	2754	ERR_PRINTF1(_L("Could not open the file"));
sl@0	2755	res = KErrGeneral;
sl@0	2756	return res;
sl@0	2757	}
sl@0	2758	gzputs(file, "Coverage Improvement");
sl@0	2759	gzclose(file);
sl@0	2760
sl@0	2761	file = gzopen(fname, "rb");
sl@0	2762	if (file == NULL)
sl@0	2763	{
sl@0	2764	free(buf1);
sl@0	2765	ERR_PRINTF1(_L("Could not open the file"));
sl@0	2766	res = KErrGeneral;
sl@0	2767	return res;
sl@0	2768	}
sl@0	2769
sl@0	2770	for (;;)
sl@0	2771	{
sl@0	2772	len = gzread(file, NULL, sizeof(buf1));
sl@0	2773	if(len<=0) break;
sl@0	2774	}
sl@0	2775
sl@0	2776	if (gzclose(file) == Z_STREAM_ERROR)
sl@0	2777	{
sl@0	2778	res=KErrNone;
sl@0	2779	}
sl@0	2780	free(buf1);
sl@0	2781	return res;
sl@0	2782
sl@0	2783	}
sl@0	2784
sl@0	2785	/**
sl@0	2786	* Function Name : TestGzreadNonGzFile
sl@0	2787	* TestCase Description: 1. Read from a non gz file
sl@0	2788	*/
sl@0	2789	TInt CTestZlib::TestGzreadNonGzFile()
sl@0	2790	{
sl@0	2791	char buf1 = (char)malloc(1024);
sl@0	2792	if (buf1 == Z_NULL)
sl@0	2793	{
sl@0	2794	ERR_PRINTF1(_L("Heap out of memory"));
sl@0	2795	return KErrNoMemory;
sl@0	2796	}
sl@0	2797
sl@0	2798	TInt res = KErrNone ;
sl@0	2799	gzFile file;
sl@0	2800	uInt len=0;
sl@0	2801	const char * fname = "c:\\file.txt";
sl@0	2802
sl@0	2803	// Write in txt file and close it
sl@0	2804	FILE *fp = fopen(fname,"w");
sl@0	2805	if(fp == NULL)
sl@0	2806	{
sl@0	2807	free(buf1);
sl@0	2808	ERR_PRINTF1(_L("Could not open the output file."));
sl@0	2809	res = KErrGeneral;
sl@0	2810	return res;
sl@0	2811	}
sl@0	2812
sl@0	2813	fputc('\n',fp);
sl@0	2814	fclose(fp);
sl@0	2815
sl@0	2816	file = gzopen(fname, "rb");
sl@0	2817	if (file == NULL)
sl@0	2818	{
sl@0	2819	free(buf1);
sl@0	2820	ERR_PRINTF1(_L("Could not open the file"));
sl@0	2821	res = KErrGeneral;
sl@0	2822	return res;
sl@0	2823	}
sl@0	2824
sl@0	2825	for (;;)
sl@0	2826	{
sl@0	2827	len = gzread(file, buf1, sizeof(buf1));
sl@0	2828	if(len<=0) break;
sl@0	2829	}
sl@0	2830
sl@0	2831	if (gzclose(file) == Z_STREAM_ERROR)
sl@0	2832	{
sl@0	2833	res=KErrNone;
sl@0	2834	}
sl@0	2835	free(buf1);
sl@0	2836	return res;
sl@0	2837	}
sl@0	2838
sl@0	2839	/**
sl@0	2840	* Function Name : TestGzrewindNonGzFile
sl@0	2841	* TestCase Description: 1. Rewind in a non gz file
sl@0	2842	*/
sl@0	2843	TInt CTestZlib::TestGzrewindNonGzFile()
sl@0	2844	{
sl@0	2845	TInt res = KErrNone ;
sl@0	2846	int err;
sl@0	2847	int len = (int)strlen(hello)+1;
sl@0	2848	gzFile file;
sl@0	2849	const char * fname = "c:\\file.txt";
sl@0	2850
sl@0	2851	FILE *fp=NULL;
sl@0	2852	fp=fopen(fname,"w");
sl@0	2853	fputc('\n',fp);
sl@0	2854	fclose(fp);
sl@0	2855
sl@0	2856	file = gzopen(fname, "rb");
sl@0	2857	if (file == NULL)
sl@0	2858	{
sl@0	2859	res = KErrGeneral;
sl@0	2860	}
sl@0	2861	err = gzrewind(file);
sl@0	2862
sl@0	2863	if(err == 0)
sl@0	2864	{
sl@0	2865	res = KErrNone ;
sl@0	2866	}
sl@0	2867	else
sl@0	2868	{
sl@0	2869	res = KErrGeneral;
sl@0	2870	}
sl@0	2871	err= gzclose(file);
sl@0	2872	if (err != Z_OK)
sl@0	2873	{
sl@0	2874	res = KErrGeneral;
sl@0	2875	}
sl@0	2876
sl@0	2877	return res;
sl@0	2878	}
sl@0	2879
sl@0	2880	/**
sl@0	2881	* Function Name : TestGzrewindFileNull
sl@0	2882	* TestCase Description: Pass NULL to gzrewind
sl@0	2883	*/
sl@0	2884	TInt CTestZlib::TestGzrewindFileNull()
sl@0	2885	{
sl@0	2886	TInt res = KErrNone ;
sl@0	2887	int err;
sl@0	2888	int len = (int)strlen(hello)+1;
sl@0	2889	gzFile file;
sl@0	2890
sl@0	2891	const char * fname = TESTFILE;
sl@0	2892	file = gzopen(fname, "rb");
sl@0	2893	if (file == NULL)
sl@0	2894	{
sl@0	2895	res = KErrGeneral;
sl@0	2896	}
sl@0	2897	err = gzrewind(NULL);
sl@0	2898
sl@0	2899	if(err == Z_ERRNO)
sl@0	2900	{
sl@0	2901	res = KErrNone ;
sl@0	2902	}
sl@0	2903	else
sl@0	2904	{
sl@0	2905	res = KErrGeneral;
sl@0	2906	}
sl@0	2907	err= gzclose(file);
sl@0	2908	if (err != Z_OK)
sl@0	2909	{
sl@0	2910	res = KErrGeneral;
sl@0	2911	}
sl@0	2912
sl@0	2913	return res;
sl@0	2914	}
sl@0	2915
sl@0	2916	/**
sl@0	2917	* Function Name : TestGzflushWithZFinish
sl@0	2918	* TestCase Description: Flush with flush = Z_FINISH
sl@0	2919	*/
sl@0	2920	TInt CTestZlib::TestGzflushWithZFinish()
sl@0	2921	{
sl@0	2922	TInt res = KErrNone ;
sl@0	2923	gzFile file;
sl@0	2924
sl@0	2925	const char * fname = TESTFILE ;
sl@0	2926	file = gzopen(fname, "wb");
sl@0	2927	if (file == Z_NULL)
sl@0	2928	{
sl@0	2929	res = KErrNoMemory;
sl@0	2930	return res;
sl@0	2931	}
sl@0	2932	int l= gzflush(file,Z_FINISH);
sl@0	2933	if(l != Z_OK)
sl@0	2934	{
sl@0	2935	res = KErrGeneral;
sl@0	2936	}
sl@0	2937
sl@0	2938	l = gzclose(file);
sl@0	2939	if (l != Z_OK)
sl@0	2940	{
sl@0	2941	res = KErrGeneral;
sl@0	2942	}
sl@0	2943	return res;
sl@0	2944	}
sl@0	2945
sl@0	2946	/**
sl@0	2947	* Function Name : TestUncompressLenSmall
sl@0	2948	* TestCase Description: Supply uncompress length smaller than compress length
sl@0	2949	* Return value: Z_BUF_ERROR
sl@0	2950	*/
sl@0	2951	TInt CTestZlib::TestUncompressLenSmall()
sl@0	2952	{
sl@0	2953	TInt res = KErrNone;
sl@0	2954	TInt err=0;
sl@0	2955	Byte compr, uncompr;
sl@0	2956	uLong len = (uLong)strlen(hello)+1;
sl@0	2957
sl@0	2958	uLong comprLen = 20*sizeof(int);
sl@0	2959	uLong uncomprLen = 3*sizeof(int);
sl@0	2960	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2961	if (compr == Z_NULL)
sl@0	2962	{
sl@0	2963	return KErrNoMemory;
sl@0	2964	}
sl@0	2965
sl@0	2966	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2967	if (uncompr == Z_NULL)
sl@0	2968	{
sl@0	2969	free(compr);
sl@0	2970	return KErrNoMemory;
sl@0	2971	}
sl@0	2972
sl@0	2973	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	2974	if(err == 0)
sl@0	2975	{
sl@0	2976	strcpy((char*)uncompr, "garbage");
sl@0	2977	err = uncompress(uncompr, &uncomprLen, compr, comprLen);
sl@0	2978	if(err == Z_BUF_ERROR)
sl@0	2979	{
sl@0	2980	res = KErrNone ;
sl@0	2981	}
sl@0	2982	else
sl@0	2983	{
sl@0	2984	res = KErrGeneral;
sl@0	2985	}
sl@0	2986	}
sl@0	2987
sl@0	2988	free(compr);
sl@0	2989	free(uncompr);
sl@0	2990	return res;
sl@0	2991	}
sl@0	2992
sl@0	2993	/**
sl@0	2994	* Function Name : TestUncompressBufNull
sl@0	2995	* TestCase Description: Supply NULL string to uncompress
sl@0	2996	* Return value: Z_STREAM_ERROR
sl@0	2997	*/
sl@0	2998	TInt CTestZlib::TestUncompressBufNull()
sl@0	2999	{
sl@0	3000	TInt res = KErrNone;
sl@0	3001	TInt err=0;
sl@0	3002	Byte compr, uncompr;
sl@0	3003	uLong len = (uLong)strlen(hello)+1;
sl@0	3004
sl@0	3005	uLong comprLen = 20*sizeof(int);
sl@0	3006	uLong uncomprLen = 3*sizeof(int);
sl@0	3007	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3008	if (compr == Z_NULL)
sl@0	3009	{
sl@0	3010	return KErrNoMemory;
sl@0	3011	}
sl@0	3012
sl@0	3013	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3014	if (uncompr == Z_NULL)
sl@0	3015	{
sl@0	3016	free(compr);
sl@0	3017	return KErrNoMemory;
sl@0	3018	}
sl@0	3019
sl@0	3020	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	3021	if(err == 0)
sl@0	3022	{
sl@0	3023	strcpy((char*)uncompr, "garbage");
sl@0	3024	err = uncompress(uncompr, &uncomprLen, Z_NULL, comprLen);
sl@0	3025	if(err == Z_STREAM_ERROR)
sl@0	3026	{
sl@0	3027	res = KErrNone ;
sl@0	3028	}
sl@0	3029	else
sl@0	3030	{
sl@0	3031	res = KErrGeneral;
sl@0	3032	}
sl@0	3033
sl@0	3034	}
sl@0	3035
sl@0	3036	free(compr);
sl@0	3037	free(uncompr);
sl@0	3038	return res;
sl@0	3039	}
sl@0	3040
sl@0	3041	/**
sl@0	3042	* Function Name : TestUncompressLenNull
sl@0	3043	* TestCase Description: Supply uncompress length=0
sl@0	3044	* Return value: Z_DATA_ERROR
sl@0	3045	*/
sl@0	3046	TInt CTestZlib::TestUncompressLenNull()
sl@0	3047	{
sl@0	3048	TInt res = KErrNone;
sl@0	3049	TInt err=0;
sl@0	3050	Byte compr, uncompr;
sl@0	3051	uLong len = (uLong)strlen(hello)+1;
sl@0	3052
sl@0	3053	uLong comprLen = 20*sizeof(int);
sl@0	3054	uLong uncomprLen = 3*sizeof(int);
sl@0	3055	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3056	if (compr == Z_NULL)
sl@0	3057	{
sl@0	3058	return KErrNoMemory;
sl@0	3059	}
sl@0	3060
sl@0	3061	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3062	if (uncompr == Z_NULL)
sl@0	3063	{
sl@0	3064	free(compr);
sl@0	3065	return KErrNoMemory;
sl@0	3066	}
sl@0	3067
sl@0	3068	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	3069	if(err == 0)
sl@0	3070	{
sl@0	3071	strcpy((char*)uncompr, "garbage");
sl@0	3072	err = uncompress(uncompr, &uncomprLen, compr, 0);
sl@0	3073	if(err == Z_DATA_ERROR)
sl@0	3074	{
sl@0	3075	res = KErrNone ;
sl@0	3076	}
sl@0	3077	else
sl@0	3078	{
sl@0	3079	res = KErrGeneral;
sl@0	3080	}
sl@0	3081	}
sl@0	3082
sl@0	3083	free(compr);
sl@0	3084	free(uncompr);
sl@0	3085	return res;
sl@0	3086	}
sl@0	3087
sl@0	3088
sl@0	3089	/**
sl@0	3090	* Function Name : TestInflateScenarios
sl@0	3091	* TestCase Description: 1. Pass Windowbits = 15 for inflateInit2_, Z_SYNC_FLUSH for inflate
sl@0	3092	* 2. Pass Windowbits = -15 for inflateInit2_, Z_SYNC_FLUSH for inflate
sl@0	3093	* 3. Pass Windowbits = 29 for inflateInit2_, Z_BLOCK for inflate
sl@0	3094	* Return Value: Z_OK
sl@0	3095	*/
sl@0	3096	TInt CTestZlib::TestInflateScenarios()
sl@0	3097	{
sl@0	3098	TInt res = KErrNone ;
sl@0	3099	TInt WindowBits = 0;
sl@0	3100	TInt flush=0;
sl@0	3101	Byte compr, uncompr;
sl@0	3102	uLong comprLen = 20*sizeof(int);
sl@0	3103	uLong uncomprLen = comprLen;
sl@0	3104	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3105	if (compr == Z_NULL)
sl@0	3106	{
sl@0	3107	return KErrNoMemory;
sl@0	3108	}
sl@0	3109	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3110	if (uncompr == Z_NULL)
sl@0	3111	{
sl@0	3112	free(compr);
sl@0	3113	return KErrNoMemory;
sl@0	3114	}
sl@0	3115	res = Test_deflate(compr, comprLen);
sl@0	3116	if(res<0)
sl@0	3117	{
sl@0	3118	free(compr);
sl@0	3119	free(uncompr);
sl@0	3120	return KErrNoMemory;
sl@0	3121	}
sl@0	3122
sl@0	3123	int err=0;
sl@0	3124	z_stream d_stream; /* decompression stream */
sl@0	3125
sl@0	3126	strcpy((char*)uncompr, "garbage");
sl@0	3127
sl@0	3128	d_stream.zalloc = (alloc_func)0;
sl@0	3129	d_stream.zfree = (free_func)0;
sl@0	3130	d_stream.opaque = (voidpf)0;
sl@0	3131
sl@0	3132	d_stream.next_in = compr;
sl@0	3133	d_stream.avail_in = 0;
sl@0	3134	d_stream.next_out = uncompr;
sl@0	3135
sl@0	3136	ReadIntParam(WindowBits);
sl@0	3137	res = inflateInit2_(&d_stream, WindowBits, "1.2.4", sizeof(d_stream));
sl@0	3138
sl@0	3139	if(res<0)
sl@0	3140	{
sl@0	3141	free(compr);
sl@0	3142	free(uncompr);
sl@0	3143	return KErrNoMemory;
sl@0	3144	}
sl@0	3145
sl@0	3146	ReadIntParam(flush);
sl@0	3147	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	3148	{
sl@0	3149	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
sl@0	3150	err = inflate(&d_stream, flush);
sl@0	3151
sl@0	3152	if (err == Z_STREAM_END \|\| err == Z_MEM_ERROR \|\| err == Z_DATA_ERROR) break;
sl@0	3153	}
sl@0	3154	if(err == Z_MEM_ERROR)
sl@0	3155	{
sl@0	3156	err = inflateEnd(&d_stream);
sl@0	3157	free(compr);
sl@0	3158	free(uncompr);
sl@0	3159
sl@0	3160	return err;
sl@0	3161	}
sl@0	3162
sl@0	3163	err = inflateEnd(&d_stream);
sl@0	3164	if (err != Z_OK)
sl@0	3165	{
sl@0	3166	res = KErrGeneral;
sl@0	3167	}
sl@0	3168	else
sl@0	3169	{
sl@0	3170	res=KErrNone ;
sl@0	3171	}
sl@0	3172	free(compr);
sl@0	3173	free(uncompr);
sl@0	3174	return res;
sl@0	3175
sl@0	3176	}
sl@0	3177
sl@0	3178
sl@0	3179	/**
sl@0	3180	* Function Name : TestInflateStreamStateNull
sl@0	3181	* TestCase Description: Make stream.state = NULL and call inflate
sl@0	3182	* Return Value: Z_STREAM_ERROR
sl@0	3183	*/
sl@0	3184	TInt CTestZlib::TestInflateStreamStateNull()
sl@0	3185	{
sl@0	3186	TInt res = KErrNone ;
sl@0	3187	Byte compr, uncompr;
sl@0	3188	uLong comprLen = 20*sizeof(int);
sl@0	3189	uLong uncomprLen = comprLen;
sl@0	3190	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3191	if (compr == Z_NULL)
sl@0	3192	{
sl@0	3193	return KErrNoMemory;
sl@0	3194	}
sl@0	3195	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3196	if (uncompr == Z_NULL)
sl@0	3197	{
sl@0	3198	free(compr);
sl@0	3199	return KErrNoMemory;
sl@0	3200	}
sl@0	3201	res = Test_deflate(compr, comprLen);
sl@0	3202	if(res<0)
sl@0	3203	{
sl@0	3204	free(compr);
sl@0	3205	free(uncompr);
sl@0	3206	return KErrNoMemory;
sl@0	3207	}
sl@0	3208
sl@0	3209	int err=0;
sl@0	3210	z_stream d_stream; /* decompression stream */
sl@0	3211
sl@0	3212	strcpy((char*)uncompr, "garbage");
sl@0	3213
sl@0	3214	d_stream.zalloc = (alloc_func)0;
sl@0	3215	d_stream.zfree = (free_func)0;
sl@0	3216	d_stream.opaque = (voidpf)0;
sl@0	3217
sl@0	3218	d_stream.next_in = compr;
sl@0	3219	d_stream.avail_in = 0;
sl@0	3220	d_stream.next_out = uncompr;
sl@0	3221
sl@0	3222	res = inflateInit2_(&d_stream, 15, "1.2.4", sizeof(d_stream));
sl@0	3223
sl@0	3224	if(res<0)
sl@0	3225	{
sl@0	3226	free(compr);
sl@0	3227	free(uncompr);
sl@0	3228	return KErrNoMemory;
sl@0	3229	}
sl@0	3230
sl@0	3231	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	3232	{
sl@0	3233	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
sl@0	3234	err = inflate(&d_stream, Z_SYNC_FLUSH);
sl@0	3235
sl@0	3236	if (err == Z_STREAM_END \|\| err == Z_STREAM_ERROR \|\| err == Z_MEM_ERROR) break;
sl@0	3237	}
sl@0	3238
sl@0	3239	if(err == Z_STREAM_ERROR)
sl@0	3240	{
sl@0	3241	res=KErrNone;
sl@0	3242	}
sl@0	3243	err = inflateEnd(&d_stream);
sl@0	3244	if (err == Z_STREAM_ERROR)
sl@0	3245	{
sl@0	3246	res=KErrNone;
sl@0	3247	}
sl@0	3248
sl@0	3249	d_stream.state = Z_NULL;
sl@0	3250	err = inflate(&d_stream, Z_SYNC_FLUSH);
sl@0	3251	if (err == Z_STREAM_ERROR)
sl@0	3252	{
sl@0	3253	res = KErrNone;
sl@0	3254	}
sl@0	3255
sl@0	3256	free(compr);
sl@0	3257	free(uncompr);
sl@0	3258	return res;
sl@0	3259	}
sl@0	3260
sl@0	3261	/**
sl@0	3262	* Function Name : TestInflateResetStreamStateNull
sl@0	3263	* TestCase Description: Make stream.state = NULL and call inflateReset
sl@0	3264	* Return Value: Z_STREAM_ERROR
sl@0	3265	*/
sl@0	3266	TInt CTestZlib::TestInflateResetStreamStateNull()
sl@0	3267	{
sl@0	3268	TInt res=KErrNone;
sl@0	3269	z_stream d_stream; /* decompression stream */
sl@0	3270	const char * version;
sl@0	3271	d_stream.zalloc = (alloc_func)0;
sl@0	3272	d_stream.zfree = (free_func)0;
sl@0	3273	d_stream.opaque = (voidpf)0;
sl@0	3274
sl@0	3275	Byte compr, uncompr;
sl@0	3276	uLong comprLen = 20*sizeof(int);
sl@0	3277	uLong uncomprLen = comprLen;
sl@0	3278	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3279	if (compr == Z_NULL)
sl@0	3280	{
sl@0	3281	return KErrNoMemory;
sl@0	3282	}
sl@0	3283	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3284	if (uncompr == Z_NULL)
sl@0	3285	{
sl@0	3286	free(compr);
sl@0	3287	return KErrNoMemory;
sl@0	3288	}
sl@0	3289
sl@0	3290	res = Test_deflate(compr, comprLen);
sl@0	3291	if(res<0)
sl@0	3292	{
sl@0	3293	free(compr);
sl@0	3294	free(uncompr);
sl@0	3295	return KErrNoMemory;
sl@0	3296	}
sl@0	3297	d_stream.next_in = compr;
sl@0	3298	d_stream.avail_in = 0;
sl@0	3299	d_stream.next_out = uncompr;
sl@0	3300	version=zlibVersion();
sl@0	3301	int err;
sl@0	3302	err = inflateInit_(&d_stream,(char*)version, sizeof(d_stream));
sl@0	3303
sl@0	3304	if(err<0)
sl@0	3305	{
sl@0	3306	free(compr);
sl@0	3307	free(uncompr);
sl@0	3308	return KErrNoMemory;
sl@0	3309	}
sl@0	3310
sl@0	3311	err=inflateReset(&d_stream);
sl@0	3312	err=inflateEnd(&d_stream);
sl@0	3313	free(compr);
sl@0	3314	free(uncompr);
sl@0	3315
sl@0	3316	// for coverage improvement
sl@0	3317	d_stream.state = Z_NULL;
sl@0	3318	err=inflateReset(&d_stream);
sl@0	3319
sl@0	3320	if(err == Z_STREAM_ERROR)
sl@0	3321	{
sl@0	3322	res = KErrNone;
sl@0	3323	}
sl@0	3324	else
sl@0	3325	{
sl@0	3326	res = KErrGeneral;
sl@0	3327	}
sl@0	3328	return res;
sl@0	3329	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--