Symaptic: os/ossrv/compressionlibs/ziplib/test/tef/tlibz/src/tzlib

sl@0	1	/*
sl@0	2	* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
sl@0	3	* All rights reserved.
sl@0	4	* This component and the accompanying materials are made available
sl@0	5	* under the terms of "Eclipse Public License v1.0"
sl@0	6	* which accompanies this distribution, and is available
sl@0	7	* at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	8	*
sl@0	9	* Initial Contributors:
sl@0	10	* Nokia Corporation - initial contribution.
sl@0	11	*
sl@0	12	* Contributors:
sl@0	13	*
sl@0	14	* Description:
sl@0	15	*
sl@0	16	*/
sl@0	17
sl@0	18
sl@0	19	#include "tzlib.h"
sl@0	20
sl@0	21	/**
sl@0	22	* Function Name : TestAdlerinit
sl@0	23	* TestCase Description: Testing Adler
sl@0	24	* Return Value: Return KErrNone if adler32=1, else return KErrGeneral
sl@0	25	*/
sl@0	26	TInt CTestZlib::TestAdlerinit()
sl@0	27	{
sl@0	28	TInt res = KErrNone ;
sl@0	29	unsigned long j=0L;
sl@0	30
sl@0	31	long adler1 = adler32(j,0, 0);
sl@0	32	if(adler1 == 1)
sl@0	33	{
sl@0	34	res=KErrNone ;
sl@0	35	}
sl@0	36	else
sl@0	37	{
sl@0	38	res = KErrGeneral;
sl@0	39	}
sl@0	40	return res;
sl@0	41	}
sl@0	42
sl@0	43	/**
sl@0	44	* Function Name : TestAdler
sl@0	45	* TestCase Description: Testing Adler32
sl@0	46	* Return Value: Return KErrNone if adler32>0, else return KErrGeneral
sl@0	47	*/
sl@0	48	TInt CTestZlib::TestAdler()
sl@0	49	{
sl@0	50	TInt res = KErrNone ;
sl@0	51	unsigned char buffer[5]="1234";
sl@0	52	unsigned int i=4;
sl@0	53	unsigned long j=0L;
sl@0	54
sl@0	55	long adler1 = adler32(j,0, 0);
sl@0	56	long adler = adler32(adler1, &buffer[0], i);
sl@0	57	INFO_PRINTF2(_L("buf %x"),adler);
sl@0	58
sl@0	59	if(adler > 0)
sl@0	60	{
sl@0	61	res=KErrNone ;
sl@0	62	}
sl@0	63	else
sl@0	64	{
sl@0	65	res = KErrGeneral;
sl@0	66	}
sl@0	67	return res;
sl@0	68	}
sl@0	69
sl@0	70	/**
sl@0	71	* Function Name : TestDeflateReset
sl@0	72	* TestCase Description: Call deflateReset after deflateInit
sl@0	73	* Return Value: Returns KErrNone on deflateReset returning Z_OK, else KErrGeneral
sl@0	74	*/
sl@0	75	TInt CTestZlib::TestDeflateReset()
sl@0	76	{
sl@0	77	INFO_PRINTF1(_L("DeflateReset test with valid input"));
sl@0	78	TInt res = KErrNone ;
sl@0	79	int level = Z_DEFAULT_COMPRESSION ;
sl@0	80	uLong len = (uLong)strlen(hello)+1;
sl@0	81	Byte compr, uncompr;
sl@0	82	uLong comprLen = 20*sizeof(int);
sl@0	83	uLong uncomprLen = comprLen;
sl@0	84	int err;
sl@0	85	z_stream stream;
sl@0	86	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	87	if (compr == Z_NULL)
sl@0	88	{
sl@0	89	return KErrNoMemory;
sl@0	90	}
sl@0	91	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	92	if (uncompr == Z_NULL)
sl@0	93	{
sl@0	94	free(compr);
sl@0	95	return KErrNoMemory;
sl@0	96	}
sl@0	97
sl@0	98	stream.zalloc = (alloc_func)0;
sl@0	99	stream.zfree = (free_func)0;
sl@0	100	stream.opaque = (voidpf)0;
sl@0	101
sl@0	102	err = deflateInit(&stream, level);
sl@0	103	if (err != Z_OK)
sl@0	104	{
sl@0	105	free(compr);
sl@0	106	free(uncompr);
sl@0	107	return KErrGeneral;
sl@0	108	}
sl@0	109
sl@0	110	Bytef *dest = compr ;
sl@0	111	uLongf *destLen = &comprLen;
sl@0	112	const Bytef source = (const Bytef)hello;
sl@0	113	uLong sourceLen = len;
sl@0	114
sl@0	115	stream.next_in = (Bytef*)source;
sl@0	116	stream.avail_in = (uInt)sourceLen;
sl@0	117	#ifdef MAXSEG_64K
sl@0	118	/* Check for source > 64K on 16-bit machine: */
sl@0	119	if ((uLong)stream.avail_in != sourceLen)
sl@0	120	{
sl@0	121	res = KErrGeneral;
sl@0	122	}
sl@0	123	#endif
sl@0	124	stream.next_out = dest;
sl@0	125	stream.avail_out = (uInt)*destLen;
sl@0	126	if ((uLong)stream.avail_out != *destLen)
sl@0	127	{
sl@0	128	res = KErrGeneral;
sl@0	129	}
sl@0	130	err=deflateReset(&stream);
sl@0	131	if (err != Z_OK)
sl@0	132	{
sl@0	133	res = KErrGeneral;
sl@0	134	}
sl@0	135	else
sl@0	136	{
sl@0	137	res = KErrNone;
sl@0	138	}
sl@0	139	err = deflateEnd(&stream);
sl@0	140	if (err != Z_OK)
sl@0	141	{
sl@0	142	INFO_PRINTF1(_L("Error in deflateEnd"));
sl@0	143	free(compr);
sl@0	144	free(uncompr);
sl@0	145	return KErrGeneral;
sl@0	146	}
sl@0	147	free(compr);
sl@0	148	free(uncompr);
sl@0	149	return res;
sl@0	150	}
sl@0	151
sl@0	152	/**
sl@0	153	* Function Name : TestDeflateReset_fail
sl@0	154	* TestCase Description: Call deflateReset before calling deflateInit
sl@0	155	* Return Value: Return KErrNone incase of deflateReset returning Z_STREAM_ERROR, else KErrGeneral
sl@0	156	*/
sl@0	157	TInt CTestZlib::TestDeflateReset_fail()
sl@0	158	{
sl@0	159	TInt res = KErrNone ;
sl@0	160	uLong len = (uLong)strlen(hello)+1;
sl@0	161	Byte compr, uncompr;
sl@0	162	uLong comprLen = 20*sizeof(int);
sl@0	163	uLong uncomprLen = comprLen;
sl@0	164	int err;
sl@0	165	z_stream stream;
sl@0	166	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	167	if (compr == Z_NULL)
sl@0	168	{
sl@0	169	return KErrNoMemory;
sl@0	170	}
sl@0	171	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	172	if (uncompr == Z_NULL)
sl@0	173	{
sl@0	174	free(compr);
sl@0	175	return KErrNoMemory;
sl@0	176	}
sl@0	177
sl@0	178	stream.zalloc = (alloc_func)0;
sl@0	179	stream.zfree = (free_func)0;
sl@0	180	stream.opaque = (voidpf)0;
sl@0	181	err=deflateReset(&stream);
sl@0	182	if (err != Z_OK)
sl@0	183	{
sl@0	184	res = KErrNone;
sl@0	185	}
sl@0	186	else
sl@0	187	{
sl@0	188	res = KErrGeneral;
sl@0	189	}
sl@0	190	free(compr);
sl@0	191	free(uncompr);
sl@0	192	return res;
sl@0	193	}
sl@0	194
sl@0	195	/**
sl@0	196	* Function Name : TestDeflateInit2_bits
sl@0	197	* TestCase Description: Call deflateInit2_ with window bits = 15 as argument
sl@0	198	* Return Value: Return KErrNone if deflateInit2_ returns Z_OK
sl@0	199	*/
sl@0	200	TInt CTestZlib::TestDeflateInit2_bits()
sl@0	201	{
sl@0	202	TInt res = KErrNone ;
sl@0	203	z_stream stream;
sl@0	204	int err;
sl@0	205	int level=Z_DEFAULT_COMPRESSION;
sl@0	206
sl@0	207	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	208	Byte *compr;
sl@0	209	uLong comprLen = 10*sizeof(int);
sl@0	210	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	211	if (compr == Z_NULL)
sl@0	212	{
sl@0	213	return KErrNoMemory;
sl@0	214	}
sl@0	215	stream.zalloc = (alloc_func)0;
sl@0	216	stream.zfree = (free_func)0;
sl@0	217	stream.opaque = (voidpf)0;
sl@0	218
sl@0	219	err= deflateInit2_(&stream, level, 3, 15, 8, 0, zlibVersion(), sizeof(z_stream));
sl@0	220
sl@0	221	if (err != Z_OK)
sl@0	222	{
sl@0	223	res = KErrNone;
sl@0	224	}
sl@0	225	else
sl@0	226	{
sl@0	227	res = KErrGeneral;
sl@0	228	}
sl@0	229	free(compr);
sl@0	230	return res;
sl@0	231	}
sl@0	232
sl@0	233	/**
sl@0	234	* Function Name : TestDeflateInit2_level
sl@0	235	* TestCase Description: Call deflateInit2_ with window bits = 2 as argument
sl@0	236	* Return Value: Returns KErrNone on deflateInit2_ returning Z_OK
sl@0	237	*/
sl@0	238	TInt CTestZlib::TestDeflateInit2_level()
sl@0	239	{
sl@0	240	TInt res = KErrNone ;
sl@0	241	z_stream stream;
sl@0	242	int err;
sl@0	243	int level=Z_DEFAULT_COMPRESSION;
sl@0	244
sl@0	245	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	246	Byte *compr;
sl@0	247	uLong comprLen = 10*sizeof(int);
sl@0	248	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	249	if (compr == Z_NULL)
sl@0	250	{
sl@0	251	return KErrNoMemory;
sl@0	252	}
sl@0	253
sl@0	254	stream.zalloc = (alloc_func)0;
sl@0	255	stream.zfree = (free_func)0;
sl@0	256	stream.opaque = (voidpf)0;
sl@0	257
sl@0	258	err= deflateInit2_(&stream, level, 3, 2, 8,
sl@0	259	0, zlibVersion(), sizeof(z_stream));
sl@0	260
sl@0	261	if (err != Z_OK)
sl@0	262	{
sl@0	263	res = KErrNone;
sl@0	264	}
sl@0	265	else
sl@0	266	{
sl@0	267	res = KErrGeneral;
sl@0	268	}
sl@0	269	free(compr);
sl@0	270	return res;
sl@0	271	}
sl@0	272
sl@0	273	/**
sl@0	274	* Function Name : TestInflateInit2_bits
sl@0	275	* TestCase Description: Call inflateInit2_ with window bits = 5 as argument
sl@0	276	* Return Value: Returns KErrNone on inflateInit2_ returning Z_OK
sl@0	277	*/
sl@0	278	TInt CTestZlib::TestInflateInit2_bits()
sl@0	279	{
sl@0	280	TInt res = KErrNone ;
sl@0	281	z_stream d_stream; // decompression stream
sl@0	282	const char * version;
sl@0	283	d_stream.zalloc = (alloc_func)0;
sl@0	284	d_stream.zfree = (free_func)0;
sl@0	285	d_stream.opaque = (voidpf)0;
sl@0	286
sl@0	287	version = zlibVersion();
sl@0	288	int ret = inflateInit2_(&d_stream,5,version, sizeof(d_stream));
sl@0	289	if(ret==0)
sl@0	290	{
sl@0	291	res = KErrGeneral;
sl@0	292	}
sl@0	293	else
sl@0	294	{
sl@0	295	res = KErrNone;
sl@0	296	}
sl@0	297	return res;
sl@0	298	}
sl@0	299
sl@0	300	/**
sl@0	301	* Function Name : TestGzread
sl@0	302	* TestCase Description: 1. Open a gz file in read mode
sl@0	303	* 2. gzRead from the opened file. Reads the given number of uncompressed bytes from the compressed file.
sl@0	304	* 3. close the gz file
sl@0	305	* Return Value: Returns KErrNone on reading the gzfile successfully
sl@0	306	*/
sl@0	307	TInt CTestZlib::TestGzread()
sl@0	308	{
sl@0	309	char * buf1 = (char*)malloc(1024);
sl@0	310	if (buf1 == NULL)
sl@0	311	{
sl@0	312	ERR_PRINTF1(_L("Heap out of memory"));
sl@0	313	return KErrNoMemory;
sl@0	314	}
sl@0	315
sl@0	316	int len1;
sl@0	317	TInt res = KErrNone ;
sl@0	318	char *file=FILETESTGZ;
sl@0	319	char *infile;
sl@0	320	gzFile in;
sl@0	321	infile = file;
sl@0	322	in = gzopen(infile, "rb");
sl@0	323	if (in == Z_NULL)
sl@0	324	{
sl@0	325	free(buf1);
sl@0	326	ERR_PRINTF1(_L("Could not open the file"));
sl@0	327	res = KErrGeneral;
sl@0	328	return res;
sl@0	329	}
sl@0	330	for (;;)
sl@0	331	{
sl@0	332	len1 = gzread(in, buf1, sizeof(buf1));
sl@0	333	if (len1 == 0 )
sl@0	334	break;
sl@0	335	else if(len1 < 0 )
sl@0	336	{
sl@0	337	INFO_PRINTF1(_L("Error in reading the file"));
sl@0	338	free(buf1);
sl@0	339	return KErrGeneral;
sl@0	340	}
sl@0	341	}
sl@0	342	if (gzclose(in) != Z_OK)
sl@0	343	{
sl@0	344	ERR_PRINTF1(_L("Could not close the file"));
sl@0	345	res=KErrGeneral;
sl@0	346	}
sl@0	347	free(buf1);
sl@0	348	return res;
sl@0	349	}
sl@0	350
sl@0	351	/**
sl@0	352	* Function Name : TestGzread_fail
sl@0	353	* TestCase Description: 1. Open a gz file in write mode
sl@0	354	* 2. gzRead from the file.
sl@0	355	* 3. close the file
sl@0	356	* Return Value: Returns KErrNone on gzread returning -1
sl@0	357	*/
sl@0	358	TInt CTestZlib::TestGzread_fail()
sl@0	359	{
sl@0	360	char * buf1 = (char*)malloc(1024);
sl@0	361	if(buf1==NULL)
sl@0	362	{
sl@0	363	return KErrNoMemory;
sl@0	364	}
sl@0	365	int len1;
sl@0	366	TInt res = KErrNone ;
sl@0	367	gzFile in = Z_NULL;
sl@0	368	in = gzopen(FILETESTGZ1, "wb");
sl@0	369	res=(int)in;
sl@0	370	if (0 == res)
sl@0	371	{
sl@0	372	free(buf1);
sl@0	373	return KErrNoMemory;;
sl@0	374	}
sl@0	375
sl@0	376	len1 = gzread(in, buf1, sizeof(buf1));
sl@0	377	if (len1 < 0)
sl@0	378	{
sl@0	379	res = KErrNone;
sl@0	380	}
sl@0	381	else if (0 == len1)
sl@0	382	{
sl@0	383	res = KErrGeneral;
sl@0	384	}
sl@0	385
sl@0	386	if (gzclose(in) != Z_OK)
sl@0	387	{
sl@0	388	free(buf1);
sl@0	389	INFO_PRINTF1(_L("Error encountered while closing the file"));
sl@0	390	return KErrGeneral;
sl@0	391	}
sl@0	392
sl@0	393	free(buf1);
sl@0	394	return res;
sl@0	395	}
sl@0	396	/**
sl@0	397	* Function Name : test_uncompress
sl@0	398	* TestCase Description: This is a global function used by many test functions
sl@0	399	*/
sl@0	400	TInt test_uncompress(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen)
sl@0	401	{
sl@0	402	TInt res = KErrNone ;
sl@0	403	int err;
sl@0	404	uLong len = (uLong)strlen(hello)+1;
sl@0	405
sl@0	406	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	407
sl@0	408	if(err == 0)
sl@0	409	{
sl@0	410	strcpy((char*)uncompr, "garbage");
sl@0	411	err = uncompress(uncompr, &uncomprLen, compr, comprLen);
sl@0	412	if(err < Z_OK)
sl@0	413	{
sl@0	414	res = KErrGeneral ;
sl@0	415	}
sl@0	416	}
sl@0	417	else
sl@0	418	{
sl@0	419	res = KErrGeneral;
sl@0	420	}
sl@0	421
sl@0	422	return res;
sl@0	423	}
sl@0	424	/**
sl@0	425	* Function Name : TestUncompress
sl@0	426	* TestCase Description: 1. Compress a text sample
sl@0	427	* 2. Uncompress is called with appropriate lengths
sl@0	428	* for compressed and uncompressed data
sl@0	429	*
sl@0	430	* Return Value: Z_OK
sl@0	431	*/
sl@0	432	TInt CTestZlib::TestUncompress()
sl@0	433	{
sl@0	434	TInt res = KErrNone ;
sl@0	435	Byte compr, uncompr;
sl@0	436	uLong comprLen = 20*sizeof(int);
sl@0	437	uLong uncomprLen = comprLen;
sl@0	438	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	439	if (compr == Z_NULL)
sl@0	440	{
sl@0	441	return KErrNoMemory;
sl@0	442	}
sl@0	443	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	444	if (uncompr == Z_NULL)
sl@0	445	{
sl@0	446	free(compr);
sl@0	447	return KErrNoMemory;
sl@0	448	}
sl@0	449	res = test_uncompress(compr, comprLen, uncompr, uncomprLen);
sl@0	450	free(compr);
sl@0	451	free(uncompr);
sl@0	452	return res;
sl@0	453	}
sl@0	454
sl@0	455	/**
sl@0	456	* Function Name : TestUncompressfail
sl@0	457	* TestCase Description: 1. Uncompress is called with uncompressed length smaller than required
sl@0	458	*
sl@0	459	* Return Value: Z_BUF_ERROR
sl@0	460	*/
sl@0	461	TInt CTestZlib::TestUncompressfail()
sl@0	462	{
sl@0	463	TInt res = KErrNone ;
sl@0	464	Byte compr, uncompr;
sl@0	465	uLong comprLen = 1*sizeof(int);
sl@0	466	uLong uncomprLen = comprLen;
sl@0	467	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	468	if (compr == Z_NULL)
sl@0	469	{
sl@0	470	return Z_MEM_ERROR;
sl@0	471	}
sl@0	472	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	473	if (uncompr == Z_NULL)
sl@0	474	{
sl@0	475	free(compr);
sl@0	476	return KErrNoMemory;
sl@0	477	}
sl@0	478	int err = test_uncompress(compr, comprLen, uncompr, uncomprLen);
sl@0	479	if(err==0)
sl@0	480	{
sl@0	481	res = KErrGeneral;
sl@0	482	}
sl@0	483	free(compr);
sl@0	484	free(uncompr);
sl@0	485	return res;
sl@0	486	}
sl@0	487
sl@0	488	/**
sl@0	489	* Function Name : Test_dict_deflate
sl@0	490	* TestCase Description: This is a global function used by many test functions
sl@0	491	*/
sl@0	492	TInt CTestZlib::Test_dict_deflate( Byte * compr,uLong comprLen)
sl@0	493	{
sl@0	494	TInt res = KErrNone ;
sl@0	495	z_stream c_stream; /* compression stream */
sl@0	496	int err;
sl@0	497
sl@0	498	c_stream.zalloc = (alloc_func)0;
sl@0	499	c_stream.zfree = (free_func)0;
sl@0	500	c_stream.opaque = (voidpf)0;
sl@0	501
sl@0	502	err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
sl@0	503	if(err<0)
sl@0	504	{
sl@0	505	res = KErrGeneral;
sl@0	506	return res;
sl@0	507	}
sl@0	508
sl@0	509	err = deflateSetDictionary(&c_stream,
sl@0	510	(const Bytef*)dictionary, sizeof(dictionary));
sl@0	511	if(err<0)
sl@0	512	{
sl@0	513	res = KErrGeneral;
sl@0	514	return res;
sl@0	515	}
sl@0	516	dictId = c_stream.adler;
sl@0	517	c_stream.next_out = compr;
sl@0	518	c_stream.avail_out = (uInt)comprLen;
sl@0	519
sl@0	520	c_stream.next_in = (Bytef*)hello;
sl@0	521	c_stream.avail_in = (uInt)strlen(hello)+1;
sl@0	522
sl@0	523	err = deflate(&c_stream, Z_FINISH);
sl@0	524	if (err != Z_STREAM_END)
sl@0	525	{
sl@0	526	res = KErrGeneral;
sl@0	527	}
sl@0	528	err = deflateEnd(&c_stream);
sl@0	529	if (err != 0)
sl@0	530	{
sl@0	531	res = KErrGeneral;
sl@0	532	}
sl@0	533	return res;
sl@0	534	}
sl@0	535
sl@0	536
sl@0	537	/**
sl@0	538	* Function Name : Test_dict_inflate
sl@0	539	* TestCase Description: This is an utility function used by many test functions
sl@0	540	*/
sl@0	541	TInt CTestZlib::Test_dict_inflate(Byte * compr,uLong comprLen, Byte * uncompr,uLong uncomprLen)
sl@0	542	{
sl@0	543	TInt res = KErrNone ;
sl@0	544	int err;
sl@0	545	z_stream d_stream; /* decompression stream */
sl@0	546
sl@0	547	strcpy((char*)uncompr, "garbage");
sl@0	548
sl@0	549	d_stream.zalloc = (alloc_func)0;
sl@0	550	d_stream.zfree = (free_func)0;
sl@0	551	d_stream.opaque = (voidpf)0;
sl@0	552
sl@0	553	d_stream.next_in = compr;
sl@0	554	d_stream.avail_in = (uInt)comprLen;
sl@0	555
sl@0	556	err = inflateInit(&d_stream);
sl@0	557	if(Z_MEM_ERROR == err)
sl@0	558	{
sl@0	559	return Z_MEM_ERROR;
sl@0	560	}
sl@0	561	else if(Z_VERSION_ERROR == err)
sl@0	562	{
sl@0	563	return Z_VERSION_ERROR;
sl@0	564	}
sl@0	565
sl@0	566	d_stream.next_out = uncompr;
sl@0	567	d_stream.avail_out = (uInt)uncomprLen;
sl@0	568
sl@0	569	for (;;)
sl@0	570	{
sl@0	571	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	572	if (err == Z_NEED_DICT)
sl@0	573	{
sl@0	574	if (d_stream.adler != dictId)
sl@0	575	{
sl@0	576	break;
sl@0	577	}
sl@0	578	err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
sl@0	579	sizeof(dictionary));
sl@0	580	if(err < Z_OK)
sl@0	581	{
sl@0	582	INFO_PRINTF1(_L("Error returned by inflateSetDictionary"));
sl@0	583	break;
sl@0	584	}
sl@0	585	}
sl@0	586	else
sl@0	587	{
sl@0	588	break;
sl@0	589	}
sl@0	590	} // end of for
sl@0	591
sl@0	592	err = inflateEnd(&d_stream);
sl@0	593	if (strcmp((char*)uncompr, hello))
sl@0	594	{
sl@0	595	INFO_PRINTF1(_L("Bad inflate with dictionary"));
sl@0	596	res = KErrGeneral;
sl@0	597	}
sl@0	598	else
sl@0	599	{
sl@0	600	INFO_PRINTF1(_L("Inflate with dictionary successful"));
sl@0	601	}
sl@0	602	return res;
sl@0	603	}
sl@0	604
sl@0	605	/**
sl@0	606	* Function Name : TestInflateSetDictionary
sl@0	607	* TestCase Description: 1. Deflate string using an existing dictionary
sl@0	608	* 2. Uncompress the compressed text using an existing dictionary
sl@0	609	* Return Value: Z_BUF_ERROR
sl@0	610	*/
sl@0	611	TInt CTestZlib::TestInflateSetDictionary()
sl@0	612	{
sl@0	613	TInt res = KErrNone ;
sl@0	614	Byte compr, uncompr;
sl@0	615	uLong comprLen = 100*sizeof(int);
sl@0	616	uLong uncomprLen = comprLen;
sl@0	617
sl@0	618	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	619	if (compr == NULL)
sl@0	620	{
sl@0	621	return KErrNoMemory;
sl@0	622	}
sl@0	623	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	624	if (uncompr == Z_NULL)
sl@0	625	{
sl@0	626	free(compr);
sl@0	627	return KErrNoMemory;
sl@0	628	}
sl@0	629	res = Test_dict_deflate(compr, comprLen);
sl@0	630	if(res < 0)
sl@0	631	{
sl@0	632	free(compr);
sl@0	633	free(uncompr);
sl@0	634	return res;
sl@0	635	}
sl@0	636	if(res==0)
sl@0	637	{
sl@0	638	res=Test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
sl@0	639	}
sl@0	640	else
sl@0	641	{
sl@0	642	res=KErrGeneral;
sl@0	643	}
sl@0	644	free(compr);
sl@0	645	free(uncompr);
sl@0	646	return res;
sl@0	647	}
sl@0	648
sl@0	649
sl@0	650	/**
sl@0	651	* Function Name : TestInflateSetDictionary_size
sl@0	652	* TestCase Description: 1. Deflate string using an existing dictionary
sl@0	653	* 2. Uncompress the compresses text using a mismatching dictionary
sl@0	654	* Return Value: Z_DATA_ERROR
sl@0	655	*/
sl@0	656	TInt CTestZlib::TestInflateSetDictionary_size()
sl@0	657	{
sl@0	658
sl@0	659	TInt res=KErrNone;
sl@0	660	Byte compr, uncompr;
sl@0	661	uLong comprLen = 20*sizeof(int);
sl@0	662	uLong uncomprLen = comprLen;
sl@0	663	z_stream d_stream; /* decompression stream */
sl@0	664
sl@0	665	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	666	if (compr == Z_NULL)
sl@0	667	{
sl@0	668	return KErrNoMemory;
sl@0	669	}
sl@0	670	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	671	if (uncompr == Z_NULL)
sl@0	672	{
sl@0	673	free(compr);
sl@0	674	return KErrNoMemory;
sl@0	675	}
sl@0	676
sl@0	677	res = Test_dict_deflate(compr, comprLen);
sl@0	678	if(res<0)
sl@0	679	{
sl@0	680	res=KErrGeneral;
sl@0	681	free(compr);
sl@0	682	free(uncompr);
sl@0	683	return res;
sl@0	684	}
sl@0	685	strcpy((char*)uncompr, "garbage");
sl@0	686
sl@0	687	d_stream.zalloc = (alloc_func)0;
sl@0	688	d_stream.zfree = (free_func)0;
sl@0	689	d_stream.opaque = (voidpf)0;
sl@0	690
sl@0	691	d_stream.next_in = compr;
sl@0	692	d_stream.avail_in = (uInt)comprLen;
sl@0	693
sl@0	694	int err = inflateInit(&d_stream);
sl@0	695
sl@0	696	d_stream.next_out = uncompr;
sl@0	697	d_stream.avail_out = (uInt)uncomprLen;
sl@0	698
sl@0	699	for (;;)
sl@0	700	{
sl@0	701	int err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	702	if (err == Z_STREAM_END \|\| err == Z_MEM_ERROR) break;
sl@0	703	err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,sizeof(dictionary)+2);
sl@0	704	if(Z_DATA_ERROR == err)
sl@0	705	{
sl@0	706	res=KErrNone;
sl@0	707	break;
sl@0	708	}
sl@0	709	else
sl@0	710	{
sl@0	711	res=KErrGeneral;
sl@0	712	break;
sl@0	713	}
sl@0	714	}
sl@0	715	err = inflateEnd(&d_stream);
sl@0	716	if(err != Z_OK)
sl@0	717	{
sl@0	718	INFO_PRINTF1(_L("InflateEnd failed"));
sl@0	719	free(compr);
sl@0	720	free(uncompr);
sl@0	721	return KErrGeneral;
sl@0	722	}
sl@0	723
sl@0	724	free(compr);
sl@0	725	free(uncompr);
sl@0	726	return res;
sl@0	727	}
sl@0	728
sl@0	729	/**
sl@0	730	* Function Name : TestInflateSetDictionary_null
sl@0	731	* TestCase Description: 1. Deflate string using an existing dictionary
sl@0	732	* 2. Pass null pointer to inflateSetDictionary
sl@0	733	* Return Value: Z_DATA_ERROR
sl@0	734	*/
sl@0	735	TInt CTestZlib::TestInflateSetDictionary_null()
sl@0	736	{
sl@0	737	TInt res=KErrNone;
sl@0	738	Byte compr, uncompr;
sl@0	739	uLong comprLen = 20*sizeof(int);
sl@0	740	uLong uncomprLen = comprLen;
sl@0	741
sl@0	742	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	743	if (compr == Z_NULL)
sl@0	744	{
sl@0	745	return KErrNoMemory;
sl@0	746	}
sl@0	747	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	748	if (uncompr == Z_NULL)
sl@0	749	{
sl@0	750	free(compr);
sl@0	751	return KErrNoMemory;
sl@0	752	}
sl@0	753
sl@0	754	res= Test_dict_deflate(compr, comprLen);
sl@0	755	if(res == KErrGeneral)
sl@0	756	{
sl@0	757	free(compr);
sl@0	758	free(uncompr);
sl@0	759	return res;
sl@0	760	}
sl@0	761	int err = inflateSetDictionary(NULL, (const Bytef*)dictionary,sizeof(dictionary));
sl@0	762	if(err != Z_STREAM_ERROR)
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 : test_compress
sl@0	773	* TestCase Description: This is a global function used by many test functions
sl@0	774	*/
sl@0	775	TInt test_compress(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen)
sl@0	776	{
sl@0	777	int err = KErrNone;
sl@0	778	uLong len = (uLong)strlen(hello)+1;
sl@0	779
sl@0	780	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	781
sl@0	782	if(err<0)
sl@0	783	{
sl@0	784	return err;
sl@0	785	}
sl@0	786	strcpy((char*)uncompr, "garbage");
sl@0	787
sl@0	788	err = uncompress(uncompr, &uncomprLen, compr, comprLen);
sl@0	789
sl@0	790	if(err<0)
sl@0	791	{
sl@0	792	return err;
sl@0	793	}
sl@0	794	if (strcmp((char*)uncompr, hello))
sl@0	795	{
sl@0	796	//INFO_PRINTF1(_L("Uncompressed string does not match with original string"));
sl@0	797	err = KErrGeneral;
sl@0	798	}
sl@0	799	else
sl@0	800	{
sl@0	801	err=0;
sl@0	802	}
sl@0	803	return err;
sl@0	804	}
sl@0	805
sl@0	806	/**
sl@0	807	* Function Name : test_gzgets
sl@0	808	* TestCase Description: This is a global function used by many test functions
sl@0	809	*/
sl@0	810	int test_gzgets(const char * fname, Byte * uncompr,uLong uncomprLen)
sl@0	811	{
sl@0	812	int err = KErrNone;
sl@0	813	int len = (int)strlen(hello)+1;
sl@0	814	gzFile file;
sl@0	815
sl@0	816	file = gzopen(fname, "wb");
sl@0	817	if (file == NULL)
sl@0	818	{
sl@0	819	err = KErrGeneral;
sl@0	820	return err;
sl@0	821	}
sl@0	822	gzputc(file, 'h');
sl@0	823	if (gzputs(file, "ello") != 4)
sl@0	824	{
sl@0	825	err=1;
sl@0	826	}
sl@0	827	if (gzprintf(file, ", %s!", "hello") != 8)
sl@0	828	{
sl@0	829	err=1;
sl@0	830	}
sl@0	831	err = gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
sl@0	832	if (err < 0)
sl@0	833	{
sl@0	834	//INFO_PRINTF1(_L("Error returned by gzssek"));
sl@0	835	}
sl@0	836	gzclose(file);
sl@0	837
sl@0	838	file = gzopen(fname, "rb");
sl@0	839	if (file == NULL)
sl@0	840	{
sl@0	841	err = KErrGeneral;
sl@0	842	return err;
sl@0	843	}
sl@0	844	strcpy((char*)uncompr, "garbage");
sl@0	845	if (gzread(file, uncompr, (unsigned)uncomprLen) != len)
sl@0	846	{
sl@0	847	}
sl@0	848	if (strcmp((char*)uncompr, hello))
sl@0	849	{
sl@0	850	err=0;
sl@0	851	}
sl@0	852	else
sl@0	853	{
sl@0	854	err=1;
sl@0	855	}
sl@0	856
sl@0	857	err = gzseek(file, -8L, SEEK_CUR);
sl@0	858	if (err < 0)
sl@0	859	{
sl@0	860	//INFO_PRINTF1(_L("Error returned by gzssek"));
sl@0	861	}
sl@0	862	gzgets(file, (char*)uncompr, (int)uncomprLen);
sl@0	863
sl@0	864	if (strlen((char*)uncompr) != 7) // " hello!"
sl@0	865	{
sl@0	866	err=0;
sl@0	867	}
sl@0	868	gzclose(file);
sl@0	869	return err;
sl@0	870	}
sl@0	871
sl@0	872	/**
sl@0	873	* Function Name : TestGzgets
sl@0	874	* TestCase Description: 1. Open a gz compressed file in read mode
sl@0	875	* 2. Read certain valid number of bytes from the compressed file
sl@0	876	* Return Value: Returns read buffer
sl@0	877	*/
sl@0	878	TInt CTestZlib::TestGzgets()
sl@0	879	{
sl@0	880	TInt res = KErrNone ;
sl@0	881	Byte compr, uncompr;
sl@0	882	uLong comprLen = 20*sizeof(int);
sl@0	883
sl@0	884	uLong uncomprLen = comprLen;
sl@0	885	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	886	if (compr == Z_NULL)
sl@0	887	{
sl@0	888	return KErrNoMemory;
sl@0	889	}
sl@0	890	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	891	if (uncompr == Z_NULL)
sl@0	892	{
sl@0	893	free(compr);
sl@0	894	return KErrNoMemory;
sl@0	895	}
sl@0	896
sl@0	897	res = test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	898	if(res < 0)
sl@0	899	{
sl@0	900	free(compr);
sl@0	901	free(uncompr);
sl@0	902	return KErrNoMemory;
sl@0	903	}
sl@0	904	int err=test_gzgets(MYFILE,uncompr, uncomprLen);
sl@0	905	if(err == 0)
sl@0	906	{
sl@0	907	res = KErrGeneral;
sl@0	908	}
sl@0	909	free(compr);
sl@0	910	free(uncompr);
sl@0	911	return res;
sl@0	912	}
sl@0	913
sl@0	914	/**
sl@0	915	* Function Name : test_gzgetsfail
sl@0	916	* TestCase Description: This is a global function used by many test functions
sl@0	917	*/
sl@0	918	TInt test_gzgetsfail(const char * fname, Byte * uncompr,int uncomprLen)
sl@0	919	{
sl@0	920	TInt res = KErrNone ;
sl@0	921	char* err;
sl@0	922	int len = (int)strlen(hello)+1;
sl@0	923	gzFile file;
sl@0	924
sl@0	925	file = gzopen(fname, "wb");
sl@0	926	if (file == NULL)
sl@0	927	{
sl@0	928	res = KErrGeneral;
sl@0	929	}
sl@0	930	err = gzgets(file, (char*)uncompr, uncomprLen);
sl@0	931
sl@0	932	if(err == 0)
sl@0	933	{
sl@0	934	res = KErrNone ;
sl@0	935	}
sl@0	936	else
sl@0	937	{
sl@0	938	res = KErrGeneral;
sl@0	939	}
sl@0	940	int err1= gzclose(file);
sl@0	941	if (err1 != Z_OK)
sl@0	942	{
sl@0	943	res = KErrGeneral;
sl@0	944	}
sl@0	945	return res;
sl@0	946	}
sl@0	947
sl@0	948
sl@0	949	/**
sl@0	950	* Function Name : TestgzgetsFail
sl@0	951	* TestCase Description: 1. Open a gz compressed file in read mode
sl@0	952	* 2. Invalid number of bytes (negative number) for gzgets
sl@0	953	* Return Value: Z_NULL
sl@0	954	*/
sl@0	955	TInt CTestZlib::TestgzgetsFail()
sl@0	956	{
sl@0	957	TInt res = KErrNone ;
sl@0	958	Byte compr, uncompr;
sl@0	959	uLong comprLen = 20*sizeof(int);
sl@0	960	uLong uncomprLen = comprLen;
sl@0	961	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	962	if (compr == Z_NULL)
sl@0	963	{
sl@0	964	return KErrNoMemory;
sl@0	965	}
sl@0	966	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	967	if (uncompr == Z_NULL)
sl@0	968	{
sl@0	969	free(compr);
sl@0	970	return KErrNoMemory;
sl@0	971	}
sl@0	972	test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	973	int ret= test_gzgetsfail(TESTFILE,uncompr, -1);
sl@0	974	if(ret == 0)
sl@0	975	{
sl@0	976	res = KErrNone ;
sl@0	977	}
sl@0	978	else
sl@0	979	{
sl@0	980	res = KErrGeneral;
sl@0	981	}
sl@0	982
sl@0	983	free(compr);
sl@0	984	free(uncompr);
sl@0	985	return res;
sl@0	986	}
sl@0	987
sl@0	988
sl@0	989	/**
sl@0	990	* Function Name : TestgzgetsopenFail
sl@0	991	* TestCase Description: 1. Open a gz compressed file in read mode
sl@0	992	* 2. Invalid number of bytes (negative number) for gzgets
sl@0	993	* Return Value: KErrNone
sl@0	994	*/
sl@0	995	TInt CTestZlib::TestgzgetsopenFail()
sl@0	996	{
sl@0	997	TInt res = KErrNone ;
sl@0	998
sl@0	999	Byte compr, uncompr;
sl@0	1000	uLong comprLen = 20*sizeof(int);
sl@0	1001	uLong uncomprLen = comprLen;
sl@0	1002	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1003	if (compr == Z_NULL)
sl@0	1004	{
sl@0	1005	return KErrNoMemory;
sl@0	1006	}
sl@0	1007	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1008	if (uncompr == Z_NULL)
sl@0	1009	{
sl@0	1010	free(compr);
sl@0	1011	return KErrNoMemory;
sl@0	1012	}
sl@0	1013	res=test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	1014	if(res < 0)
sl@0	1015	{
sl@0	1016	free(compr);
sl@0	1017	free(uncompr);
sl@0	1018	return KErrNoMemory;
sl@0	1019	}
sl@0	1020	int err = test_gzgetsfail(NOFILE,uncompr, uncomprLen);
sl@0	1021
sl@0	1022	if(err != 0)
sl@0	1023	{
sl@0	1024	res = KErrNone ;
sl@0	1025	}
sl@0	1026	else
sl@0	1027	{
sl@0	1028	res = KErrGeneral;
sl@0	1029	}
sl@0	1030	free(compr);
sl@0	1031	free(uncompr);
sl@0	1032	return res;
sl@0	1033	}
sl@0	1034
sl@0	1035
sl@0	1036	/**
sl@0	1037	* Function Name : Test_deflate
sl@0	1038	* TestCase Description: 1. Call deflateInit with valid arguments
sl@0	1039	* 2. Call deflate with necessary valid arguments
sl@0	1040	* Return Value: Z_OK
sl@0	1041	*/
sl@0	1042	TInt CTestZlib::Test_deflate( Byte *compr, uLong comprLen)
sl@0	1043	{
sl@0	1044	TInt res = KErrNone ;
sl@0	1045	z_stream c_stream; /* compression stream */
sl@0	1046	int err;
sl@0	1047	uLong len = (uLong)strlen(hello)+1;
sl@0	1048
sl@0	1049	c_stream.zalloc = (alloc_func)0;
sl@0	1050	c_stream.zfree = (free_func)0;
sl@0	1051	c_stream.opaque = (voidpf)0;
sl@0	1052
sl@0	1053	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	1054
sl@0	1055	if(err<0)
sl@0	1056	{
sl@0	1057	return err;
sl@0	1058	}
sl@0	1059	c_stream.next_in = (Bytef*)hello;
sl@0	1060	c_stream.next_out = compr;
sl@0	1061
sl@0	1062	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	1063	{
sl@0	1064	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
sl@0	1065	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	1066	}
sl@0	1067	/* Finish the stream, still forcing small buffers: */
sl@0	1068	for (;;)
sl@0	1069	{
sl@0	1070	c_stream.avail_out = 1;
sl@0	1071	err = deflate(&c_stream, Z_FINISH);
sl@0	1072	if (err == Z_STREAM_END) break;
sl@0	1073	if(err!=Z_OK)
sl@0	1074	{
sl@0	1075	res = KErrGeneral;
sl@0	1076	}
sl@0	1077	}
sl@0	1078	err = deflateEnd(&c_stream);
sl@0	1079	if(err!=Z_OK)
sl@0	1080	{
sl@0	1081	res = KErrGeneral;
sl@0	1082	}
sl@0	1083	return res;
sl@0	1084	}
sl@0	1085
sl@0	1086
sl@0	1087	/**
sl@0	1088	* Function Name : TestInflate
sl@0	1089	* TestCase Description: 1. Compress the data using deflate
sl@0	1090	* 2. inflateInit to initialize internal stream state for decompression
sl@0	1091	* 3. inflate with necessary valid arguments
sl@0	1092	* Return Value: Z_OK
sl@0	1093	*/
sl@0	1094	TInt CTestZlib::TestInflate()
sl@0	1095	{
sl@0	1096	TInt res = KErrNone ;
sl@0	1097	Byte compr, uncompr;
sl@0	1098	uLong comprLen = 20*sizeof(int);
sl@0	1099	uLong uncomprLen = comprLen;
sl@0	1100	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1101	if (compr == Z_NULL)
sl@0	1102	{
sl@0	1103	return KErrNoMemory;
sl@0	1104	}
sl@0	1105	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1106	if (uncompr == Z_NULL)
sl@0	1107	{
sl@0	1108	free(compr);
sl@0	1109	return KErrNoMemory;
sl@0	1110	}
sl@0	1111	// test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	1112	res = Test_deflate(compr, comprLen);
sl@0	1113	if(res<0)
sl@0	1114	{
sl@0	1115	free(compr);
sl@0	1116	free(uncompr);
sl@0	1117	return KErrNoMemory;
sl@0	1118	}
sl@0	1119
sl@0	1120	int err=0;
sl@0	1121	z_stream d_stream; /* decompression stream */
sl@0	1122
sl@0	1123	strcpy((char*)uncompr, "garbage");
sl@0	1124
sl@0	1125	d_stream.zalloc = (alloc_func)0;
sl@0	1126	d_stream.zfree = (free_func)0;
sl@0	1127	d_stream.opaque = (voidpf)0;
sl@0	1128
sl@0	1129	d_stream.next_in = compr;
sl@0	1130	d_stream.avail_in = 0;
sl@0	1131	d_stream.next_out = uncompr;
sl@0	1132
sl@0	1133	res = inflateInit(&d_stream);
sl@0	1134
sl@0	1135	if(res<0)
sl@0	1136	{
sl@0	1137	free(compr);
sl@0	1138	free(uncompr);
sl@0	1139	return KErrNoMemory;
sl@0	1140	}
sl@0	1141	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	1142	{
sl@0	1143	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
sl@0	1144	err = inflate(&d_stream, Z_SYNC_FLUSH);
sl@0	1145
sl@0	1146	if (err == Z_STREAM_END \|\| err == Z_MEM_ERROR) break;
sl@0	1147	}
sl@0	1148	//inflate() should normally be called until it returns Z_STREAM_END
sl@0	1149
sl@0	1150	if(err == Z_MEM_ERROR)
sl@0	1151	{
sl@0	1152	err = inflateEnd(&d_stream);
sl@0	1153	free(compr);
sl@0	1154	free(uncompr);
sl@0	1155	return err;
sl@0	1156	}
sl@0	1157	err = inflateEnd(&d_stream);
sl@0	1158
sl@0	1159	if (err != Z_OK)
sl@0	1160	{
sl@0	1161	res = KErrGeneral;
sl@0	1162	}
sl@0	1163	else
sl@0	1164	{
sl@0	1165	res=KErrNone ;
sl@0	1166	}
sl@0	1167	free(compr);
sl@0	1168	free(uncompr);
sl@0	1169	return res;
sl@0	1170	}
sl@0	1171
sl@0	1172
sl@0	1173	/**
sl@0	1174	* Function Name : TestInflate_fail1
sl@0	1175	* TestCase Description: 1. Compress the data using deflate
sl@0	1176	* 2. inflateInit to initialize internal stream state for decompression
sl@0	1177	* 3. Set avail_in = 0 and call inflate
sl@0	1178	* Return Value: Z_STREAM_ERROR
sl@0	1179	*/
sl@0	1180	TInt CTestZlib::TestInflate_fail1()
sl@0	1181	{
sl@0	1182	TInt res = KErrNone ;
sl@0	1183	Byte compr, uncompr;
sl@0	1184	uLong comprLen = 20*sizeof(int);
sl@0	1185	uLong uncomprLen = comprLen;
sl@0	1186	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1187	if (compr == Z_NULL)
sl@0	1188	{
sl@0	1189	return KErrNoMemory;
sl@0	1190	}
sl@0	1191	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1192	if (uncompr == Z_NULL)
sl@0	1193	{
sl@0	1194	free(compr);
sl@0	1195	return KErrNoMemory;
sl@0	1196	}
sl@0	1197
sl@0	1198	// test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	1199	res = Test_deflate(compr, comprLen);
sl@0	1200	if(res<0)
sl@0	1201	{
sl@0	1202	free(compr);
sl@0	1203	free(uncompr);
sl@0	1204	return KErrNoMemory;
sl@0	1205	}
sl@0	1206
sl@0	1207	int err;
sl@0	1208	z_stream d_stream; /* decompression stream */
sl@0	1209
sl@0	1210	strcpy((char*)uncompr, "garbage");
sl@0	1211
sl@0	1212	d_stream.zalloc = (alloc_func)0;
sl@0	1213	d_stream.zfree = (free_func)0;
sl@0	1214	d_stream.opaque = (voidpf)0;
sl@0	1215
sl@0	1216	d_stream.next_in = compr;
sl@0	1217	d_stream.avail_in = 0;
sl@0	1218	d_stream.next_out = NULL;
sl@0	1219
sl@0	1220	err = inflateInit(&d_stream);
sl@0	1221
sl@0	1222	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	1223	{
sl@0	1224	d_stream.avail_in = 0;
sl@0	1225	d_stream.avail_out = 1; /* force small buffers */
sl@0	1226	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	1227	if (err == Z_STREAM_ERROR) break;
sl@0	1228	}
sl@0	1229	//inflate() should normally be called until it returns Z_STREAM_END
sl@0	1230
sl@0	1231	err = inflateEnd(&d_stream);
sl@0	1232
sl@0	1233	if (err != Z_OK)
sl@0	1234	{
sl@0	1235	res = KErrGeneral;
sl@0	1236	}
sl@0	1237	else
sl@0	1238	{
sl@0	1239	res=KErrNone ;
sl@0	1240	}
sl@0	1241	free(compr);
sl@0	1242	free(uncompr);
sl@0	1243	return res;
sl@0	1244	}
sl@0	1245
sl@0	1246	/**
sl@0	1247	* Function Name : TestInflate_fail1
sl@0	1248	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1249	* 2. Call inflateInit to initialize internal stream state for decompression
sl@0	1250	* 3. Pass Z_NULL to inflate
sl@0	1251	* Return Value: Z_STREAM_ERROR
sl@0	1252	*/
sl@0	1253	TInt CTestZlib::TestInflate_fail2()
sl@0	1254	{
sl@0	1255	TInt res = KErrNone ;
sl@0	1256	Byte compr, uncompr;
sl@0	1257	uLong comprLen = 20*sizeof(int);
sl@0	1258	uLong uncomprLen = comprLen;
sl@0	1259	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1260	if (compr == Z_NULL)
sl@0	1261	{
sl@0	1262	return KErrNoMemory;
sl@0	1263	}
sl@0	1264	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1265	if (uncompr == Z_NULL)
sl@0	1266	{
sl@0	1267	free(compr);
sl@0	1268	return KErrNoMemory;
sl@0	1269	}
sl@0	1270	res = Test_deflate(compr, comprLen);
sl@0	1271	if(res<0)
sl@0	1272	{
sl@0	1273	free(compr);
sl@0	1274	free(uncompr);
sl@0	1275	return KErrNoMemory;
sl@0	1276	}
sl@0	1277
sl@0	1278	int err;
sl@0	1279	z_stream d_stream; /* decompression stream */
sl@0	1280
sl@0	1281	strcpy((char*)uncompr, "garbage");
sl@0	1282
sl@0	1283	d_stream.zalloc = (alloc_func)0;
sl@0	1284	d_stream.zfree = (free_func)0;
sl@0	1285	d_stream.opaque = (voidpf)0;
sl@0	1286
sl@0	1287	d_stream.next_in = compr;
sl@0	1288	d_stream.avail_in = 0;
sl@0	1289	d_stream.next_out = uncompr;
sl@0	1290
sl@0	1291	err = inflateInit(&d_stream);
sl@0	1292
sl@0	1293	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	1294	{
sl@0	1295	d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
sl@0	1296	err = inflate(NULL, Z_NO_FLUSH);
sl@0	1297	if (err == Z_STREAM_ERROR) break;
sl@0	1298	}
sl@0	1299	//inflate() should normally be called until it returns Z_STREAM_END
sl@0	1300	err = inflateEnd(&d_stream);
sl@0	1301
sl@0	1302	if (err != Z_OK)
sl@0	1303	{
sl@0	1304	res = KErrGeneral;
sl@0	1305	}
sl@0	1306	else
sl@0	1307	{
sl@0	1308	res=KErrNone ;
sl@0	1309	}
sl@0	1310	free(compr);
sl@0	1311	free(uncompr);
sl@0	1312	return res;
sl@0	1313	}
sl@0	1314
sl@0	1315	/**
sl@0	1316	* Function Name : TestInflate_fail3
sl@0	1317	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1318	* 2. Call inflateInit to initialize internal stream state for decompression
sl@0	1319	* 3. Set avail_out = 0 and call inflate with necessary valid arguments
sl@0	1320	* Return Value: Z_STREAM_ERROR
sl@0	1321	*/
sl@0	1322	TInt CTestZlib::TestInflate_fail3()
sl@0	1323	{
sl@0	1324	TInt res = KErrNone ;
sl@0	1325	Byte compr, uncompr;
sl@0	1326	uLong comprLen = 20*sizeof(int);
sl@0	1327	uLong uncomprLen = comprLen;
sl@0	1328	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1329	if (compr == Z_NULL)
sl@0	1330	{
sl@0	1331	return KErrNoMemory;
sl@0	1332	}
sl@0	1333	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1334	if (uncompr == Z_NULL)
sl@0	1335	{
sl@0	1336	free(compr);
sl@0	1337	return KErrNoMemory;
sl@0	1338	}
sl@0	1339	res = Test_deflate(compr, comprLen);
sl@0	1340	if(res<0)
sl@0	1341	{
sl@0	1342	free(compr);
sl@0	1343	free(uncompr);
sl@0	1344	return KErrNoMemory;
sl@0	1345	}
sl@0	1346
sl@0	1347	int err;
sl@0	1348	z_stream d_stream; /* decompression stream */
sl@0	1349
sl@0	1350	strcpy((char*)uncompr, "garbage");
sl@0	1351
sl@0	1352	d_stream.zalloc = (alloc_func)0;
sl@0	1353	d_stream.zfree = (free_func)0;
sl@0	1354	d_stream.opaque = (voidpf)0;
sl@0	1355
sl@0	1356	d_stream.next_in = NULL;
sl@0	1357	d_stream.avail_in = 0;
sl@0	1358	d_stream.next_out = uncompr;
sl@0	1359
sl@0	1360	err = inflateInit(&d_stream);
sl@0	1361
sl@0	1362	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	1363	{
sl@0	1364	d_stream.avail_in = 1;
sl@0	1365	d_stream.avail_out = 0; /* force small buffers */
sl@0	1366	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	1367	if (err == Z_STREAM_ERROR) break;
sl@0	1368	}
sl@0	1369	//inflate() should normally be called until it returns Z_STREAM_END
sl@0	1370
sl@0	1371	err = inflateEnd(&d_stream);
sl@0	1372
sl@0	1373	if (err != Z_OK)
sl@0	1374	{
sl@0	1375	res = KErrGeneral;
sl@0	1376	}
sl@0	1377	else
sl@0	1378	{
sl@0	1379	res=KErrNone ;
sl@0	1380	}
sl@0	1381	free(compr);
sl@0	1382	free(uncompr);
sl@0	1383	return res;
sl@0	1384	}
sl@0	1385
sl@0	1386	/**
sl@0	1387	* Function Name : test_compress_positive
sl@0	1388	* TestCase Description: This is a global function used by many test functions
sl@0	1389	*/
sl@0	1390	TInt test_compress_positive(Byte * compr,uLong comprLen,Byte * /uncompr/,uLong /uncomprLen/)
sl@0	1391	{
sl@0	1392	TInt res = KErrNone ;
sl@0	1393	int err;
sl@0	1394	uLong len = (uLong)strlen(hello)+1;
sl@0	1395
sl@0	1396	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	1397	if(err < 0)
sl@0	1398	{
sl@0	1399	res = KErrNoMemory;
sl@0	1400	}
sl@0	1401
sl@0	1402	if(err == 0)
sl@0	1403	{
sl@0	1404	res = KErrNone ;
sl@0	1405	}
sl@0	1406	else
sl@0	1407	{
sl@0	1408	res = KErrGeneral;
sl@0	1409	}
sl@0	1410	return res;
sl@0	1411	}
sl@0	1412
sl@0	1413	/**
sl@0	1414	* Function Name : test_inflateend_positive
sl@0	1415	* TestCase Description: This is a global function used by many test functions
sl@0	1416	*/
sl@0	1417	TInt test_inflateend_positive(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen)
sl@0	1418	{
sl@0	1419	TInt res = KErrNone ;
sl@0	1420	int err;
sl@0	1421	z_stream d_stream; // decompression stream
sl@0	1422
sl@0	1423	strcpy((char*)uncompr, "garbage");
sl@0	1424
sl@0	1425	d_stream.zalloc = (alloc_func)0;
sl@0	1426	d_stream.zfree = (free_func)0;
sl@0	1427	d_stream.opaque = (voidpf)0;
sl@0	1428
sl@0	1429	d_stream.next_in = compr;
sl@0	1430	d_stream.avail_in = 0;
sl@0	1431	d_stream.next_out = uncompr;
sl@0	1432
sl@0	1433	err = inflateInit(&d_stream);
sl@0	1434	if(err <0)
sl@0	1435	{
sl@0	1436	return KErrNoMemory;
sl@0	1437	}
sl@0	1438
sl@0	1439	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	1440	{
sl@0	1441	d_stream.avail_in = d_stream.avail_out = 1; // force small buffers
sl@0	1442	err = inflate(&d_stream, Z_NO_FLUSH);
sl@0	1443	if (err == Z_STREAM_END) break;
sl@0	1444	if(err<0) break;
sl@0	1445	}
sl@0	1446
sl@0	1447	err = inflateEnd(&d_stream);
sl@0	1448	if (err != Z_OK)
sl@0	1449	{
sl@0	1450	res = KErrGeneral;
sl@0	1451	}
sl@0	1452	else
sl@0	1453	{
sl@0	1454	res=KErrNone ;
sl@0	1455	}
sl@0	1456	return res;
sl@0	1457	}
sl@0	1458
sl@0	1459
sl@0	1460	/**
sl@0	1461	* Function Name : TestInflateend
sl@0	1462	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1463	* 2. inflate to decompress the data
sl@0	1464	* 3. inflateEnd
sl@0	1465	* Return Value: Z_OK
sl@0	1466	*/
sl@0	1467	TInt CTestZlib::TestInflateend()
sl@0	1468	{
sl@0	1469	TInt res = KErrNone ;
sl@0	1470	Byte compr, uncompr;
sl@0	1471	uLong comprLen = 20*sizeof(int);
sl@0	1472	uLong uncomprLen = comprLen;
sl@0	1473	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1474	if (compr == Z_NULL)
sl@0	1475	{
sl@0	1476	return KErrNoMemory;
sl@0	1477	}
sl@0	1478	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1479	if (uncompr == Z_NULL)
sl@0	1480	{
sl@0	1481	free(compr);
sl@0	1482	return KErrNoMemory;
sl@0	1483	}
sl@0	1484	res= test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	1485	if(res<0)
sl@0	1486	{
sl@0	1487	free(compr);
sl@0	1488	free(uncompr);
sl@0	1489	return KErrNoMemory;
sl@0	1490	}
sl@0	1491	res = Test_deflate(compr, comprLen);
sl@0	1492	if(res<0)
sl@0	1493	{
sl@0	1494	free(compr);
sl@0	1495	free(uncompr);
sl@0	1496	return KErrNoMemory;
sl@0	1497	}
sl@0	1498	res = test_inflateend_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	1499	if(res <0)
sl@0	1500	{
sl@0	1501	free(compr);
sl@0	1502	free(uncompr);
sl@0	1503	return res;
sl@0	1504	}
sl@0	1505	else if(res==0)
sl@0	1506	{
sl@0	1507	res = KErrNone;
sl@0	1508	}
sl@0	1509	else
sl@0	1510	{
sl@0	1511	res = KErrGeneral;
sl@0	1512	}
sl@0	1513	free(compr);
sl@0	1514	free(uncompr);
sl@0	1515	return res;
sl@0	1516	}
sl@0	1517
sl@0	1518	/**
sl@0	1519	* Function Name : TestInflateend_fail
sl@0	1520	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1521	* 2. inflate to decompress the data
sl@0	1522	* 3. Pass Z_NULL as argument to inflateEnd
sl@0	1523	* Return Value: Z_STREAM_ERROR
sl@0	1524	*/
sl@0	1525	TInt CTestZlib::TestInflateend_fail()
sl@0	1526	{
sl@0	1527	TInt res = KErrNone ;
sl@0	1528	Byte compr, uncompr;
sl@0	1529	uLong comprLen = 20*sizeof(int);
sl@0	1530	uLong uncomprLen = comprLen;
sl@0	1531	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1532	if (compr == Z_NULL)
sl@0	1533	{
sl@0	1534	return KErrNoMemory;
sl@0	1535	}
sl@0	1536	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1537	if (uncompr == Z_NULL)
sl@0	1538	{
sl@0	1539	free(compr);
sl@0	1540	return KErrNoMemory;
sl@0	1541	}
sl@0	1542	res=test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	1543	if(res<0)
sl@0	1544	{
sl@0	1545	free(compr);
sl@0	1546	free(uncompr);
sl@0	1547	return KErrNoMemory;
sl@0	1548	}
sl@0	1549	res = Test_deflate(compr, comprLen);
sl@0	1550	if(res<0)
sl@0	1551	{
sl@0	1552	free(compr);
sl@0	1553	free(uncompr);
sl@0	1554	return KErrNoMemory;
sl@0	1555	}
sl@0	1556	int ret= inflateEnd(NULL);
sl@0	1557	if(ret==0)
sl@0	1558	{
sl@0	1559	res = KErrGeneral;
sl@0	1560	}
sl@0	1561	else
sl@0	1562	{
sl@0	1563	res = KErrNone;
sl@0	1564	}
sl@0	1565	free(compr);
sl@0	1566	free(uncompr);
sl@0	1567	return res;
sl@0	1568	}
sl@0	1569
sl@0	1570	/**
sl@0	1571	* Function Name : TestInflateReset
sl@0	1572	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1573	* 2. Call inflateInit to initialize internal stream state for decompression
sl@0	1574	* 3. Call inflateReset with valid arguments
sl@0	1575	* Return Value: Z_OK
sl@0	1576	*/
sl@0	1577	TInt CTestZlib::TestInflateReset()
sl@0	1578	{
sl@0	1579	TInt res=KErrNone;
sl@0	1580	z_stream d_stream; /* decompression stream */
sl@0	1581	const char * version;
sl@0	1582	d_stream.zalloc = (alloc_func)0;
sl@0	1583	d_stream.zfree = (free_func)0;
sl@0	1584	d_stream.opaque = (voidpf)0;
sl@0	1585
sl@0	1586	Byte compr, uncompr;
sl@0	1587	uLong comprLen = 20*sizeof(int);
sl@0	1588	uLong uncomprLen = comprLen;
sl@0	1589	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1590	if (compr == Z_NULL)
sl@0	1591	{
sl@0	1592	return KErrNoMemory;
sl@0	1593	}
sl@0	1594	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1595	if (uncompr == Z_NULL)
sl@0	1596	{
sl@0	1597	free(compr);
sl@0	1598	return KErrNoMemory;
sl@0	1599	}
sl@0	1600
sl@0	1601	res = Test_deflate(compr, comprLen);
sl@0	1602	if(res<0)
sl@0	1603	{
sl@0	1604	free(compr);
sl@0	1605	free(uncompr);
sl@0	1606	return KErrNoMemory;
sl@0	1607	}
sl@0	1608	d_stream.next_in = compr;
sl@0	1609	d_stream.avail_in = 0;
sl@0	1610	d_stream.next_out = uncompr;
sl@0	1611	version=zlibVersion();
sl@0	1612	int err;
sl@0	1613	err = inflateInit_(&d_stream,(char*)version, sizeof(d_stream));
sl@0	1614	if(err<0)
sl@0	1615	{
sl@0	1616	free(compr);
sl@0	1617	free(uncompr);
sl@0	1618	return KErrNoMemory;
sl@0	1619	}
sl@0	1620
sl@0	1621	err=inflateReset(&d_stream);
sl@0	1622	if(err<0)
sl@0	1623	{
sl@0	1624	inflateEnd(&d_stream);
sl@0	1625	free(compr);
sl@0	1626	free(uncompr);
sl@0	1627	return KErrNoMemory;
sl@0	1628	}
sl@0	1629	if(err!=0)
sl@0	1630	{
sl@0	1631	res=KErrGeneral;
sl@0	1632	}
sl@0	1633	free(compr);
sl@0	1634	free(uncompr);
sl@0	1635	res=inflateEnd(&d_stream);
sl@0	1636	return res;
sl@0	1637	}
sl@0	1638
sl@0	1639
sl@0	1640	/**
sl@0	1641	* Function Name : TestInflateResetfail1
sl@0	1642	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1643	* 2. Call inflateInit to initialize internal stream state for decompression
sl@0	1644	* 3. Pass Z_NULL as argument to inflateReset
sl@0	1645	* Return Value: Z_STREAM_ERROR
sl@0	1646	*/
sl@0	1647	TInt CTestZlib::TestInflateResetfail1()
sl@0	1648	{
sl@0	1649	TInt res=KErrNone;
sl@0	1650	z_stream d_stream; /* decompression stream */
sl@0	1651	const char * version;
sl@0	1652	d_stream.zalloc = (alloc_func)0;
sl@0	1653	d_stream.zfree = (free_func)0;
sl@0	1654	d_stream.opaque = (voidpf)0;
sl@0	1655
sl@0	1656	Byte compr, uncompr;
sl@0	1657	uLong comprLen = 20*sizeof(int);
sl@0	1658	uLong uncomprLen = comprLen;
sl@0	1659	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1660	if (compr == Z_NULL)
sl@0	1661	{
sl@0	1662	return KErrNoMemory;
sl@0	1663	}
sl@0	1664	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1665	if (uncompr == Z_NULL)
sl@0	1666	{
sl@0	1667	free(compr);
sl@0	1668	return KErrNoMemory;
sl@0	1669	}
sl@0	1670
sl@0	1671	res = Test_deflate(compr, comprLen);
sl@0	1672	if(res<0)
sl@0	1673	{
sl@0	1674	free(compr);
sl@0	1675	free(uncompr);
sl@0	1676	return KErrNoMemory;
sl@0	1677	}
sl@0	1678	d_stream.next_in = compr;
sl@0	1679	d_stream.avail_in = 0;
sl@0	1680	d_stream.next_out = uncompr;
sl@0	1681	version=zlibVersion();
sl@0	1682	inflateInit_(&d_stream,(char*)version, sizeof(d_stream));
sl@0	1683	res=inflateReset(NULL);
sl@0	1684	if(res!=Z_STREAM_ERROR)
sl@0	1685	{
sl@0	1686	res=KErrGeneral;
sl@0	1687	}
sl@0	1688	res=inflateEnd(&d_stream);
sl@0	1689	if(res!=0)
sl@0	1690	{
sl@0	1691	res=KErrGeneral;
sl@0	1692	}
sl@0	1693	free(compr);
sl@0	1694	free(uncompr);
sl@0	1695	return res;
sl@0	1696	}
sl@0	1697
sl@0	1698	/**
sl@0	1699	* Function Name : TestInflateInit2_
sl@0	1700	* TestCase Description: Test inflateInit2_
sl@0	1701	* Return Value: Z_OK
sl@0	1702	*/
sl@0	1703	TInt CTestZlib::TestInflateInit2_()
sl@0	1704	{
sl@0	1705	TInt res = KErrNone ;
sl@0	1706	z_stream d_stream; // decompression stream
sl@0	1707	const char * version;
sl@0	1708	d_stream.zalloc = (alloc_func)0;
sl@0	1709	d_stream.zfree = (free_func)0;
sl@0	1710	d_stream.opaque = (voidpf)0;
sl@0	1711
sl@0	1712	version = zlibVersion();
sl@0	1713	TInt ret = inflateInit2_(&d_stream,15,version, sizeof(d_stream));
sl@0	1714	if(ret==0)
sl@0	1715	{
sl@0	1716	res = KErrNone;
sl@0	1717	}
sl@0	1718	else
sl@0	1719	{
sl@0	1720	return ret;
sl@0	1721	}
sl@0	1722	inflateEnd(&d_stream);
sl@0	1723	return res;
sl@0	1724	}
sl@0	1725
sl@0	1726	/**
sl@0	1727	* Function Name : TestInflateInit_
sl@0	1728	* TestCase Description: Test inflateInit_
sl@0	1729	* Return Value: Z_OK
sl@0	1730	*/
sl@0	1731	TInt CTestZlib::TestInflateInit_()
sl@0	1732	{
sl@0	1733	TInt res = KErrNone ;
sl@0	1734	z_stream d_stream;
sl@0	1735	const char * version;
sl@0	1736	d_stream.zalloc = (alloc_func)0;
sl@0	1737	d_stream.zfree = (free_func)0;
sl@0	1738	d_stream.opaque = (voidpf)0;
sl@0	1739
sl@0	1740	Byte compr, uncompr;
sl@0	1741	uLong comprLen = 20*sizeof(int);
sl@0	1742	uLong uncomprLen = comprLen;
sl@0	1743	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1744	if (compr == Z_NULL)
sl@0	1745	{
sl@0	1746	return KErrNoMemory;
sl@0	1747	}
sl@0	1748	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1749	if (uncompr == Z_NULL)
sl@0	1750	{
sl@0	1751	free(compr);
sl@0	1752	return KErrNoMemory;
sl@0	1753	}
sl@0	1754	res= test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	1755	if(res<0)
sl@0	1756	{
sl@0	1757	free(compr);
sl@0	1758	free(uncompr);
sl@0	1759	return KErrNoMemory;
sl@0	1760	}
sl@0	1761
sl@0	1762	res = Test_deflate(compr, comprLen);
sl@0	1763	if(res<0)
sl@0	1764	{
sl@0	1765	free(compr);
sl@0	1766	free(uncompr);
sl@0	1767	return KErrNoMemory;
sl@0	1768	}
sl@0	1769	d_stream.next_in = compr;
sl@0	1770	d_stream.avail_in = 0;
sl@0	1771	d_stream.next_out = uncompr;
sl@0	1772	version=zlibVersion();
sl@0	1773	int ret = inflateInit_(&d_stream,(char*)version, sizeof(d_stream));
sl@0	1774	if(ret==0)
sl@0	1775	{
sl@0	1776	res = KErrNone;
sl@0	1777	}
sl@0	1778	else
sl@0	1779	{
sl@0	1780	res = KErrGeneral;
sl@0	1781	}
sl@0	1782	inflateEnd(&d_stream);
sl@0	1783	free(compr);
sl@0	1784	free(uncompr);
sl@0	1785	return res;
sl@0	1786	}
sl@0	1787
sl@0	1788	/**
sl@0	1789	* Function Name : TestInflateInit2_negative
sl@0	1790	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1791	* 2. inflateInit2_ with stream size less than required
sl@0	1792	* Return Value: Z_MEM_ERROR
sl@0	1793	*/
sl@0	1794	TInt CTestZlib::TestInflateInit2_negative()
sl@0	1795	{
sl@0	1796	TInt res = KErrNone ;
sl@0	1797	z_stream d_stream; // decompression stream
sl@0	1798	const char * version;
sl@0	1799	d_stream.zalloc = (alloc_func)0;
sl@0	1800	d_stream.zfree = (free_func)0;
sl@0	1801	d_stream.opaque = (voidpf)0;
sl@0	1802
sl@0	1803	Byte compr, uncompr;
sl@0	1804	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	1805	uLong uncomprLen = comprLen;
sl@0	1806	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1807	if (compr == Z_NULL)
sl@0	1808	{
sl@0	1809	return KErrNoMemory;
sl@0	1810	}
sl@0	1811	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1812	if (uncompr == Z_NULL)
sl@0	1813	{
sl@0	1814	free(compr);
sl@0	1815	return KErrNoMemory;
sl@0	1816	}
sl@0	1817
sl@0	1818	res = Test_deflate(compr, comprLen);
sl@0	1819	if(res<0)
sl@0	1820	{
sl@0	1821	free(compr);
sl@0	1822	free(uncompr);
sl@0	1823	return KErrNoMemory;
sl@0	1824	}
sl@0	1825	d_stream.next_in = compr;
sl@0	1826	d_stream.avail_in = 0;
sl@0	1827	d_stream.next_out = uncompr;
sl@0	1828	version=zlibVersion();
sl@0	1829	int ret = inflateInit2_(&d_stream, 15, version, sizeof(d_stream)-5);
sl@0	1830	if(ret==0)
sl@0	1831	{
sl@0	1832	res = KErrGeneral;
sl@0	1833	}
sl@0	1834	else
sl@0	1835	{
sl@0	1836	res = KErrNone;
sl@0	1837	}
sl@0	1838	free(compr);
sl@0	1839	free(uncompr);
sl@0	1840	// inflateEnd(&d_stream);
sl@0	1841	return res;
sl@0	1842	}
sl@0	1843
sl@0	1844	/**
sl@0	1845	* Function Name : TestInflateInit_negative
sl@0	1846	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1847	* 2. Call inflateInit_ with stream size less than required
sl@0	1848	* Return Value: Z_MEM_ERROR
sl@0	1849	*/
sl@0	1850	TInt CTestZlib::TestInflateInit_negative()
sl@0	1851	{
sl@0	1852	TInt res = KErrNone ;
sl@0	1853	z_stream d_stream; // decompression stream
sl@0	1854	const char * version;
sl@0	1855	d_stream.zalloc = (alloc_func)0;
sl@0	1856	d_stream.zfree = (free_func)0;
sl@0	1857	d_stream.opaque = (voidpf)0;
sl@0	1858
sl@0	1859	Byte compr, uncompr;
sl@0	1860	uLong comprLen = 20*sizeof(int);
sl@0	1861	uLong uncomprLen = comprLen;
sl@0	1862	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1863	if (compr == Z_NULL)
sl@0	1864	{
sl@0	1865	return KErrNoMemory;
sl@0	1866	}
sl@0	1867	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1868	if (uncompr == Z_NULL)
sl@0	1869	{
sl@0	1870	free(compr);
sl@0	1871	return KErrNoMemory;
sl@0	1872	}
sl@0	1873	res = Test_deflate(compr, comprLen);
sl@0	1874	if(res<0)
sl@0	1875	{
sl@0	1876	free(compr);
sl@0	1877	free(uncompr);
sl@0	1878	return KErrNoMemory;
sl@0	1879	}
sl@0	1880	d_stream.next_in = compr;
sl@0	1881	d_stream.avail_in = 0;
sl@0	1882	d_stream.next_out = uncompr;
sl@0	1883	version=zlibVersion();
sl@0	1884	int ret = inflateInit_(&d_stream,(char*)version, sizeof(d_stream) - 5);
sl@0	1885	if(ret==0)
sl@0	1886	{
sl@0	1887	res = KErrGeneral;
sl@0	1888	}
sl@0	1889	else
sl@0	1890	{
sl@0	1891	res = KErrNone;
sl@0	1892	}
sl@0	1893	// inflateEnd(&d_stream);
sl@0	1894	free(compr);
sl@0	1895	free(uncompr);
sl@0	1896	return res;
sl@0	1897	}
sl@0	1898
sl@0	1899	/**
sl@0	1900	* Function Name : TestInflateInit2_versioncheck
sl@0	1901	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1902	* 2. inflateInit2_ with valid zlib version as argument
sl@0	1903	* Return Value: Z_OK
sl@0	1904	*/
sl@0	1905	TInt CTestZlib::TestInflateInit2_versioncheck()
sl@0	1906	{
sl@0	1907	TInt res = KErrNone ;
sl@0	1908	z_stream d_stream; // decompression stream
sl@0	1909	const char * version;
sl@0	1910	d_stream.zalloc = (alloc_func)0;
sl@0	1911	d_stream.zfree = (free_func)0;
sl@0	1912	d_stream.opaque = (voidpf)0;
sl@0	1913
sl@0	1914	Byte compr, uncompr;
sl@0	1915	uLong comprLen = 20*sizeof(int);
sl@0	1916	uLong uncomprLen = comprLen;
sl@0	1917	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1918	if (compr == Z_NULL)
sl@0	1919	{
sl@0	1920	return KErrNoMemory;
sl@0	1921	}
sl@0	1922	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1923	if (uncompr == Z_NULL)
sl@0	1924	{
sl@0	1925	free(compr);
sl@0	1926	return KErrNoMemory;
sl@0	1927	}
sl@0	1928
sl@0	1929	res = Test_deflate(compr, comprLen);
sl@0	1930	if(res<0)
sl@0	1931	{
sl@0	1932	free(compr);
sl@0	1933	free(uncompr);
sl@0	1934	return KErrNoMemory;
sl@0	1935	}
sl@0	1936	d_stream.next_in = compr;
sl@0	1937	d_stream.avail_in = 0;
sl@0	1938	d_stream.next_out = uncompr;
sl@0	1939	version=zlibVersion();
sl@0	1940	INFO_PRINTF2(_L("Version : %d"),version);
sl@0	1941	int ret = inflateInit2_(&d_stream, 15, "1.2.4", sizeof(d_stream)-5);
sl@0	1942	if(ret==0)
sl@0	1943	{
sl@0	1944	res = KErrGeneral;
sl@0	1945	}
sl@0	1946	else
sl@0	1947	{
sl@0	1948	res = KErrNone;
sl@0	1949	}
sl@0	1950	free(compr);
sl@0	1951	free(uncompr);
sl@0	1952	return res;
sl@0	1953	}
sl@0	1954
sl@0	1955	/**
sl@0	1956	* Function Name : TestInflateInit_versioncheck
sl@0	1957	* TestCase Description: 1. Compress the sample data using deflate
sl@0	1958	* 2. inflateInit_ with valid zlib version as argument
sl@0	1959	* Return Value: Z_OK
sl@0	1960	*/
sl@0	1961	TInt CTestZlib::TestInflateInit_versioncheck()
sl@0	1962	{
sl@0	1963	TInt res = KErrNone ;
sl@0	1964
sl@0	1965	z_stream d_stream; // decompression stream
sl@0	1966	const char * version;
sl@0	1967	d_stream.zalloc = (alloc_func)0;
sl@0	1968	d_stream.zfree = (free_func)0;
sl@0	1969	d_stream.opaque = (voidpf)0;
sl@0	1970
sl@0	1971	Byte compr, uncompr;
sl@0	1972	uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS
sl@0	1973	uLong uncomprLen = comprLen;
sl@0	1974	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1975	if (compr == Z_NULL)
sl@0	1976	{
sl@0	1977	return KErrNoMemory;
sl@0	1978	}
sl@0	1979	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1980	if (uncompr == Z_NULL)
sl@0	1981	{
sl@0	1982	free(compr);
sl@0	1983	return KErrNoMemory;
sl@0	1984	}
sl@0	1985	res = Test_deflate(compr, comprLen);
sl@0	1986	if(res<0)
sl@0	1987	{
sl@0	1988	free(compr);
sl@0	1989	free(uncompr);
sl@0	1990	return KErrNoMemory;
sl@0	1991	}
sl@0	1992	d_stream.next_in = compr;
sl@0	1993	d_stream.avail_in = 0;
sl@0	1994	d_stream.next_out = uncompr;
sl@0	1995	version=zlibVersion();
sl@0	1996	INFO_PRINTF2(_L("Version : %d"),version);
sl@0	1997	int ret = inflateInit_(&d_stream,(char*) "1.2.4", sizeof(d_stream) - 5);
sl@0	1998	if(ret==0)
sl@0	1999	{
sl@0	2000	res = KErrGeneral;
sl@0	2001	}
sl@0	2002	else
sl@0	2003	{
sl@0	2004	res = KErrNone;
sl@0	2005	}
sl@0	2006	free(compr);
sl@0	2007	free(uncompr);
sl@0	2008	return res;
sl@0	2009	}
sl@0	2010
sl@0	2011	/**
sl@0	2012	* Function Name : TestCompress
sl@0	2013	* TestCase Description: Test compress()
sl@0	2014	* Return Value: Z_OK
sl@0	2015	*/
sl@0	2016	TInt CTestZlib::TestCompress()
sl@0	2017	{
sl@0	2018	TInt res = KErrNone ;
sl@0	2019	Byte compr, uncompr;
sl@0	2020	uLong comprLen = 20*sizeof(int);
sl@0	2021	uLong uncomprLen = comprLen;
sl@0	2022	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2023	if (compr == Z_NULL)
sl@0	2024	{
sl@0	2025	return KErrNoMemory;
sl@0	2026	}
sl@0	2027	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2028	if (uncompr == Z_NULL)
sl@0	2029	{
sl@0	2030	free(compr);
sl@0	2031	return KErrNoMemory;
sl@0	2032	}
sl@0	2033	res=test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	2034	free(compr);
sl@0	2035	free(uncompr);
sl@0	2036	return res;
sl@0	2037	}
sl@0	2038
sl@0	2039	/**
sl@0	2040	* Function Name : test_compress_negative
sl@0	2041	* TestCase Description: This is a global function used by many test functions
sl@0	2042	*/
sl@0	2043	TInt test_compress_negative(Byte * compr,uLong comprLen,Byte * /uncompr/,uLong /uncomprLen/)
sl@0	2044	{
sl@0	2045	TInt res = KErrNone ;
sl@0	2046	int err;
sl@0	2047	uLong len = (uLong)strlen(hello)+1;
sl@0	2048	err = compress(compr, &comprLen, (const Bytef*)hello, len);
sl@0	2049	if(err == 0)
sl@0	2050	{
sl@0	2051	res = KErrGeneral;
sl@0	2052	}
sl@0	2053	else
sl@0	2054	{
sl@0	2055	res = KErrNone ;
sl@0	2056	}
sl@0	2057	return res;
sl@0	2058	}
sl@0	2059
sl@0	2060	/**
sl@0	2061	* Function Name : TestCompress_negative
sl@0	2062	* TestCase Description: Call compress with compression length less than required
sl@0	2063	* Return Value: Z_BUF_ERROR
sl@0	2064	*/
sl@0	2065	TInt CTestZlib::TestCompress_negative()
sl@0	2066	{
sl@0	2067	TInt res = KErrNone ;
sl@0	2068	Byte compr, uncompr;
sl@0	2069	uLong comprLen = 1*sizeof(int);
sl@0	2070	uLong uncomprLen = comprLen;
sl@0	2071	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2072	if (compr == Z_NULL)
sl@0	2073	{
sl@0	2074	return KErrNoMemory;
sl@0	2075	}
sl@0	2076	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2077	if (uncompr == Z_NULL)
sl@0	2078	{
sl@0	2079	free(compr);
sl@0	2080	return KErrNoMemory;
sl@0	2081	}
sl@0	2082	res=test_compress_negative(compr, comprLen, uncompr, uncomprLen);
sl@0	2083	free(compr);
sl@0	2084	free(uncompr);
sl@0	2085	return res;
sl@0	2086	}
sl@0	2087
sl@0	2088	/**
sl@0	2089	* Function Name : TestCompress2_positive
sl@0	2090	* TestCase Description: Test compress2 with valid arguments
sl@0	2091	* Return Value: Z_OK
sl@0	2092	*/
sl@0	2093	TInt CTestZlib::TestCompress2_positive()
sl@0	2094	{
sl@0	2095	TInt res = KErrNone ;
sl@0	2096	int err;
sl@0	2097	uLong len = (uLong)strlen(hello)+1;
sl@0	2098
sl@0	2099	Byte compr, uncompr;
sl@0	2100	uLong comprLen = 20*sizeof(int);
sl@0	2101	uLong uncomprLen = comprLen;
sl@0	2102	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2103	if (compr == Z_NULL)
sl@0	2104	{
sl@0	2105	return KErrNoMemory;
sl@0	2106	}
sl@0	2107	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2108	if (uncompr == Z_NULL)
sl@0	2109	{
sl@0	2110	free(compr);
sl@0	2111	return KErrNoMemory;
sl@0	2112	}
sl@0	2113
sl@0	2114	err=compress2(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION);
sl@0	2115
sl@0	2116	if(err == 0)
sl@0	2117	{
sl@0	2118	res = KErrNone ;
sl@0	2119	}
sl@0	2120	else
sl@0	2121	{
sl@0	2122	res = KErrGeneral;
sl@0	2123	}
sl@0	2124	free(compr);
sl@0	2125	free(uncompr);
sl@0	2126	return res;
sl@0	2127	}
sl@0	2128
sl@0	2129	/**
sl@0	2130	* Function Name : TestCompress2_negative
sl@0	2131	* TestCase Description: Test compress2 with compression length less than required
sl@0	2132	* Return Value: Z_BUF_ERROR
sl@0	2133	*/
sl@0	2134	TInt CTestZlib::TestCompress2_negative()
sl@0	2135	{
sl@0	2136	int err;
sl@0	2137	TInt res = KErrNone ;
sl@0	2138	uLong len = (uLong)strlen(hello)+1;
sl@0	2139	Byte *compr;
sl@0	2140	uLong comprLen = 20*sizeof(int);
sl@0	2141	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2142	if (compr == Z_NULL)
sl@0	2143	{
sl@0	2144	return KErrNoMemory;
sl@0	2145	}
sl@0	2146	err=compress2(compr, &comprLen, (const Bytef*)hello, len,14);
sl@0	2147	if(err == 0)
sl@0	2148	{
sl@0	2149	res = KErrGeneral;
sl@0	2150	}
sl@0	2151	else
sl@0	2152	{
sl@0	2153	res = KErrNone ;
sl@0	2154	}
sl@0	2155	free(compr);
sl@0	2156	return res;
sl@0	2157	}
sl@0	2158
sl@0	2159
sl@0	2160	/**
sl@0	2161	* Function Name : test_compressbound
sl@0	2162	* TestCase Description: This is a global function used by many test functions
sl@0	2163	*/
sl@0	2164	TInt test_compressbound(Byte * compr,uLong comprLen)
sl@0	2165	{
sl@0	2166	TInt res = KErrNone ;
sl@0	2167	int err;
sl@0	2168	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	2169	err=compress(compr, &comprLen, (const Bytef*)hello, sourceLen);
sl@0	2170	if(err==0)
sl@0	2171	{
sl@0	2172	int x = compressBound(sourceLen);
sl@0	2173	if(x > sourceLen)
sl@0	2174	{
sl@0	2175	res = KErrNone ;
sl@0	2176	}
sl@0	2177	else
sl@0	2178	{
sl@0	2179	res = KErrGeneral;
sl@0	2180	}
sl@0	2181	}
sl@0	2182	else
sl@0	2183	{
sl@0	2184	res = KErrGeneral;
sl@0	2185	}
sl@0	2186	return res;
sl@0	2187	}
sl@0	2188
sl@0	2189	/**
sl@0	2190	* Function Name : TestCompressbound
sl@0	2191	* TestCase Description: 1. Call compress with appropriate arguments
sl@0	2192	* 2. Then verify the length of the compressed buffer using compressBound
sl@0	2193	* Return Value: Returns an upper bound on the compressed size after compression
sl@0	2194	*
sl@0	2195	*/
sl@0	2196	TInt CTestZlib::TestCompressbound()
sl@0	2197	{
sl@0	2198	TInt res = KErrNone ;
sl@0	2199	Byte *compr;
sl@0	2200	uLong comprLen =20*sizeof(int);
sl@0	2201	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2202	if (compr == Z_NULL)
sl@0	2203	{
sl@0	2204	return KErrNoMemory;
sl@0	2205	}
sl@0	2206
sl@0	2207	res = test_compressbound(compr, comprLen);
sl@0	2208	free(compr);
sl@0	2209	return res;
sl@0	2210	}
sl@0	2211
sl@0	2212	/**
sl@0	2213	* Function Name : test_deflatebound
sl@0	2214	* TestCase Description: This is a global function used by many test functions
sl@0	2215	*/
sl@0	2216	TInt test_deflatebound(Bytef dest, uLongf destLen, const Bytef *source, uLong sourceLen, int level)
sl@0	2217	{
sl@0	2218	TInt res = KErrNone ;
sl@0	2219	int err;
sl@0	2220	z_stream stream;
sl@0	2221	stream.next_in = (Bytef*)source;
sl@0	2222	stream.avail_in = (uInt)sourceLen;
sl@0	2223	stream.next_out = dest;
sl@0	2224	stream.avail_out = (uInt)*destLen;
sl@0	2225	if ((uLong)stream.avail_out != *destLen)
sl@0	2226	{
sl@0	2227	res = KErrGeneral;
sl@0	2228	}
sl@0	2229	stream.zalloc = (alloc_func)0;
sl@0	2230	stream.zfree = (free_func)0;
sl@0	2231	stream.opaque = (voidpf)0;
sl@0	2232
sl@0	2233	err = deflateInit(&stream, level);
sl@0	2234	if (err == Z_OK)
sl@0	2235	{
sl@0	2236	int y= deflateBound(&stream, sourceLen);
sl@0	2237	if(y > sourceLen)
sl@0	2238	{
sl@0	2239	res = KErrNone ;
sl@0	2240	}
sl@0	2241	else
sl@0	2242	{
sl@0	2243	res = KErrGeneral;
sl@0	2244	}
sl@0	2245	}
sl@0	2246	else
sl@0	2247	{
sl@0	2248	res = KErrGeneral;
sl@0	2249	return res;
sl@0	2250	}
sl@0	2251	err=deflateEnd(&stream);
sl@0	2252	if (err != Z_OK)
sl@0	2253	{
sl@0	2254	res = KErrGeneral;
sl@0	2255	}
sl@0	2256	return res;
sl@0	2257	}
sl@0	2258
sl@0	2259	/**
sl@0	2260	* Function Name : TestDeflatebound
sl@0	2261	* TestCase Description: 1. Compress the sample data using deflate
sl@0	2262	* 2. Then verify the length of the compressed buffer using deflateBound
sl@0	2263	* Return Value: Returns an upper bound on the compressed size after compression
sl@0	2264	*/
sl@0	2265	TInt CTestZlib::TestDeflatebound()
sl@0	2266	{
sl@0	2267	TInt res = KErrNone ;
sl@0	2268
sl@0	2269	uLong len = (uLong)strlen(hello)+1;
sl@0	2270	Byte compr, uncompr;
sl@0	2271	uLong comprLen = 20*sizeof(int);
sl@0	2272	uLong uncomprLen = comprLen;
sl@0	2273	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2274	if (compr == Z_NULL)
sl@0	2275	{
sl@0	2276	return KErrNoMemory;
sl@0	2277	}
sl@0	2278	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	2279	if(uncompr == Z_NULL)
sl@0	2280	{
sl@0	2281	free(compr);
sl@0	2282	return KErrNoMemory;
sl@0	2283	}
sl@0	2284	res=test_deflatebound(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION);
sl@0	2285	free(compr);
sl@0	2286	free(uncompr);
sl@0	2287	return res;
sl@0	2288	}
sl@0	2289
sl@0	2290	/**
sl@0	2291	* Function Name : TestDeflateparams
sl@0	2292	* TestCase Description: 1. deflateInit to initialize the internal stream state for compression
sl@0	2293	* 2. deflateParams with valid compression level and strategy
sl@0	2294	*
sl@0	2295	* Return Value: Z_OK
sl@0	2296	*/
sl@0	2297	TInt CTestZlib::TestDeflateparams()
sl@0	2298	{
sl@0	2299	TInt res = KErrNone ;
sl@0	2300	z_stream c_stream; /* compression stream */
sl@0	2301	int err;
sl@0	2302	Byte * compr;
sl@0	2303	uLong comprLen = 20*sizeof(int);
sl@0	2304	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2305	if (compr == Z_NULL)
sl@0	2306	{
sl@0	2307	return KErrNoMemory;
sl@0	2308	}
sl@0	2309	uLong len = (uLong)strlen(hello)+1;
sl@0	2310	c_stream.zalloc = (alloc_func)0;
sl@0	2311	c_stream.zfree = (free_func)0;
sl@0	2312	c_stream.opaque = (voidpf)0;
sl@0	2313
sl@0	2314	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	2315	if(err <0)
sl@0	2316	{
sl@0	2317	free(compr);
sl@0	2318	return err;
sl@0	2319	}
sl@0	2320	c_stream.next_in = (Bytef*)hello;
sl@0	2321	c_stream.next_out = compr;
sl@0	2322
sl@0	2323	err= deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
sl@0	2324	if(err != 0)
sl@0	2325	{
sl@0	2326	res = KErrGeneral;
sl@0	2327	}
sl@0	2328	deflateEnd(&c_stream);
sl@0	2329	free(compr);
sl@0	2330	return res;
sl@0	2331	}
sl@0	2332
sl@0	2333	/**
sl@0	2334	* Function Name : TestDeflateparamsfail1
sl@0	2335	* TestCase Description: 1. deflateInit to initialize the internal stream state for compression
sl@0	2336	* 2. deflateParams with invalid compression level
sl@0	2337	* Return Value: Z_STREAM_ERROR
sl@0	2338	*/
sl@0	2339	TInt CTestZlib::TestDeflateparamsfail1()
sl@0	2340	{
sl@0	2341	TInt res = KErrNone ;
sl@0	2342	z_stream c_stream; /* compression stream */
sl@0	2343	int err;
sl@0	2344	Byte * compr;
sl@0	2345	uLong comprLen = 20*sizeof(int);
sl@0	2346	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2347	if (compr == Z_NULL)
sl@0	2348	{
sl@0	2349	return KErrNoMemory;
sl@0	2350	}
sl@0	2351
sl@0	2352	uLong len = (uLong)strlen(hello)+1;
sl@0	2353	c_stream.zalloc = (alloc_func)0;
sl@0	2354	c_stream.zfree = (free_func)0;
sl@0	2355	c_stream.opaque = (voidpf)0;
sl@0	2356
sl@0	2357	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	2358	if(err<0)
sl@0	2359	{
sl@0	2360	free(compr);
sl@0	2361	return err;
sl@0	2362	}
sl@0	2363
sl@0	2364	c_stream.next_in = (Bytef*)hello;
sl@0	2365	c_stream.next_out = compr;
sl@0	2366
sl@0	2367	err= deflateParams(&c_stream, 12, Z_DEFAULT_STRATEGY);
sl@0	2368	if(err != 0)
sl@0	2369	{
sl@0	2370	res = KErrNone;
sl@0	2371	}
sl@0	2372	deflateEnd(&c_stream);
sl@0	2373	free(compr);
sl@0	2374	return res;
sl@0	2375	}
sl@0	2376
sl@0	2377	/**
sl@0	2378	* Function Name : TestDeflateparamsfail2
sl@0	2379	* TestCase Description: 1. deflateInit to initialize the internal stream state for compression
sl@0	2380	* 2. Pass NULL stream as argument to deflateParams
sl@0	2381	* Return Value: Z_STREAM_ERROR
sl@0	2382	*/
sl@0	2383	TInt CTestZlib::TestDeflateparamsfail2()
sl@0	2384	{
sl@0	2385	TInt res = KErrNone ;
sl@0	2386	int err= deflateParams(NULL, 12, Z_DEFAULT_STRATEGY);
sl@0	2387	if(err != 0)
sl@0	2388	{
sl@0	2389	res = KErrNone;
sl@0	2390	}
sl@0	2391
sl@0	2392	return res;
sl@0	2393	}
sl@0	2394
sl@0	2395	/**
sl@0	2396	* Function Name : TestCrcinit
sl@0	2397	* TestCase Description: Test crc32 with proper arguments
sl@0	2398	* Return Value: KErrNone
sl@0	2399	*/
sl@0	2400	TInt CTestZlib::TestCrcinit()
sl@0	2401	{
sl@0	2402	TInt res = KErrNone ;
sl@0	2403	unsigned long j=0L;
sl@0	2404	long crc = crc32(j,0, 0);
sl@0	2405
sl@0	2406	if(crc==0)
sl@0	2407	{
sl@0	2408	res = KErrNone ;
sl@0	2409	}
sl@0	2410	else
sl@0	2411	{
sl@0	2412	res = KErrGeneral;
sl@0	2413	}
sl@0	2414
sl@0	2415	return res;
sl@0	2416	}
sl@0	2417
sl@0	2418	/**
sl@0	2419	* Function Name : TestCrc
sl@0	2420	* TestCase Description: 1. Call crc32 with proper arguments
sl@0	2421	* 2. Call crc32 with with one of the arguments as an updated crc generated from previous call to crc32
sl@0	2422	* Return Value: KErrNone
sl@0	2423	*/
sl@0	2424	TInt CTestZlib::TestCrc()
sl@0	2425	{
sl@0	2426	TInt res = KErrNone ;
sl@0	2427	unsigned char buffer[5]="1234";
sl@0	2428	unsigned int i=4;
sl@0	2429	unsigned long j=0L;
sl@0	2430
sl@0	2431	long crc1 = crc32(j,0, 0);
sl@0	2432
sl@0	2433	long crc = crc32(crc1, &buffer[0], i);
sl@0	2434
sl@0	2435	INFO_PRINTF2(_L("buf %x"),crc);
sl@0	2436
sl@0	2437	if(crc==(long)2615402659LL)
sl@0	2438	{
sl@0	2439	res = KErrNone ;
sl@0	2440	}
sl@0	2441	else
sl@0	2442	{
sl@0	2443	res = KErrGeneral;
sl@0	2444	}
sl@0	2445
sl@0	2446	return res;
sl@0	2447	}
sl@0	2448
sl@0	2449	/**
sl@0	2450	* Function Name : TestGet_crc_table
sl@0	2451	* TestCase Description: Test get_crc_table
sl@0	2452	* Return Value: KErrNone
sl@0	2453	*/
sl@0	2454	TInt CTestZlib::TestGet_crc_table()
sl@0	2455	{
sl@0	2456	TInt res = KErrNone ;
sl@0	2457	const unsigned long* pcrc_32_tab;
sl@0	2458
sl@0	2459	pcrc_32_tab = get_crc_table();
sl@0	2460
sl@0	2461	if(pcrc_32_tab)
sl@0	2462	{
sl@0	2463	res = KErrNone ;
sl@0	2464	}
sl@0	2465	else
sl@0	2466	{
sl@0	2467	res = KErrGeneral;
sl@0	2468	}
sl@0	2469
sl@0	2470	return res;
sl@0	2471	}
sl@0	2472
sl@0	2473	/**
sl@0	2474	* Function Name : TestDeflateInit_
sl@0	2475	* TestCase Description: deflateInit_ with all valid arguments
sl@0	2476	* Return Value: KErrNone
sl@0	2477	*/
sl@0	2478	TInt CTestZlib::TestDeflateInit_()
sl@0	2479	{
sl@0	2480	TInt res = KErrNone ;
sl@0	2481	z_stream stream;
sl@0	2482	int err;
sl@0	2483
sl@0	2484	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	2485	Byte *compr;
sl@0	2486	uLong comprLen = 10*sizeof(int);
sl@0	2487	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2488	if (compr == Z_NULL)
sl@0	2489	{
sl@0	2490	return KErrNoMemory;
sl@0	2491	}
sl@0	2492
sl@0	2493	stream.zalloc = (alloc_func)0;
sl@0	2494	stream.zfree = (free_func)0;
sl@0	2495	stream.opaque = (voidpf)0;
sl@0	2496
sl@0	2497	err= deflateInit_(&stream, Z_DEFAULT_COMPRESSION, zlibVersion(), sizeof(z_stream));
sl@0	2498
sl@0	2499	if (err != Z_OK)
sl@0	2500	{
sl@0	2501	free(compr);
sl@0	2502	res = KErrGeneral;
sl@0	2503	return res;
sl@0	2504	}
sl@0	2505	else
sl@0	2506	{
sl@0	2507	res = KErrNone;
sl@0	2508	}
sl@0	2509	deflateEnd(&stream);
sl@0	2510	free(compr);
sl@0	2511	return res;
sl@0	2512	}
sl@0	2513
sl@0	2514	/**
sl@0	2515	* Function Name : TestDeflateInit_level
sl@0	2516	* TestCase Description: deflateInit_ with invalid compression level
sl@0	2517	* Return Value: Z_STREAM_ERROR
sl@0	2518	*/
sl@0	2519	TInt CTestZlib::TestDeflateInit_level()
sl@0	2520	{
sl@0	2521	TInt res = KErrNone ;
sl@0	2522	z_stream stream;
sl@0	2523	int err;
sl@0	2524	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	2525	Byte *compr;
sl@0	2526	uLong comprLen = 10*sizeof(int);
sl@0	2527	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2528	if (compr == Z_NULL)
sl@0	2529	{
sl@0	2530	return KErrNoMemory;
sl@0	2531	}
sl@0	2532
sl@0	2533	stream.zalloc = (alloc_func)0;
sl@0	2534	stream.zfree = (free_func)0;
sl@0	2535	stream.opaque = (voidpf)0;
sl@0	2536
sl@0	2537	err= deflateInit_(&stream, 11, zlibVersion(), sizeof(z_stream));
sl@0	2538
sl@0	2539	if (err != Z_OK)
sl@0	2540	{
sl@0	2541	res = KErrNone;
sl@0	2542	}
sl@0	2543	else
sl@0	2544	{
sl@0	2545	res = KErrGeneral;
sl@0	2546	}
sl@0	2547
sl@0	2548	free(compr);
sl@0	2549	return res;
sl@0	2550	}
sl@0	2551
sl@0	2552
sl@0	2553	/**
sl@0	2554	* Function Name : TestDeflateInit2_
sl@0	2555	* TestCase Description: deflateInit2_ with invalid compression level
sl@0	2556	* Return Value: Z_STREAM_ERROR
sl@0	2557	*/
sl@0	2558	TInt CTestZlib::TestDeflateInit2_()
sl@0	2559	{
sl@0	2560	TInt res = KErrNone ;
sl@0	2561	z_stream stream;
sl@0	2562	int err;
sl@0	2563
sl@0	2564	uLong sourceLen = (uLong)strlen(hello)+1;
sl@0	2565	Byte *compr;
sl@0	2566	uLong comprLen = 10*sizeof(int);
sl@0	2567	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2568	if (compr == Z_NULL)
sl@0	2569	{
sl@0	2570	return KErrNoMemory;
sl@0	2571	}
sl@0	2572
sl@0	2573	stream.zalloc = (alloc_func)0;
sl@0	2574	stream.zfree = (free_func)0;
sl@0	2575	stream.opaque = (voidpf)0;
sl@0	2576
sl@0	2577	err= deflateInit2_(&stream, 11, 8, 15, 8, 0, zlibVersion(), sizeof(z_stream));
sl@0	2578
sl@0	2579	if (err != Z_OK)
sl@0	2580	{
sl@0	2581	res = KErrNone;
sl@0	2582	}
sl@0	2583	else
sl@0	2584	{
sl@0	2585	res = KErrGeneral;
sl@0	2586	}
sl@0	2587	free(compr);
sl@0	2588	return res;
sl@0	2589	}
sl@0	2590
sl@0	2591
sl@0	2592	/**
sl@0	2593	* Function Name : TestDeflatefail
sl@0	2594	* TestCase Description: Set stream next_in and next_out to NULL and call deflateEnd
sl@0	2595	* Return Value: Z_STREAM_ERROR
sl@0	2596	*/
sl@0	2597	TInt CTestZlib::TestDeflatefail()
sl@0	2598	{
sl@0	2599	TInt res = KErrNone ;
sl@0	2600	z_stream c_stream; /* compression stream */
sl@0	2601	int err;
sl@0	2602	Byte * compr;
sl@0	2603	uLong comprLen = 20*sizeof(int);
sl@0	2604	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2605	if (compr == Z_NULL)
sl@0	2606	{
sl@0	2607	return KErrNoMemory;
sl@0	2608	}
sl@0	2609
sl@0	2610	uLong len = (uLong)strlen(hello)+1;
sl@0	2611
sl@0	2612	c_stream.zalloc = (alloc_func)0;
sl@0	2613	c_stream.zfree = (free_func)0;
sl@0	2614	c_stream.opaque = (voidpf)0;
sl@0	2615
sl@0	2616	res = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	2617	if(res <0)
sl@0	2618	{
sl@0	2619	free(compr);
sl@0	2620	return res;
sl@0	2621	}
sl@0	2622
sl@0	2623	c_stream.next_in = NULL;//(Bytef*)hello;
sl@0	2624	c_stream.next_out = NULL;//compr;
sl@0	2625
sl@0	2626	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	2627	{
sl@0	2628	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
sl@0	2629	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	2630	if(err == 0)
sl@0	2631	{
sl@0	2632	res = KErrGeneral;
sl@0	2633	}
sl@0	2634	else
sl@0	2635	{
sl@0	2636	res=KErrNone;
sl@0	2637	break;
sl@0	2638	}
sl@0	2639	}
sl@0	2640	/* Finish the stream, still forcing small buffers: */
sl@0	2641	res = deflateEnd(&c_stream);
sl@0	2642	free(compr);
sl@0	2643	return res;
sl@0	2644	}
sl@0	2645
sl@0	2646	/**
sl@0	2647	* Function Name : TestDeflatefail
sl@0	2648	* TestCase Description: Set stream avail_out to NULL and call deflateEnd
sl@0	2649	* Return Value: Z_STREAM_ERROR
sl@0	2650	*/
sl@0	2651	TInt CTestZlib::TestDeflatefail2()
sl@0	2652	{
sl@0	2653	TInt res = KErrNone ;
sl@0	2654	z_stream c_stream; /* compression stream */
sl@0	2655	int err;
sl@0	2656	Byte * compr;
sl@0	2657	uLong comprLen = 20*sizeof(int);
sl@0	2658
sl@0	2659	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	2660	if (compr == Z_NULL)
sl@0	2661	{
sl@0	2662	return KErrNoMemory;
sl@0	2663	}
sl@0	2664
sl@0	2665	uLong len = (uLong)strlen(hello)+1;
sl@0	2666	c_stream.zalloc = (alloc_func)0;
sl@0	2667	c_stream.zfree = (free_func)0;
sl@0	2668	c_stream.opaque = (voidpf)0;
sl@0	2669
sl@0	2670	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	2671
sl@0	2672	if(err <0)
sl@0	2673	{
sl@0	2674	free(compr);
sl@0	2675	return err;
sl@0	2676	}
sl@0	2677	c_stream.next_in = (Bytef*)hello;
sl@0	2678	c_stream.next_out = compr;
sl@0	2679
sl@0	2680	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	2681	{
sl@0	2682	c_stream.avail_in = 1;
sl@0	2683	c_stream.avail_out = 0; /* fail */
sl@0	2684	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	2685	if(err == 0)
sl@0	2686	{
sl@0	2687	res = KErrGeneral;
sl@0	2688	}
sl@0	2689	else
sl@0	2690	{
sl@0	2691	res=KErrNone;
sl@0	2692	break;
sl@0	2693	}
sl@0	2694	}
sl@0	2695
sl@0	2696	err = deflateEnd(&c_stream);
sl@0	2697	free(compr);
sl@0	2698	return res;
sl@0	2699	}
sl@0	2700
sl@0	2701	/**
sl@0	2702	* Function Name : TestZlibversion
sl@0	2703	* TestCase Description: Test Zlibversion
sl@0	2704	* Return Value: Z_OK
sl@0	2705	*/
sl@0	2706	TInt CTestZlib::TestZlibversion()
sl@0	2707	{
sl@0	2708	TInt res = KErrNone ;
sl@0	2709	if(strcmp(zlibVersion(), "1.2.3") != 0)
sl@0	2710	{
sl@0	2711	res=KErrGeneral;
sl@0	2712	ERR_PRINTF1(_L("using incorrect zlib version "));
sl@0	2713	}
sl@0	2714	return res;
sl@0	2715	}
sl@0	2716
sl@0	2717	/**
sl@0	2718	* Function Name : TestGzputc
sl@0	2719	* TestCase Description: 1. Open a gzfile in read mode
sl@0	2720	* 2. Write a character in the file using gzputc
sl@0	2721	* 3. Close the file
sl@0	2722	* Return Value: KErrNone
sl@0	2723	*/
sl@0	2724	TInt CTestZlib::TestGzputc()
sl@0	2725	{
sl@0	2726	TInt res = KErrNone ;
sl@0	2727	TInt res1 = KErrNone ;
sl@0	2728	gzFile file;
sl@0	2729	const char * fname = TESTFILE ;
sl@0	2730	file = gzopen(fname, "wb");
sl@0	2731	if (file == NULL)
sl@0	2732	{
sl@0	2733	res = KErrGeneral;
sl@0	2734	return res;
sl@0	2735	}
sl@0	2736	else
sl@0	2737	{
sl@0	2738	res1=gzputc(file, 'r');
sl@0	2739	if(res1<0)
sl@0	2740	{
sl@0	2741	res = KErrGeneral;
sl@0	2742	}
sl@0	2743	else
sl@0	2744	{
sl@0	2745	res = KErrNone;
sl@0	2746	}
sl@0	2747	}
sl@0	2748	int err= gzclose(file);
sl@0	2749	if (err != Z_OK)
sl@0	2750	{
sl@0	2751	res = KErrGeneral;
sl@0	2752	}
sl@0	2753	else
sl@0	2754	{
sl@0	2755	res = KErrNone;
sl@0	2756	}
sl@0	2757	return res;
sl@0	2758	}
sl@0	2759
sl@0	2760	/**
sl@0	2761	* Function Name : TestGzopen
sl@0	2762	* TestCase Description: 1. Open a gzfile in read mode
sl@0	2763	* 2. Close the file
sl@0	2764	* Return Value: KErrNone
sl@0	2765	*/
sl@0	2766	TInt CTestZlib::TestGzopen()
sl@0	2767	{
sl@0	2768	TInt res = KErrNone ;
sl@0	2769	gzFile file;
sl@0	2770	const char * fname = TESTFILE ;
sl@0	2771	file = gzopen(fname, "rb");
sl@0	2772	if (file == NULL)
sl@0	2773	{
sl@0	2774	res = KErrGeneral;
sl@0	2775	return res;
sl@0	2776	}
sl@0	2777	else
sl@0	2778	{
sl@0	2779	res = KErrNone;
sl@0	2780	}
sl@0	2781	int err=gzclose(file);
sl@0	2782	if (err != Z_OK)
sl@0	2783	{
sl@0	2784	res = KErrGeneral;
sl@0	2785	}
sl@0	2786	return res;
sl@0	2787	}
sl@0	2788
sl@0	2789	/**
sl@0	2790	* Function Name : TestGzopenmode
sl@0	2791	* TestCase Description: 1. Open a gzfile mentioning invalid mode
sl@0	2792	* Return Value: KErrNone
sl@0	2793	*/
sl@0	2794	TInt CTestZlib::TestGzopenmode()
sl@0	2795	{
sl@0	2796	TInt res = KErrNone ;
sl@0	2797	gzFile file;
sl@0	2798	const char * fname = TESTFILE ;
sl@0	2799	file = gzopen(fname, "xyz");
sl@0	2800	if (file == NULL)
sl@0	2801	{
sl@0	2802	res = KErrNone;
sl@0	2803	}
sl@0	2804	else
sl@0	2805	{
sl@0	2806	res = KErrGeneral;
sl@0	2807	}
sl@0	2808	return res;
sl@0	2809	}
sl@0	2810
sl@0	2811	/**
sl@0	2812	* Function Name : TestGzopenfail
sl@0	2813	* TestCase Description: Open a gzfile mentioning invalid path
sl@0	2814	* Return Value: KErrNone
sl@0	2815	*/
sl@0	2816	TInt CTestZlib::TestGzopenfail()
sl@0	2817	{
sl@0	2818	TInt res = KErrNone ;
sl@0	2819	gzFile file;
sl@0	2820	const char * fname = NOFILE ;
sl@0	2821	file = gzopen(fname, "wb");
sl@0	2822	if (file == NULL)
sl@0	2823	{
sl@0	2824	res =KErrNone;
sl@0	2825	}
sl@0	2826	else
sl@0	2827	{
sl@0	2828	res = KErrGeneral;
sl@0	2829	}
sl@0	2830	return res;
sl@0	2831	}
sl@0	2832
sl@0	2833	/**
sl@0	2834	* Function Name : TestGzputcfail
sl@0	2835	* TestCase Description: 1. Open a gzfile mentioning invalid path
sl@0	2836	* 2. Use gzputc to write a character
sl@0	2837	* Return Value: KErrNone
sl@0	2838	*/
sl@0	2839	TInt CTestZlib::TestGzputcfail()
sl@0	2840	{
sl@0	2841	TInt res = KErrNone ;
sl@0	2842	TInt res1 = KErrNone ;
sl@0	2843	gzFile file;
sl@0	2844	const char * fname = NOFILE ;
sl@0	2845	file = gzopen(fname, "wb");
sl@0	2846	if (file != NULL)
sl@0	2847	{
sl@0	2848	res = KErrGeneral;
sl@0	2849	return res;
sl@0	2850	}
sl@0	2851	else
sl@0	2852	{
sl@0	2853	res1=gzputc(file, 'r');
sl@0	2854	if(res1<0)
sl@0	2855	{
sl@0	2856	res = KErrNone;
sl@0	2857	}
sl@0	2858	else
sl@0	2859	{
sl@0	2860	res = KErrGeneral;
sl@0	2861	}
sl@0	2862	}
sl@0	2863
sl@0	2864	int err= gzclose(file);
sl@0	2865	if (err == Z_OK)
sl@0	2866	{
sl@0	2867	res = KErrGeneral;
sl@0	2868	}
sl@0	2869	else
sl@0	2870	{
sl@0	2871	res = KErrNone;
sl@0	2872	}
sl@0	2873	return res;
sl@0	2874	}
sl@0	2875
sl@0	2876	/**
sl@0	2877	* Function Name : TestGzputcreturn
sl@0	2878	* TestCase Description: 1. Open a gzfile in write mode
sl@0	2879	* 2. Write a character in the file using gzputc
sl@0	2880	* 3. Verify the character written by comparing it with what is written
sl@0	2881	* 4. Close the file
sl@0	2882	* Return Value: returns the value of the character that was written
sl@0	2883	*/
sl@0	2884	TInt CTestZlib::TestGzputcreturn()
sl@0	2885	{
sl@0	2886	TInt res = KErrNone ;
sl@0	2887	TInt res1 = KErrNone ;
sl@0	2888	gzFile file;
sl@0	2889	const char * fname = TESTFILE ;
sl@0	2890	file = gzopen(fname, "wb");
sl@0	2891
sl@0	2892	if (file == NULL)
sl@0	2893	{
sl@0	2894	res = KErrGeneral;
sl@0	2895	return res;
sl@0	2896	}
sl@0	2897	else
sl@0	2898	{
sl@0	2899	res1=gzputc(file, 'r');
sl@0	2900	if(res1!=(int)'r')
sl@0	2901	{
sl@0	2902	res = KErrGeneral;
sl@0	2903	}
sl@0	2904	else
sl@0	2905	{
sl@0	2906	res = KErrNone;
sl@0	2907	}
sl@0	2908	}
sl@0	2909
sl@0	2910	int err= gzclose(file);
sl@0	2911	if (err != Z_OK)
sl@0	2912	{
sl@0	2913	res = KErrGeneral;
sl@0	2914	}
sl@0	2915	return res;
sl@0	2916	}
sl@0	2917
sl@0	2918	/**
sl@0	2919	* Function Name : TestGzputs
sl@0	2920	* TestCase Description: 1. Open a gzfile in write mode
sl@0	2921	* 2. Write a string into file
sl@0	2922	* 3. Close the file
sl@0	2923	* Return Value: KErrNone
sl@0	2924	*/
sl@0	2925	TInt CTestZlib::TestGzputs()
sl@0	2926	{
sl@0	2927	TInt res = KErrNone ;
sl@0	2928	gzFile file;
sl@0	2929	const char * fname = TESTFILE ;
sl@0	2930	file = gzopen(fname, "wb");
sl@0	2931	if (file == NULL)
sl@0	2932	{
sl@0	2933	res = KErrGeneral;
sl@0	2934	return res;
sl@0	2935	}
sl@0	2936	if (gzputs(file, "ello") != 4)
sl@0	2937	{
sl@0	2938	ERR_PRINTF1(_L("gzputs err"));
sl@0	2939	}
sl@0	2940	int err= gzclose(file);
sl@0	2941	if (err != Z_OK)
sl@0	2942	{
sl@0	2943	res = KErrGeneral;
sl@0	2944	}
sl@0	2945	return res;
sl@0	2946	}
sl@0	2947
sl@0	2948	/**
sl@0	2949	* Function Name : TestGzputsfail
sl@0	2950	* TestCase Description: 1. Open a gzfile in read mode
sl@0	2951	* 2. Write a string into file
sl@0	2952	* 3. Close the file
sl@0	2953	* Return Value: KErrNone
sl@0	2954	*/
sl@0	2955	TInt CTestZlib::TestGzputsfail()
sl@0	2956	{
sl@0	2957	TInt res = KErrNone ;
sl@0	2958	gzFile file;
sl@0	2959	const char *fname = TESTFILE ;
sl@0	2960	file = gzopen(fname, "rb");
sl@0	2961	if (file == NULL)
sl@0	2962	{
sl@0	2963	res = KErrGeneral;
sl@0	2964	return res;
sl@0	2965	}
sl@0	2966	if(gzputs(file, "ello") == 4)
sl@0	2967	{
sl@0	2968	res= KErrGeneral;
sl@0	2969	}
sl@0	2970	int err= gzclose(file);
sl@0	2971	if (err != Z_OK)
sl@0	2972	{
sl@0	2973	res = KErrGeneral;
sl@0	2974	}
sl@0	2975	return res;
sl@0	2976	}
sl@0	2977
sl@0	2978	/**
sl@0	2979	* Function Name : TestGzprintf
sl@0	2980	* TestCase Description: 1. Open a gzfile in write mode
sl@0	2981	* 2. Write a string into file mentioning the valid format specifier
sl@0	2982	* 3. Close the file
sl@0	2983	* Return Value: KErrNone
sl@0	2984	*/
sl@0	2985	TInt CTestZlib::TestGzprintf()
sl@0	2986	{
sl@0	2987	TInt res = KErrNone ;
sl@0	2988	gzFile file;
sl@0	2989	const char * fname = TESTFILE ;
sl@0	2990	file = gzopen(fname, "wb");
sl@0	2991	if(file == NULL)
sl@0	2992	{
sl@0	2993	res = KErrNoMemory;
sl@0	2994	return res;
sl@0	2995	}
sl@0	2996	if(gzprintf(file, ", %s!", "hello") != 8)
sl@0	2997	{
sl@0	2998	ERR_PRINTF1(_L("gzprintf err"));
sl@0	2999	return KErrNone;
sl@0	3000	}
sl@0	3001
sl@0	3002	int err = gzclose(file);
sl@0	3003	if(err == 0)
sl@0	3004	{
sl@0	3005	res = KErrNone ;
sl@0	3006	}
sl@0	3007	else
sl@0	3008	{
sl@0	3009	res =res= KErrGeneral;
sl@0	3010	}
sl@0	3011	return res;
sl@0	3012	}
sl@0	3013
sl@0	3014	/**
sl@0	3015	* Function Name : TestGzprintf_trying
sl@0	3016	* TestCase Description: 1. Open a gzfile in read mode
sl@0	3017	* 2. Write a string into file mentioning the valid format specifier
sl@0	3018	* 3. Close the file
sl@0	3019	* Return Value: KErrNone
sl@0	3020	*/
sl@0	3021	TInt CTestZlib::TestGzprintf_trying()
sl@0	3022	{
sl@0	3023	TInt res = KErrNone ;
sl@0	3024	gzFile file;
sl@0	3025	const char * fname = TESTFILE ;
sl@0	3026	file = gzopen(fname, "rb");
sl@0	3027	if (file == NULL)
sl@0	3028	{
sl@0	3029	res = KErrNoMemory;
sl@0	3030	return res;
sl@0	3031	}
sl@0	3032	if (gzprintf(file, ", %s!", "hello") != 8)
sl@0	3033	{
sl@0	3034	gzclose(file);
sl@0	3035	res=KErrGeneral;
sl@0	3036	ERR_PRINTF1(_L("gzprintf err"));
sl@0	3037	return KErrNone;
sl@0	3038	}
sl@0	3039	int err = gzclose(file);
sl@0	3040	if(err == 0)
sl@0	3041	{
sl@0	3042	res = KErrNone ;
sl@0	3043	}
sl@0	3044	else
sl@0	3045	{
sl@0	3046	res = KErrGeneral;
sl@0	3047	}
sl@0	3048	return res;
sl@0	3049	}
sl@0	3050
sl@0	3051	/**
sl@0	3052	* Function Name : TestGzprintf_trying
sl@0	3053	* TestCase Description: 1. Open a gzfile in write mode
sl@0	3054	* 2. Write a string into file mentioning the valid arguments for gzwrite
sl@0	3055	* 3. Close the file
sl@0	3056	* Return Value: KErrNone
sl@0	3057	*/
sl@0	3058	TInt CTestZlib::TestGzwrite()
sl@0	3059	{
sl@0	3060	TInt res = KErrNone ;
sl@0	3061	gzFile file;
sl@0	3062	uInt size ,len;
sl@0	3063	const char *s="ritesh";
sl@0	3064	len=strlen(s);
sl@0	3065	const char * fname = TESTFILE ;
sl@0	3066	file = gzopen(fname, "wb");
sl@0	3067	if (file == Z_NULL)
sl@0	3068	{
sl@0	3069	res = KErrGeneral;
sl@0	3070	return res;
sl@0	3071	}
sl@0	3072	size = gzwrite(file, (char*)s, (unsigned)strlen(s));
sl@0	3073	if(len!=size)
sl@0	3074	{
sl@0	3075	res = KErrGeneral;
sl@0	3076	}
sl@0	3077	int err= gzclose(file);
sl@0	3078	if (err != Z_OK)
sl@0	3079	{
sl@0	3080	res = KErrGeneral;
sl@0	3081	}
sl@0	3082	return res;
sl@0	3083	}
sl@0	3084
sl@0	3085	/**
sl@0	3086	* Function Name : TestGzwritefail
sl@0	3087	* TestCase Description: 1. Open a gzfile in read mode
sl@0	3088	* 2. Write a string into file mentioning the valid arguments for gzwrite
sl@0	3089	* 3. Close the file
sl@0	3090	* Return Value: Z_NULL
sl@0	3091	*/
sl@0	3092	TInt CTestZlib::TestGzwritefail()
sl@0	3093	{
sl@0	3094	TInt res = KErrNone ;
sl@0	3095	gzFile file;
sl@0	3096	uInt size ,len;
sl@0	3097	const char *s="ritesh";
sl@0	3098	len=strlen(s);
sl@0	3099	const char * fname = TESTFILE ;
sl@0	3100	file = gzopen(fname, "rb"); //read mode
sl@0	3101	if (file == Z_NULL)
sl@0	3102	{
sl@0	3103	res = KErrNoMemory;
sl@0	3104	return res;
sl@0	3105	}
sl@0	3106	size = gzwrite(file, (char*)s, (unsigned)strlen(s));
sl@0	3107	if(len!=size)
sl@0	3108	{
sl@0	3109	res = KErrNone;
sl@0	3110	}
sl@0	3111	int err= gzclose(file);
sl@0	3112	if (err != Z_OK)
sl@0	3113	{
sl@0	3114	res = KErrGeneral;
sl@0	3115	}
sl@0	3116	return res;
sl@0	3117	}
sl@0	3118
sl@0	3119	TInt testgztell( const char * fname, Byte * uncompr,uLong uncomprLen)
sl@0	3120	{
sl@0	3121	int err=0;
sl@0	3122	int len = (int)strlen(hello)+1;
sl@0	3123	gzFile file;
sl@0	3124	z_off_t pos;
sl@0	3125
sl@0	3126	file = gzopen(fname, "wb");
sl@0	3127	if (file == NULL)
sl@0	3128	{
sl@0	3129	if (file == NULL)
sl@0	3130	{
sl@0	3131	err = KErrGeneral;
sl@0	3132	return err;
sl@0	3133	}
sl@0	3134
sl@0	3135	}
sl@0	3136	gzputc(file, 'h');
sl@0	3137	if(gzputs(file, "ello") != 4)
sl@0	3138	{
sl@0	3139	//fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
sl@0	3140	}
sl@0	3141	if(gzprintf(file, ", %s!", "hello") != 8)
sl@0	3142	{
sl@0	3143	//fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
sl@0	3144	}
sl@0	3145	gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
sl@0	3146	gzclose(file);
sl@0	3147
sl@0	3148	file = gzopen(fname, "rb");
sl@0	3149	if(file == NULL)
sl@0	3150	{
sl@0	3151	err = KErrGeneral;
sl@0	3152	return err;
sl@0	3153	}
sl@0	3154	strcpy((char*)uncompr, "garbage");
sl@0	3155	if(gzread(file, uncompr, (unsigned)uncomprLen) != len)
sl@0	3156	{
sl@0	3157	//fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
sl@0	3158	//exit(1);
sl@0	3159	}
sl@0	3160	if(strcmp((char*)uncompr, hello))
sl@0	3161	{
sl@0	3162	//fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
sl@0	3163	////exit(1);
sl@0	3164	}
sl@0	3165	else
sl@0	3166	{
sl@0	3167	//printf("gzread(): %s\n", (char*)uncompr);
sl@0	3168	}
sl@0	3169
sl@0	3170	pos = gzseek(file, -8L, SEEK_CUR);
sl@0	3171	if (pos != 6 \|\| gztell(file) != pos)
sl@0	3172	{
sl@0	3173	err=-1;
sl@0	3174	}
sl@0	3175	err= gzclose(file);
sl@0	3176	return err;
sl@0	3177	}
sl@0	3178
sl@0	3179	TInt CTestZlib::TestGztell()
sl@0	3180	{
sl@0	3181	TInt res = KErrNone ;
sl@0	3182	Byte compr, uncompr;
sl@0	3183	uLong comprLen = 20*sizeof(int);
sl@0	3184	uLong uncomprLen = comprLen;
sl@0	3185	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3186	if (compr == Z_NULL)
sl@0	3187	{
sl@0	3188	return KErrNoMemory;
sl@0	3189	}
sl@0	3190	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3191	if (uncompr == Z_NULL)
sl@0	3192	{
sl@0	3193	free(compr);
sl@0	3194	return KErrNoMemory;
sl@0	3195	}
sl@0	3196	test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	3197	int err = testgztell(TESTFILE,uncompr, uncomprLen);
sl@0	3198	if(err<0)
sl@0	3199	{
sl@0	3200	res= KErrGeneral;
sl@0	3201	}
sl@0	3202	free(compr);
sl@0	3203	free(uncompr);
sl@0	3204	return res;
sl@0	3205	}
sl@0	3206
sl@0	3207	TInt CTestZlib::TestGztell1()
sl@0	3208	{
sl@0	3209	TInt res = KErrNone ;
sl@0	3210	int err;
sl@0	3211	gzFile file;
sl@0	3212	file = gzopen(TESTFILE, "wb");
sl@0	3213	if (file == NULL)
sl@0	3214	{
sl@0	3215	res = KErrGeneral;
sl@0	3216	return res;
sl@0	3217	}
sl@0	3218	err=gztell(file) ;
sl@0	3219	if(err<0)
sl@0	3220	{
sl@0	3221	res = KErrGeneral;
sl@0	3222	return res;
sl@0	3223	}
sl@0	3224	err= gzclose(file);
sl@0	3225	if(err != Z_OK)
sl@0	3226	{
sl@0	3227	res = KErrGeneral;
sl@0	3228	}
sl@0	3229	return res;
sl@0	3230	}
sl@0	3231
sl@0	3232	TInt CTestZlib::TestGztellfail1()
sl@0	3233	{
sl@0	3234	TInt res = KErrNone ;
sl@0	3235	int err;
sl@0	3236	gzFile file;
sl@0	3237	file = gzopen(NOFILE, "wb");
sl@0	3238	if (file == NULL)
sl@0	3239	{
sl@0	3240	res = KErrNone;
sl@0	3241	return res;
sl@0	3242	}
sl@0	3243	err=gztell(file) ;
sl@0	3244	if(err>0)
sl@0	3245	{
sl@0	3246	res= KErrGeneral;
sl@0	3247	}
sl@0	3248	return res;
sl@0	3249	}
sl@0	3250
sl@0	3251	int test_deflatecopy (Bytef dest, uLongf destLen, const Bytef *source, uLong sourceLen, int level)
sl@0	3252	{
sl@0	3253	TInt res = KErrNone ;
sl@0	3254	z_stream stream;
sl@0	3255	z_stream stream1;
sl@0	3256	int err;
sl@0	3257
sl@0	3258	stream.zalloc = (alloc_func)0;
sl@0	3259	stream.zfree = (free_func)0;
sl@0	3260	stream.opaque = (voidpf)0;
sl@0	3261
sl@0	3262	stream.next_in = (Bytef*)source;
sl@0	3263	stream.avail_in = (uInt)sourceLen;
sl@0	3264
sl@0	3265	stream.next_out = dest;
sl@0	3266	stream.avail_out = (uInt)*destLen;
sl@0	3267	if ((uLong)stream.avail_out != *destLen)
sl@0	3268	{
sl@0	3269	res = KErrGeneral;
sl@0	3270	}
sl@0	3271
sl@0	3272	err = deflateInit(&stream, level);
sl@0	3273	if (err != Z_OK)
sl@0	3274	{
sl@0	3275	res = KErrGeneral;
sl@0	3276	return res;
sl@0	3277	}
sl@0	3278	err=deflateCopy(&stream1 , &stream);
sl@0	3279	if (err != Z_OK)
sl@0	3280	{
sl@0	3281	res = KErrGeneral;
sl@0	3282	}
sl@0	3283	err=deflateEnd(&stream);
sl@0	3284	if (err != Z_OK)
sl@0	3285	{
sl@0	3286	res = KErrGeneral;
sl@0	3287	}
sl@0	3288	err=deflateEnd(&stream1);
sl@0	3289	if (err != Z_OK)
sl@0	3290	{
sl@0	3291	res = KErrGeneral;
sl@0	3292	}
sl@0	3293	return res;
sl@0	3294	}
sl@0	3295
sl@0	3296	TInt CTestZlib::TestDeflatecopy()
sl@0	3297	{
sl@0	3298	TInt res;
sl@0	3299	uLong len = (uLong)strlen(hello)+1;
sl@0	3300
sl@0	3301	Byte compr, uncompr;
sl@0	3302	uLong comprLen = 20*sizeof(int);
sl@0	3303	uLong uncomprLen = comprLen;
sl@0	3304	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3305	if (compr == Z_NULL)
sl@0	3306	{
sl@0	3307	return KErrNoMemory;
sl@0	3308	}
sl@0	3309	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3310	if (uncompr == Z_NULL)
sl@0	3311	{
sl@0	3312	free(compr);
sl@0	3313	return KErrNoMemory;
sl@0	3314	}
sl@0	3315	res= test_deflatecopy(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION);
sl@0	3316	free(compr);
sl@0	3317	free(uncompr);
sl@0	3318	return res;
sl@0	3319	}
sl@0	3320
sl@0	3321
sl@0	3322	TInt CTestZlib::TestDeflatecopyfail()
sl@0	3323	{
sl@0	3324	TInt res = KErrNone ;int err;
sl@0	3325	z_stream stream1;
sl@0	3326	uLong len = (uLong)strlen(hello)+1;
sl@0	3327
sl@0	3328	Byte *compr;
sl@0	3329	uLong comprLen = 20*sizeof(int);
sl@0	3330	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3331
sl@0	3332	if (compr == Z_NULL)
sl@0	3333	{
sl@0	3334	return KErrNoMemory;
sl@0	3335	}
sl@0	3336	err=deflateCopy(&stream1 , NULL);
sl@0	3337	if (err == Z_OK)
sl@0	3338	{
sl@0	3339	res = KErrNone;
sl@0	3340	}
sl@0	3341
sl@0	3342	free(compr);
sl@0	3343	return res;
sl@0	3344	}
sl@0	3345
sl@0	3346
sl@0	3347	TInt CTestZlib::TestGzclose()
sl@0	3348	{
sl@0	3349	TInt res = KErrNone ;
sl@0	3350	int err;
sl@0	3351	int len = (int)strlen(hello)+1;
sl@0	3352	gzFile file;
sl@0	3353
sl@0	3354	const char * fname = TESTFILE;
sl@0	3355	file = gzopen(fname, "wb");
sl@0	3356	gzputc(file, 'h');
sl@0	3357
sl@0	3358	err= gzclose(file);
sl@0	3359
sl@0	3360	if(err != 0)
sl@0	3361	{
sl@0	3362	res = KErrGeneral;
sl@0	3363	}
sl@0	3364	return res;
sl@0	3365	}
sl@0	3366
sl@0	3367
sl@0	3368	TInt CTestZlib::TestGzclose_fail()
sl@0	3369	{
sl@0	3370	TInt res = KErrNone ;
sl@0	3371	int err;
sl@0	3372	int len = (int)strlen(hello)+1;
sl@0	3373	gzFile file;
sl@0	3374	const char * fname = NOFILE;
sl@0	3375
sl@0	3376	file = gzopen(fname, "wb");
sl@0	3377
sl@0	3378	err=gzclose(file);
sl@0	3379	if(err == 0)
sl@0	3380	{
sl@0	3381	res = KErrGeneral;
sl@0	3382	}
sl@0	3383	return res;
sl@0	3384	}
sl@0	3385
sl@0	3386	TInt CTestZlib::TestGzeof()
sl@0	3387	{
sl@0	3388	TInt res = KErrNone ;
sl@0	3389	gzFile file;
sl@0	3390	const char * fname = TESTFILE ;
sl@0	3391	file = gzopen(fname, "wb");
sl@0	3392	if (file == NULL)
sl@0	3393	{
sl@0	3394	res = KErrGeneral;
sl@0	3395	return res;
sl@0	3396	}
sl@0	3397
sl@0	3398	if (gzputs(file, "ello") != 4)
sl@0	3399	{
sl@0	3400	ERR_PRINTF1(_L("gzputs err"));
sl@0	3401	return KErrNone;
sl@0	3402	}
sl@0	3403	int x=gzeof(file);
sl@0	3404	if(x!=0)
sl@0	3405	{
sl@0	3406	res= KErrGeneral;
sl@0	3407	}
sl@0	3408
sl@0	3409	int err= gzclose(file);
sl@0	3410	if (err != Z_OK)
sl@0	3411	{
sl@0	3412	res = KErrGeneral;
sl@0	3413	}
sl@0	3414	return res;
sl@0	3415	}
sl@0	3416
sl@0	3417	TInt CTestZlib::TestGzeoffail1()
sl@0	3418	{
sl@0	3419	TInt res = KErrNone ;
sl@0	3420	gzFile file;
sl@0	3421	const char * fname = TESTFILE ;
sl@0	3422	file = gzopen(fname, "rb");
sl@0	3423	if (file == NULL)
sl@0	3424	{
sl@0	3425	res = KErrGeneral;
sl@0	3426	return res;
sl@0	3427	}
sl@0	3428	int x=gzeof(file);
sl@0	3429	if(x!=Z_STREAM_END)
sl@0	3430	{
sl@0	3431	res= KErrNone;
sl@0	3432	}
sl@0	3433
sl@0	3434	int err= gzclose(file);
sl@0	3435	if (err != Z_OK)
sl@0	3436	{
sl@0	3437	res = KErrGeneral;
sl@0	3438	}
sl@0	3439	return res;
sl@0	3440	}
sl@0	3441
sl@0	3442	TInt CTestZlib::TestGzeoffail2()
sl@0	3443	{
sl@0	3444	TInt res = KErrNone ;
sl@0	3445	gzFile file;
sl@0	3446	const char * fname = NOFILE ;
sl@0	3447	file = gzopen(fname, "wb");
sl@0	3448	int x=gzeof(file);
sl@0	3449	if(x!=0)
sl@0	3450	{
sl@0	3451	res= KErrNone;
sl@0	3452	}
sl@0	3453	int err= gzclose(file);
sl@0	3454	if (err == Z_OK)
sl@0	3455	{
sl@0	3456	res = KErrGeneral;
sl@0	3457	}
sl@0	3458	return res;
sl@0	3459	}
sl@0	3460
sl@0	3461	TInt CTestZlib::TestGzgetc()
sl@0	3462	{
sl@0	3463	TInt res = KErrNone ;
sl@0	3464	gzFile file;
sl@0	3465	const char * fname = TESTFILE ;
sl@0	3466	file = gzopen(fname, "rb");
sl@0	3467	if (file == Z_NULL)
sl@0	3468	{
sl@0	3469	res = KErrNoMemory;
sl@0	3470	return res;
sl@0	3471	}
sl@0	3472	int l= gzgetc(file);
sl@0	3473	int err= gzclose(file);
sl@0	3474	if (err != Z_OK)
sl@0	3475	{
sl@0	3476	res = KErrGeneral;
sl@0	3477	}
sl@0	3478	return res;
sl@0	3479	}
sl@0	3480
sl@0	3481
sl@0	3482	TInt CTestZlib::TestGzflush()
sl@0	3483	{
sl@0	3484	TInt res = KErrNone ;
sl@0	3485	gzFile file;
sl@0	3486	const char * fname = TESTFILE ;
sl@0	3487	file = gzopen(fname, "wb");
sl@0	3488	if (file == Z_NULL)
sl@0	3489	{
sl@0	3490	res = KErrNoMemory;
sl@0	3491	return res;
sl@0	3492	}
sl@0	3493	int l= gzflush(file,Z_FULL_FLUSH);
sl@0	3494	if(l != Z_OK)
sl@0	3495	{
sl@0	3496	res = KErrGeneral;
sl@0	3497	}
sl@0	3498
sl@0	3499	int err=gzclose(file);
sl@0	3500	if (err != Z_OK)
sl@0	3501	{
sl@0	3502	res = KErrGeneral;
sl@0	3503	}
sl@0	3504	return res;
sl@0	3505	}
sl@0	3506
sl@0	3507
sl@0	3508	TInt CTestZlib::TestGzflushsync()
sl@0	3509	{
sl@0	3510	TInt res = KErrNone ;
sl@0	3511	gzFile file;
sl@0	3512	const char * fname = TESTFILE ;
sl@0	3513	file = gzopen(fname, "wb");
sl@0	3514	if (file == Z_NULL)
sl@0	3515	{
sl@0	3516	res = KErrNoMemory;
sl@0	3517	return res;
sl@0	3518	}
sl@0	3519	int l= gzflush(file,Z_SYNC_FLUSH);
sl@0	3520	if (l != Z_OK)
sl@0	3521	{
sl@0	3522	res = KErrGeneral;
sl@0	3523	}
sl@0	3524	int err= gzclose(file);
sl@0	3525	if(err != Z_OK)
sl@0	3526	{
sl@0	3527	res = KErrGeneral;
sl@0	3528	}
sl@0	3529	return res;
sl@0	3530	}
sl@0	3531
sl@0	3532	TInt CTestZlib::TestGzflushfail()
sl@0	3533	{
sl@0	3534	TInt res = KErrNone ;
sl@0	3535	gzFile file;
sl@0	3536	const char * fname = TESTFILE ;
sl@0	3537	file = gzopen(fname, "rb");
sl@0	3538	if (file == Z_NULL)
sl@0	3539	{
sl@0	3540	res = KErrGeneral;
sl@0	3541	return res;
sl@0	3542	}
sl@0	3543	int l= gzflush(file,Z_FULL_FLUSH);
sl@0	3544	if (l == Z_OK)
sl@0	3545	{
sl@0	3546	res = KErrGeneral;
sl@0	3547	}
sl@0	3548	int err= gzclose(file);
sl@0	3549	if (err != Z_OK)
sl@0	3550	{
sl@0	3551	res = KErrGeneral;
sl@0	3552	}
sl@0	3553	return res;
sl@0	3554	}
sl@0	3555
sl@0	3556	TInt CTestZlib::TestGzerror()
sl@0	3557	{
sl@0	3558	TInt res = KErrNone ;
sl@0	3559	int err;
sl@0	3560	int len = (int)strlen(hello)+1;
sl@0	3561	gzFile file;
sl@0	3562	const char * fname = TESTFILE ;
sl@0	3563	file = gzopen(fname, "wb");
sl@0	3564	if (file == NULL)
sl@0	3565	{
sl@0	3566	res=KErrGeneral;
sl@0	3567	}
sl@0	3568	gzputc(file, 'h');
sl@0	3569	if (gzputs(file, "ello") != 5)
sl@0	3570	{
sl@0	3571	gzprintf(file, "gzputs err: %s\n", gzerror(file, &err));
sl@0	3572	res=KErrGeneral;
sl@0	3573	}
sl@0	3574	err= gzclose(file);
sl@0	3575	if (err != Z_OK)
sl@0	3576	{
sl@0	3577	res = KErrGeneral;
sl@0	3578	}
sl@0	3579	else
sl@0	3580	{
sl@0	3581	res = KErrNone;
sl@0	3582	}
sl@0	3583	return res;
sl@0	3584	}
sl@0	3585
sl@0	3586
sl@0	3587	TInt CTestZlib::TestGzerrorfail1()
sl@0	3588	{
sl@0	3589	TInt res = KErrNone ;
sl@0	3590	int err;
sl@0	3591	int len = (int)strlen(hello)+1;
sl@0	3592	gzFile file;
sl@0	3593	const char * fname = NOFILE ;
sl@0	3594	file = gzopen(fname, "wb");
sl@0	3595	if (file != NULL)
sl@0	3596	{
sl@0	3597	res=KErrGeneral;
sl@0	3598	return res;
sl@0	3599	}
sl@0	3600	gzputc(file, 'h');
sl@0	3601	if (gzputs(file, "ello") != 5)
sl@0	3602	{
sl@0	3603	gzprintf(file, "gzputs err: %s\n", gzerror(file, &err));
sl@0	3604	res=KErrNone;
sl@0	3605	}
sl@0	3606	err= gzclose(file);
sl@0	3607	if (err == Z_OK)
sl@0	3608	{
sl@0	3609	res = KErrGeneral;
sl@0	3610	}
sl@0	3611	return res;
sl@0	3612	}
sl@0	3613
sl@0	3614
sl@0	3615	TInt CTestZlib::TestGzgetcfail()
sl@0	3616	{
sl@0	3617	TInt res = KErrNone ;
sl@0	3618	gzFile file;
sl@0	3619	const char * fname = TESTFILE ;
sl@0	3620	file = gzopen(fname, "wb");
sl@0	3621	if (file == Z_NULL)
sl@0	3622	{
sl@0	3623	res = KErrNoMemory;
sl@0	3624	return res;
sl@0	3625	}
sl@0	3626	int l= gzgetc(file);
sl@0	3627	int err= gzclose(file);
sl@0	3628	if (err != Z_OK)
sl@0	3629	{
sl@0	3630	res = KErrGeneral;
sl@0	3631	}
sl@0	3632	return res;
sl@0	3633	}
sl@0	3634
sl@0	3635
sl@0	3636	TInt CTestZlib::TestDeflateSetDictionary()
sl@0	3637	{
sl@0	3638	TInt res = KErrNone ;
sl@0	3639	Byte compr, uncompr;
sl@0	3640	uLong comprLen = 20*sizeof(int);
sl@0	3641	uLong uncomprLen = comprLen;
sl@0	3642
sl@0	3643	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3644	if (compr == Z_NULL)
sl@0	3645	{
sl@0	3646	return KErrNoMemory;
sl@0	3647	}
sl@0	3648	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3649	if (uncompr == Z_NULL)
sl@0	3650	{
sl@0	3651	free(compr);
sl@0	3652	return KErrNoMemory;
sl@0	3653	}
sl@0	3654
sl@0	3655	res = test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	3656	if(res < 0)
sl@0	3657	{
sl@0	3658	free(compr);
sl@0	3659	free(uncompr);
sl@0	3660	return KErrNoMemory;
sl@0	3661	}
sl@0	3662	res=Test_dict_deflate(compr, comprLen);
sl@0	3663	free(compr);
sl@0	3664	free(uncompr);
sl@0	3665	return res;
sl@0	3666	}
sl@0	3667
sl@0	3668
sl@0	3669
sl@0	3670	TInt CTestZlib::TestDeflateSetDictionary_nodict()
sl@0	3671	{
sl@0	3672	TInt res = KErrNone ;
sl@0	3673	Byte compr, uncompr;
sl@0	3674	uLong comprLen = 20*sizeof(int);
sl@0	3675	uLong uncomprLen = comprLen;
sl@0	3676	z_stream c_stream; /* compression stream */
sl@0	3677	int err;
sl@0	3678
sl@0	3679	c_stream.zalloc = (alloc_func)0;
sl@0	3680	c_stream.zfree = (free_func)0;
sl@0	3681	c_stream.opaque = (voidpf)0;
sl@0	3682
sl@0	3683	err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
sl@0	3684	if(err < 0)
sl@0	3685	{
sl@0	3686	return Z_MEM_ERROR;
sl@0	3687	}
sl@0	3688	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3689	if (compr == Z_NULL)
sl@0	3690	{
sl@0	3691	return KErrNoMemory;
sl@0	3692	}
sl@0	3693	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3694	if (uncompr == Z_NULL)
sl@0	3695	{
sl@0	3696	free(compr);
sl@0	3697	return KErrNoMemory;
sl@0	3698	}
sl@0	3699	err = deflateSetDictionary(&c_stream,NULL, sizeof(dictionary));
sl@0	3700	if(err != 0)
sl@0	3701	{
sl@0	3702	res = KErrNone ;
sl@0	3703	}
sl@0	3704	else
sl@0	3705	{
sl@0	3706	res = KErrGeneral;
sl@0	3707	}
sl@0	3708	err = deflateEnd(&c_stream);
sl@0	3709	if (err)
sl@0	3710	{
sl@0	3711	res = KErrGeneral;
sl@0	3712	}
sl@0	3713	free(compr);
sl@0	3714	free(uncompr);
sl@0	3715
sl@0	3716	return res;
sl@0	3717	}
sl@0	3718
sl@0	3719	TInt CTestZlib::TestDeflateSetDictionary_fail()
sl@0	3720	{
sl@0	3721	TInt res = KErrNone ;
sl@0	3722	Byte compr, uncompr;
sl@0	3723	uLong comprLen = 20*sizeof(int);
sl@0	3724	uLong uncomprLen = comprLen;
sl@0	3725
sl@0	3726	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3727	if (compr == Z_NULL)
sl@0	3728	{
sl@0	3729	return KErrNoMemory;
sl@0	3730	}
sl@0	3731	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3732	if (uncompr == Z_NULL)
sl@0	3733	{
sl@0	3734	free(compr);
sl@0	3735	return KErrNoMemory;
sl@0	3736	}
sl@0	3737
sl@0	3738	res=test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	3739
sl@0	3740	if(res < 0)
sl@0	3741	{
sl@0	3742	free(compr);
sl@0	3743	free(uncompr);
sl@0	3744	return KErrNoMemory;
sl@0	3745	}
sl@0	3746	res = Test_dict_deflate(compr, comprLen);
sl@0	3747	if(res < 0)
sl@0	3748	{
sl@0	3749	free(compr);
sl@0	3750	free(uncompr);
sl@0	3751	return KErrNoMemory;
sl@0	3752	}
sl@0	3753	int err = deflateSetDictionary(NULL,(const Bytef*)dictionary, sizeof(dictionary));
sl@0	3754	if(err != 0)
sl@0	3755	{
sl@0	3756	res = KErrNone ;
sl@0	3757	}
sl@0	3758	else
sl@0	3759	{
sl@0	3760	res = KErrGeneral;
sl@0	3761	}
sl@0	3762	free(compr);
sl@0	3763	free(uncompr);
sl@0	3764	return res;
sl@0	3765	}
sl@0	3766
sl@0	3767
sl@0	3768	TInt CTestZlib::TestDeflateend()
sl@0	3769	{
sl@0	3770	TInt res = KErrNone ;
sl@0	3771	z_stream c_stream; /* compression stream */
sl@0	3772	int err;
sl@0	3773	uLong len = (uLong)strlen(hello)+1;
sl@0	3774	Byte compr, uncompr;
sl@0	3775	uLong comprLen = 20*sizeof(int);
sl@0	3776	uLong uncomprLen = comprLen;
sl@0	3777	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3778	if (compr == Z_NULL)
sl@0	3779	{
sl@0	3780	return KErrNoMemory;
sl@0	3781	}
sl@0	3782	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3783	if (uncompr == Z_NULL)
sl@0	3784	{
sl@0	3785	free(compr);
sl@0	3786	return KErrNoMemory;
sl@0	3787	}
sl@0	3788
sl@0	3789	c_stream.zalloc = (alloc_func)0;
sl@0	3790	c_stream.zfree = (free_func)0;
sl@0	3791	c_stream.opaque = (voidpf)0;
sl@0	3792	err=test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	3793	if(err <0)
sl@0	3794	{
sl@0	3795	free(compr);
sl@0	3796	free(uncompr);
sl@0	3797	return err;
sl@0	3798	}
sl@0	3799	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	3800	if(err <0)
sl@0	3801	{
sl@0	3802	free(compr);
sl@0	3803	free(uncompr);
sl@0	3804	return err;
sl@0	3805	}
sl@0	3806
sl@0	3807	c_stream.next_in = (Bytef*)hello;
sl@0	3808	c_stream.next_out = compr;
sl@0	3809
sl@0	3810	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	3811	{
sl@0	3812	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
sl@0	3813	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	3814	}
sl@0	3815	/* Finish the stream, still forcing small buffers: */
sl@0	3816	for (;;)
sl@0	3817	{
sl@0	3818	c_stream.avail_out = 1;
sl@0	3819	err = deflate(&c_stream, Z_FINISH);
sl@0	3820	if (err == Z_STREAM_END) break;
sl@0	3821	}
sl@0	3822	err = deflateEnd(&c_stream);
sl@0	3823	if (err)
sl@0	3824	{
sl@0	3825	res = KErrGeneral;
sl@0	3826	}
sl@0	3827	free(compr);
sl@0	3828	free(uncompr);
sl@0	3829	return res;
sl@0	3830	}
sl@0	3831
sl@0	3832
sl@0	3833	TInt CTestZlib::TestDeflateendfail1()
sl@0	3834	{
sl@0	3835	TInt res = KErrNone ;
sl@0	3836	z_stream c_stream; /* compression stream */
sl@0	3837	int err;
sl@0	3838	Byte * compr;
sl@0	3839	uLong comprLen = 20*sizeof(int);
sl@0	3840	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3841	if (compr == Z_NULL)
sl@0	3842	{
sl@0	3843	return KErrNoMemory;
sl@0	3844	}
sl@0	3845
sl@0	3846	uLong len = (uLong)strlen(hello)+1;
sl@0	3847	c_stream.zalloc = (alloc_func)0;
sl@0	3848	c_stream.zfree = (free_func)0;
sl@0	3849	c_stream.opaque = (voidpf)0;
sl@0	3850
sl@0	3851	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	3852	if(err<0)
sl@0	3853	{
sl@0	3854	free(compr);
sl@0	3855	return KErrNoMemory;
sl@0	3856	}
sl@0	3857	c_stream.next_in = (Bytef*)hello;
sl@0	3858	c_stream.next_out = compr;
sl@0	3859
sl@0	3860	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	3861	{
sl@0	3862	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
sl@0	3863	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	3864	}
sl@0	3865
sl@0	3866	err = deflateEnd(&c_stream);
sl@0	3867	if (!err)
sl@0	3868	{
sl@0	3869	res = KErrGeneral;
sl@0	3870	}
sl@0	3871	free(compr);
sl@0	3872	return res;
sl@0	3873	}
sl@0	3874
sl@0	3875
sl@0	3876	TInt CTestZlib::TestDeflate()
sl@0	3877	{
sl@0	3878	TInt res = KErrNone ;
sl@0	3879	z_stream c_stream; /* compression stream */
sl@0	3880	int err;
sl@0	3881	Byte * compr;
sl@0	3882	uLong comprLen = 20*sizeof(int);
sl@0	3883	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3884	if (compr == Z_NULL)
sl@0	3885	{
sl@0	3886	return KErrNoMemory;
sl@0	3887	}
sl@0	3888	uLong len = (uLong)strlen(hello)+1;
sl@0	3889
sl@0	3890	c_stream.zalloc = (alloc_func)0;
sl@0	3891	c_stream.zfree = (free_func)0;
sl@0	3892	c_stream.opaque = (voidpf)0;
sl@0	3893
sl@0	3894	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	3895	if(err <0)
sl@0	3896	{
sl@0	3897	free(compr);
sl@0	3898	return err;
sl@0	3899	}
sl@0	3900
sl@0	3901	c_stream.next_in = (Bytef*)hello;
sl@0	3902	c_stream.next_out = compr;
sl@0	3903
sl@0	3904	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	3905	{
sl@0	3906	c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
sl@0	3907	err = deflate(&c_stream, Z_NO_FLUSH);
sl@0	3908	if(err != 0)
sl@0	3909	{
sl@0	3910	res = KErrGeneral;
sl@0	3911	}
sl@0	3912	}
sl@0	3913
sl@0	3914	err = deflateEnd(&c_stream);
sl@0	3915	free(compr);
sl@0	3916
sl@0	3917	return res;
sl@0	3918	}
sl@0	3919
sl@0	3920
sl@0	3921	TInt CTestZlib::TestGzseek()
sl@0	3922	{
sl@0	3923	TInt res = KErrNone ;
sl@0	3924	Byte compr, uncompr;
sl@0	3925	uLong comprLen = 20*sizeof(int);
sl@0	3926	uLong uncomprLen = comprLen;
sl@0	3927	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3928	if (compr == Z_NULL)
sl@0	3929	{
sl@0	3930	return KErrNoMemory;
sl@0	3931	}
sl@0	3932	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3933	if (uncompr == Z_NULL)
sl@0	3934	{
sl@0	3935	free(compr);
sl@0	3936	return KErrNoMemory;
sl@0	3937	}
sl@0	3938	int err;
sl@0	3939	err = test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	3940	if (err < 0)
sl@0	3941	{
sl@0	3942	free(compr);
sl@0	3943	free(uncompr);
sl@0	3944	return KErrNoMemory;
sl@0	3945	}
sl@0	3946	int len = (int)strlen(hello)+1;
sl@0	3947	gzFile file;
sl@0	3948	file = gzopen(TESTFILE, "wb");
sl@0	3949	if (file == NULL)
sl@0	3950	{
sl@0	3951	free(compr);
sl@0	3952	free(uncompr);
sl@0	3953	res = KErrNoMemory;
sl@0	3954	return res;
sl@0	3955	}
sl@0	3956	gzputc(file, 'h');
sl@0	3957	if (gzputs(file, "ello") != 4)
sl@0	3958	{
sl@0	3959	res = KErrGeneral;
sl@0	3960	return res;
sl@0	3961	}
sl@0	3962	if (gzprintf(file, ", %s!", "hello") != 8)
sl@0	3963	{
sl@0	3964	res = KErrGeneral;
sl@0	3965	return res;
sl@0	3966	}
sl@0	3967	err= gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
sl@0	3968	if(err<0)
sl@0	3969	{
sl@0	3970	res = KErrGeneral;
sl@0	3971	}
sl@0	3972	err= gzclose(file);
sl@0	3973	if (err != Z_OK)
sl@0	3974	{
sl@0	3975	res = KErrGeneral;
sl@0	3976	}
sl@0	3977
sl@0	3978	free(compr);
sl@0	3979	free(uncompr);
sl@0	3980	return res;
sl@0	3981	}
sl@0	3982
sl@0	3983
sl@0	3984	TInt CTestZlib::TestGzseekfail1()
sl@0	3985	{
sl@0	3986	TInt res = KErrNone ;
sl@0	3987	Byte compr, uncompr;
sl@0	3988	uLong comprLen = 20*sizeof(int);
sl@0	3989	uLong uncomprLen = comprLen;
sl@0	3990
sl@0	3991	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	3992	if (compr == Z_NULL)
sl@0	3993	{
sl@0	3994	return KErrNoMemory;
sl@0	3995	}
sl@0	3996	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	3997	if (uncompr == Z_NULL)
sl@0	3998	{
sl@0	3999	free(compr);
sl@0	4000	return KErrNoMemory;
sl@0	4001	}
sl@0	4002	int err;
sl@0	4003	err = test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	4004	if (err < 0)
sl@0	4005	{
sl@0	4006	free(compr);
sl@0	4007	free(uncompr);
sl@0	4008	return KErrNoMemory;
sl@0	4009	}
sl@0	4010
sl@0	4011	int len = (int)strlen(hello)+1;
sl@0	4012	gzFile file;
sl@0	4013	file = gzopen(NOFILE, "wb");
sl@0	4014
sl@0	4015	err = gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
sl@0	4016	if(err>=0)
sl@0	4017	{
sl@0	4018	res= KErrGeneral;
sl@0	4019	}
sl@0	4020	err= gzclose(file);
sl@0	4021	if (err == Z_OK)
sl@0	4022	{
sl@0	4023	res = KErrGeneral;
sl@0	4024	}
sl@0	4025
sl@0	4026	free(compr);
sl@0	4027	free(uncompr);
sl@0	4028	return res;
sl@0	4029	}
sl@0	4030
sl@0	4031	TInt CTestZlib::TestGzseekfail2()
sl@0	4032	{
sl@0	4033	TInt res = KErrNone ;
sl@0	4034	Byte compr, uncompr;
sl@0	4035	uLong comprLen = 20*sizeof(int);
sl@0	4036	uLong uncomprLen = comprLen;
sl@0	4037
sl@0	4038	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	4039	if (compr == Z_NULL)
sl@0	4040	{
sl@0	4041	return KErrNoMemory;
sl@0	4042	}
sl@0	4043	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	4044	if(uncompr == Z_NULL)
sl@0	4045	{
sl@0	4046	free(compr);
sl@0	4047	return KErrNoMemory;
sl@0	4048	}
sl@0	4049
sl@0	4050	int err;
sl@0	4051	err = test_compress(compr, comprLen, uncompr, uncomprLen);
sl@0	4052	if (err < 0)
sl@0	4053	{
sl@0	4054	free(compr);
sl@0	4055	free(uncompr);
sl@0	4056	return KErrNoMemory;
sl@0	4057	}
sl@0	4058	int len = (int)strlen(hello)+1;
sl@0	4059	gzFile file;
sl@0	4060	file = gzopen(TESTFILE, "wb");
sl@0	4061
sl@0	4062	err = gzseek(file, -1L, SEEK_CUR); /* add one zero byte */
sl@0	4063	if(err>=0)
sl@0	4064	{
sl@0	4065	res= KErrGeneral;
sl@0	4066	}
sl@0	4067	err= gzclose(file);
sl@0	4068	if (err != Z_OK)
sl@0	4069	{
sl@0	4070	res = KErrGeneral;
sl@0	4071	}
sl@0	4072
sl@0	4073	free(compr);
sl@0	4074	free(uncompr);
sl@0	4075	return res;
sl@0	4076	}
sl@0	4077
sl@0	4078	TInt CTestZlib::TestGzsetparams()
sl@0	4079	{
sl@0	4080	TInt res = KErrNone ;
sl@0	4081	int len = (int)strlen(hello)+1;
sl@0	4082	gzFile file;
sl@0	4083	const char * fname = TESTFILE;
sl@0	4084
sl@0	4085	file = gzopen(fname, "wb");
sl@0	4086	gzputc(file, 'h');
sl@0	4087
sl@0	4088	int u = gzsetparams(file, Z_BEST_SPEED, Z_DEFAULT_STRATEGY);
sl@0	4089	if(u!=0)
sl@0	4090	{
sl@0	4091	res= KErrGeneral;
sl@0	4092	}
sl@0	4093	int err= gzclose(file);
sl@0	4094	if (err != Z_OK)
sl@0	4095	{
sl@0	4096	res = KErrGeneral;
sl@0	4097	}
sl@0	4098
sl@0	4099	return res;
sl@0	4100	}
sl@0	4101
sl@0	4102
sl@0	4103	TInt CTestZlib::TestGzsetparams_fail1()
sl@0	4104	{
sl@0	4105	TInt res = KErrNone ;
sl@0	4106	int len = (int)strlen(hello)+1;
sl@0	4107	gzFile file;
sl@0	4108	const char * fname = TESTFILE;
sl@0	4109	file = gzopen(fname, "wb");
sl@0	4110	gzputc(file, 'h');
sl@0	4111
sl@0	4112	int u = gzsetparams(file, Z_BEST_SPEED, -2);
sl@0	4113	if(u==0)
sl@0	4114	{
sl@0	4115	res= KErrGeneral;
sl@0	4116	}
sl@0	4117
sl@0	4118	int err= gzclose(file);
sl@0	4119	if (err != Z_OK)
sl@0	4120	{
sl@0	4121	res = KErrGeneral;
sl@0	4122	}
sl@0	4123
sl@0	4124	return res;
sl@0	4125	}
sl@0	4126
sl@0	4127
sl@0	4128	TInt CTestZlib::TestGzsetparams_fail2()
sl@0	4129	{
sl@0	4130	TInt res = KErrNone ;
sl@0	4131
sl@0	4132	int len = (int)strlen(hello)+1;
sl@0	4133	gzFile file;
sl@0	4134
sl@0	4135	const char * fname = TESTFILE;
sl@0	4136	file = gzopen(fname, "wb");
sl@0	4137	gzputc(file, 'h');
sl@0	4138
sl@0	4139	int u = gzsetparams(file, -2, Z_DEFAULT_STRATEGY);
sl@0	4140	if(u==0)
sl@0	4141	{
sl@0	4142	res= KErrGeneral;
sl@0	4143	}
sl@0	4144	int err= gzclose(file);
sl@0	4145	if (err != Z_OK)
sl@0	4146	{
sl@0	4147	res = KErrGeneral;
sl@0	4148	}
sl@0	4149
sl@0	4150	return res;
sl@0	4151	}
sl@0	4152
sl@0	4153	TInt CTestZlib::TestGzsetparams_fail3()
sl@0	4154	{
sl@0	4155	TInt res = KErrNone ;
sl@0	4156	int len = (int)strlen(hello)+1;
sl@0	4157	gzFile file;
sl@0	4158	const char * fname = TESTFILE;
sl@0	4159
sl@0	4160	file = gzopen(fname, "rb");
sl@0	4161	if (file == NULL)
sl@0	4162	{
sl@0	4163	res = KErrGeneral;
sl@0	4164	return res;
sl@0	4165	}
sl@0	4166	gzputc(file, 'h');
sl@0	4167
sl@0	4168	int u = gzsetparams(file, Z_BEST_SPEED, Z_DEFAULT_STRATEGY);
sl@0	4169	if(u==0)
sl@0	4170	{
sl@0	4171	res = KErrGeneral;
sl@0	4172	}
sl@0	4173
sl@0	4174	int err= gzclose(file);
sl@0	4175	if (err != Z_OK)
sl@0	4176	{
sl@0	4177	res = KErrGeneral;
sl@0	4178	}
sl@0	4179	return res;
sl@0	4180	}
sl@0	4181
sl@0	4182
sl@0	4183	TInt CTestZlib::TestGzrewind()
sl@0	4184	{
sl@0	4185	TInt res = KErrNone ;
sl@0	4186	int err;
sl@0	4187	int len = (int)strlen(hello)+1;
sl@0	4188	gzFile file;
sl@0	4189
sl@0	4190	const char * fname = TESTFILE;
sl@0	4191	file = gzopen(fname, "rb");
sl@0	4192	if (file == NULL)
sl@0	4193	{
sl@0	4194	res = KErrGeneral;
sl@0	4195	}
sl@0	4196	gzputc(file, 'h');
sl@0	4197	err = gzrewind(file);
sl@0	4198	if(err == 0)
sl@0	4199	{
sl@0	4200	res = KErrNone ;
sl@0	4201	}
sl@0	4202	else
sl@0	4203	{
sl@0	4204	res = KErrGeneral;
sl@0	4205	}
sl@0	4206	err = gzclose(file);
sl@0	4207	if (err != Z_OK)
sl@0	4208	{
sl@0	4209	res = KErrGeneral;
sl@0	4210	}
sl@0	4211	return res;
sl@0	4212	}
sl@0	4213
sl@0	4214
sl@0	4215
sl@0	4216	TInt CTestZlib::TestGzrewindfail()
sl@0	4217	{
sl@0	4218	TInt res = KErrNone ;
sl@0	4219	int err;
sl@0	4220	int len = (int)strlen(hello)+1;
sl@0	4221	gzFile file;
sl@0	4222
sl@0	4223	const char * fname = TESTFILE;
sl@0	4224	file = gzopen(fname, "wb");
sl@0	4225	if (file == NULL)
sl@0	4226	{
sl@0	4227	res = KErrGeneral;
sl@0	4228	}
sl@0	4229	gzputc(file, 'h');
sl@0	4230	err = gzrewind(file);
sl@0	4231	if(err == 0)
sl@0	4232	{
sl@0	4233	res = KErrGeneral;
sl@0	4234	}
sl@0	4235	else
sl@0	4236	{
sl@0	4237	res = KErrNone ;
sl@0	4238	}
sl@0	4239	err= gzclose(file);
sl@0	4240	if (err != Z_OK)
sl@0	4241	{
sl@0	4242	res = KErrGeneral;
sl@0	4243	}
sl@0	4244
sl@0	4245	return res;
sl@0	4246	}
sl@0	4247
sl@0	4248	TInt CTestZlib::TestGzdopen()
sl@0	4249	{
sl@0	4250	TInt res = KErrNone ;
sl@0	4251	int len = (int)strlen(hello)+1;
sl@0	4252	gzFile file;
sl@0	4253	const char * fname = TESTFILE ;
sl@0	4254	FILE* fp = fopen(fname, "rb");
sl@0	4255	file = gzdopen(fileno(fp), "rb");
sl@0	4256	if (file == NULL)
sl@0	4257	{
sl@0	4258	res = Z_MEM_ERROR;
sl@0	4259	fclose(fp);
sl@0	4260	return res;
sl@0	4261	}
sl@0	4262	int err= gzclose(file);
sl@0	4263	if (err != Z_OK)
sl@0	4264	{
sl@0	4265	res = KErrGeneral;
sl@0	4266	}
sl@0	4267	fclose(fp);
sl@0	4268	return res;
sl@0	4269	}
sl@0	4270
sl@0	4271
sl@0	4272	TInt CTestZlib::TestGzdopen_fail()
sl@0	4273	{
sl@0	4274	TInt res = KErrNone ;
sl@0	4275	int len = (int)strlen(hello)+1;
sl@0	4276	gzFile file;
sl@0	4277	const char * fname = TESTFILE ;
sl@0	4278	FILE* fp = fopen(fname, "rb");
sl@0	4279	file = gzdopen(fileno(fp), "xyz");
sl@0	4280	if (file == NULL)
sl@0	4281	{
sl@0	4282	res=KErrNone;
sl@0	4283	fclose(fp);
sl@0	4284	return res;
sl@0	4285	}
sl@0	4286	int err= gzclose(file);
sl@0	4287	if (err == Z_OK)
sl@0	4288	{
sl@0	4289	res = KErrGeneral;
sl@0	4290	}
sl@0	4291	fclose(fp);
sl@0	4292	return res;
sl@0	4293	}
sl@0	4294
sl@0	4295
sl@0	4296	TInt CTestZlib::TestGzdopen_fail2()
sl@0	4297	{
sl@0	4298	TInt res = KErrNone ;
sl@0	4299	int len = (int)strlen(hello)+1;
sl@0	4300	gzFile file;
sl@0	4301	const char * fname = TESTFILE ;
sl@0	4302	FILE* fp = fopen(fname, "rb");
sl@0	4303	file = gzdopen(-1, "xyz");
sl@0	4304	if (file == NULL)
sl@0	4305	{
sl@0	4306	fclose(fp);
sl@0	4307	res=KErrNone;
sl@0	4308	return res;
sl@0	4309	}
sl@0	4310	int err= gzclose(file);
sl@0	4311	if (err == Z_OK)
sl@0	4312	{
sl@0	4313	res = KErrGeneral;
sl@0	4314	}
sl@0	4315	fclose(fp);
sl@0	4316	return res;
sl@0	4317	}
sl@0	4318
sl@0	4319	/* ===========================================================================
sl@0	4320	* Test deflate() with full flush
sl@0	4321	*/
sl@0	4322	TInt CTestZlib::Test_flush( Byte * compr,uLong * comprLen)
sl@0	4323	{
sl@0	4324	TInt res = KErrNone ;
sl@0	4325	z_stream c_stream; /* compression stream */
sl@0	4326	int err;
sl@0	4327	uInt len = (uInt)strlen(hello)+1;
sl@0	4328
sl@0	4329	c_stream.zalloc = (alloc_func)0;
sl@0	4330	c_stream.zfree = (free_func)0;
sl@0	4331	c_stream.opaque = (voidpf)0;
sl@0	4332
sl@0	4333	err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	4334	if(err<0)
sl@0	4335	{
sl@0	4336	return Z_MEM_ERROR;
sl@0	4337	}
sl@0	4338
sl@0	4339	c_stream.next_in = (Bytef*)hello;
sl@0	4340	c_stream.next_out = compr;
sl@0	4341	c_stream.avail_in = 3;
sl@0	4342	c_stream.avail_out = (uInt)*comprLen;
sl@0	4343	err = deflate(&c_stream, Z_FULL_FLUSH);
sl@0	4344
sl@0	4345	int h=inflateSyncPoint(&c_stream);
sl@0	4346	compr[3]++; /* force an error in first compressed block */
sl@0	4347	c_stream.avail_in = len - 3;
sl@0	4348
sl@0	4349	err = deflate(&c_stream, Z_FINISH);
sl@0	4350	if (err != Z_STREAM_END)
sl@0	4351	{
sl@0	4352	res = KErrGeneral;
sl@0	4353	}
sl@0	4354	err = deflateEnd(&c_stream);
sl@0	4355	if (err != 0)
sl@0	4356	{
sl@0	4357	res = KErrGeneral;
sl@0	4358	}
sl@0	4359	*comprLen = c_stream.total_out;
sl@0	4360	return res;
sl@0	4361	}
sl@0	4362
sl@0	4363
sl@0	4364	TInt test_sync(Byte * compr,uLong comprLen, Byte * uncompr,uLong uncomprLen)
sl@0	4365	{
sl@0	4366	TInt res = KErrNone ;
sl@0	4367	int err;
sl@0	4368	z_stream d_stream; /* decompression stream */
sl@0	4369
sl@0	4370	strcpy((char*)uncompr, "garbage");
sl@0	4371
sl@0	4372	d_stream.zalloc = (alloc_func)0;
sl@0	4373	d_stream.zfree = (free_func)0;
sl@0	4374	d_stream.opaque = (voidpf)0;
sl@0	4375
sl@0	4376	d_stream.next_in = compr;
sl@0	4377	d_stream.avail_in = 2; /* just read the zlib header */
sl@0	4378
sl@0	4379	err = inflateInit(&d_stream);
sl@0	4380	if(err!=0)
sl@0	4381	{
sl@0	4382	res=KErrGeneral;
sl@0	4383	}
sl@0	4384	d_stream.next_out = uncompr;
sl@0	4385	d_stream.avail_out = (uInt)uncomprLen;
sl@0	4386
sl@0	4387	err= inflate(&d_stream, Z_NO_FLUSH);
sl@0	4388	if(err!=0)
sl@0	4389	{
sl@0	4390	res=KErrGeneral;
sl@0	4391	}
sl@0	4392	d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
sl@0	4393	err = inflateSync(&d_stream); /* but skip the damaged part */
sl@0	4394	if(err!=0)
sl@0	4395	{
sl@0	4396	res=KErrGeneral;
sl@0	4397	}
sl@0	4398	err = inflate(&d_stream, Z_FINISH);
sl@0	4399	if(err==0)
sl@0	4400	{
sl@0	4401	res=KErrGeneral;
sl@0	4402	}
sl@0	4403	err = inflateEnd(&d_stream);
sl@0	4404	if(err!=0)
sl@0	4405	{
sl@0	4406	res=KErrGeneral;
sl@0	4407	}
sl@0	4408	return res;
sl@0	4409	}
sl@0	4410
sl@0	4411
sl@0	4412	TInt CTestZlib::TestInflateSync()
sl@0	4413	{
sl@0	4414	TInt res = KErrNone ;
sl@0	4415	uLong len = (uLong)strlen(hello)+1;
sl@0	4416
sl@0	4417	Byte compr, uncompr;
sl@0	4418	uLong comprLen = 20*sizeof(int);
sl@0	4419	uLong uncomprLen = comprLen;
sl@0	4420	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	4421	if (compr == Z_NULL)
sl@0	4422	{
sl@0	4423	return KErrNoMemory;
sl@0	4424	}
sl@0	4425	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	4426	if(uncompr == Z_NULL)
sl@0	4427	{
sl@0	4428	free(compr);
sl@0	4429	return KErrNoMemory;
sl@0	4430	}
sl@0	4431	res= test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	4432	if(res<0)
sl@0	4433	{
sl@0	4434	free(compr);
sl@0	4435	free(uncompr);
sl@0	4436	return KErrNoMemory;
sl@0	4437	}
sl@0	4438	Test_flush(compr, &comprLen);
sl@0	4439	res = test_sync(compr, comprLen, uncompr, uncomprLen);
sl@0	4440	free(compr);
sl@0	4441	free(uncompr);
sl@0	4442	return res;
sl@0	4443	}
sl@0	4444
sl@0	4445
sl@0	4446	TInt CTestZlib::TestinflateSyncfail()
sl@0	4447	{
sl@0	4448	TInt res = KErrNone ;
sl@0	4449	uLong len = (uLong)strlen(hello)+1;
sl@0	4450
sl@0	4451	Byte compr, uncompr;
sl@0	4452	uLong comprLen = 20*sizeof(int);
sl@0	4453	uLong uncomprLen = comprLen;
sl@0	4454	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	4455	if (compr == Z_NULL)
sl@0	4456	{
sl@0	4457	return KErrNoMemory;
sl@0	4458	}
sl@0	4459	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	4460	if (uncompr == Z_NULL)
sl@0	4461	{
sl@0	4462	free(compr);
sl@0	4463	return KErrNoMemory;
sl@0	4464	}
sl@0	4465
sl@0	4466	res= test_compress_positive(compr, comprLen, uncompr, uncomprLen);
sl@0	4467	if(res<0)
sl@0	4468	{
sl@0	4469	free(compr);
sl@0	4470	free(uncompr);
sl@0	4471	return KErrNoMemory;
sl@0	4472	}
sl@0	4473	int err = test_sync(compr, comprLen, uncompr, uncomprLen);
sl@0	4474	if(err!=0)
sl@0	4475	{
sl@0	4476	res = KErrNone ;
sl@0	4477	}
sl@0	4478	else
sl@0	4479	{
sl@0	4480	res = KErrGeneral;
sl@0	4481	}
sl@0	4482	free(compr);
sl@0	4483	free(uncompr);
sl@0	4484	return res;
sl@0	4485	}
sl@0	4486
sl@0	4487
sl@0	4488	int test_syncpoint (Bytef dest, uLongf destLen, const Bytef *source, uLong sourceLen, int level)
sl@0	4489	{
sl@0	4490	TInt res = KErrNone ;
sl@0	4491	z_stream stream;
sl@0	4492	int err;
sl@0	4493
sl@0	4494	stream.next_in = (Bytef*)source;
sl@0	4495	stream.avail_in = (uInt)sourceLen;
sl@0	4496	stream.next_out = dest;
sl@0	4497	stream.avail_out = (uInt)*destLen;
sl@0	4498
sl@0	4499	stream.zalloc = (alloc_func)0;
sl@0	4500	stream.zfree = (free_func)0;
sl@0	4501	stream.opaque = (voidpf)0;
sl@0	4502
sl@0	4503	err = deflateInit(&stream, level);
sl@0	4504	if (err != Z_OK) return err;
sl@0	4505
sl@0	4506	err = deflate(&stream, Z_FINISH);
sl@0	4507	if (err != Z_STREAM_END)
sl@0	4508	{
sl@0	4509	deflateEnd(&stream);
sl@0	4510	return err == Z_OK ? Z_BUF_ERROR : err;
sl@0	4511	}
sl@0	4512	*destLen = stream.total_out;
sl@0	4513	int h=inflateSyncPoint(&stream);
sl@0	4514	if(h!=0)
sl@0	4515	{
sl@0	4516	res=KErrGeneral;
sl@0	4517	}
sl@0	4518	deflateEnd(&stream);
sl@0	4519	return res;
sl@0	4520	}
sl@0	4521
sl@0	4522
sl@0	4523	TInt CTestZlib::TestInflateSyncPoint()
sl@0	4524	{
sl@0	4525	TInt res = KErrNone ;
sl@0	4526	uLong len = (uLong)strlen(hello)+1;
sl@0	4527	Byte compr, uncompr;
sl@0	4528	uLong comprLen = 20*sizeof(int);
sl@0	4529	uLong uncomprLen = comprLen;
sl@0	4530	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	4531	if (compr == Z_NULL)
sl@0	4532	{
sl@0	4533	return KErrNoMemory;
sl@0	4534	}
sl@0	4535	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	4536	if (uncompr == Z_NULL)
sl@0	4537	{
sl@0	4538	free(compr);
sl@0	4539	return KErrNoMemory;
sl@0	4540	}
sl@0	4541	res= test_syncpoint(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION);
sl@0	4542	free(compr);
sl@0	4543	free(uncompr);
sl@0	4544	return res;
sl@0	4545	}
sl@0	4546
sl@0	4547	TInt CTestZlib::TestInflateSyncPoint_null()
sl@0	4548	{
sl@0	4549	TInt res = KErrNone ;
sl@0	4550	uLong len = (uLong)strlen(hello)+1;
sl@0	4551	Byte compr, uncompr;
sl@0	4552	uLong comprLen = 20*sizeof(int);
sl@0	4553	uLong uncomprLen = comprLen;
sl@0	4554	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	4555	if (compr == Z_NULL)
sl@0	4556	{
sl@0	4557	return KErrNoMemory;
sl@0	4558	}
sl@0	4559	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	4560	if (uncompr == Z_NULL)
sl@0	4561	{
sl@0	4562	free(compr);
sl@0	4563	return KErrNoMemory;
sl@0	4564	}
sl@0	4565	int h=inflateSyncPoint(NULL);
sl@0	4566	if(h==0)
sl@0	4567	{
sl@0	4568	res=KErrGeneral;
sl@0	4569	}
sl@0	4570	free(compr);
sl@0	4571	free(uncompr);
sl@0	4572	return res;
sl@0	4573	}
sl@0	4574
sl@0	4575
sl@0	4576	TInt CTestZlib::TestZerror()
sl@0	4577	{
sl@0	4578	TInt res = KErrNone ;
sl@0	4579	const char * s = zError(1);
sl@0	4580	if(strcmp(s,"stream end"))
sl@0	4581	{
sl@0	4582	res=KErrGeneral;
sl@0	4583	}
sl@0	4584	return res;
sl@0	4585	}
sl@0	4586
sl@0	4587	TInt CTestZlib::TestZerror1()
sl@0	4588	{
sl@0	4589	TInt res = KErrNone ;
sl@0	4590	const char * s = zError(-3);
sl@0	4591	if(strcmp(s,"data error"))
sl@0	4592	{
sl@0	4593	res=KErrGeneral;
sl@0	4594	}
sl@0	4595
sl@0	4596	return res;
sl@0	4597	}
sl@0	4598
sl@0	4599	TInt CTestZlib::TestZerror2()
sl@0	4600	{
sl@0	4601	TInt res = KErrNone ;
sl@0	4602	const char * s = zError(0);
sl@0	4603	if(strcmp(s,""))
sl@0	4604	{
sl@0	4605	res=KErrGeneral;
sl@0	4606	}
sl@0	4607
sl@0	4608	return res;
sl@0	4609	}
sl@0	4610

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