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

sl@0	1	// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	// Name : tzlibcases.cpp
sl@0	15	//
sl@0	16	//
sl@0	17	#include <errno.h>
sl@0	18	#include "tzlib.h"
sl@0	19
sl@0	20	#define CHECK_ERR(err, msg) { \
sl@0	21	if (err != Z_OK) { \
sl@0	22	INFO_PRINTF2(_L("Error: %d"), err); \
sl@0	23	return err; \
sl@0	24	} \
sl@0	25	}
sl@0	26
sl@0	27	// -----------------------------------------------------------------------------
sl@0	28	//Function Name :ReadStringParam
sl@0	29	//Description:Reads string from ini file
sl@0	30	//Param : aString is populated with the read string
sl@0	31	// -----------------------------------------------------------------------------
sl@0	32	void CTestZlib::ReadStringParam(char* aString)
sl@0	33	{
sl@0	34	_LIT( Kparam, "Param%d" );
sl@0	35	TBuf<100> pNameBuf;
sl@0	36	TPtrC descriptor;
sl@0	37	TInt i;
sl@0	38
sl@0	39	pNameBuf.Format (Kparam, ++iParamCnt);
sl@0	40	TBool ret = GetStringFromConfig (ConfigSection (), pNameBuf, descriptor);
sl@0	41	if ( descriptor == _L("\"\""))
sl@0	42	{
sl@0	43	i = 0;
sl@0	44	}
sl@0	45	else
sl@0	46	{
sl@0	47	// If the string is quoted, take only the insides
sl@0	48	if ( (descriptor[0] == '\"') && (descriptor[descriptor.Length()-1] == '\"'))
sl@0	49	{
sl@0	50	for (i=0; i<descriptor.Length ()-2; i++)
sl@0	51	{
sl@0	52	aString[i]=descriptor[i+1];
sl@0	53	}
sl@0	54	}
sl@0	55	// Otherwise,take the whole string
sl@0	56	else
sl@0	57	{
sl@0	58	for (i=0; i<descriptor.Length (); i++)
sl@0	59	{
sl@0	60	aString[i]=descriptor[i];
sl@0	61	}
sl@0	62	}
sl@0	63	}
sl@0	64
sl@0	65	aString[i]='\0';
sl@0	66	}
sl@0	67
sl@0	68	// -----------------------------------------------------------------------------
sl@0	69	//Function Name : ReadIntParam
sl@0	70	//TestCase Description:Reads Int value from ini file
sl@0	71	//Param : TInt to receive the read integer
sl@0	72	// -----------------------------------------------------------------------------
sl@0	73	void CTestZlib::ReadIntParam(TInt &aInt)
sl@0	74	{
sl@0	75	_LIT( Kparam, "Param%d" );
sl@0	76	TBuf<8> pNameBuf;
sl@0	77	TPtrC string;
sl@0	78	pNameBuf.Format (Kparam, ++iParamCnt);
sl@0	79	TBool res = GetIntFromConfig (ConfigSection (), pNameBuf, aInt);
sl@0	80	}
sl@0	81
sl@0	82	//---------------/COMPRESS AND UNCOMPRESS/----------------------------------
sl@0	83
sl@0	84	TInt CTestZlib::sec_compress(Byte * compr, uLong comprLen, Byte * uncompr,
sl@0	85	uLong uncomprLen)
sl@0	86	{
sl@0	87
sl@0	88	int err;
sl@0	89	const char hello[] = "hello, hello!";
sl@0	90	uLong len = (uLong)strlen(hello)+1;
sl@0	91
sl@0	92	err = compress (compr, &comprLen, (const Bytef*)hello, len);
sl@0	93	CHECK_ERR(err, "compress");
sl@0	94
sl@0	95	strcpy ((char*)uncompr, "garbage");
sl@0	96
sl@0	97	err = uncompress (uncompr, &uncomprLen, compr, comprLen);
sl@0	98	CHECK_ERR(err, "uncompress");
sl@0	99
sl@0	100	if ( strcmp ((char*)uncompr, hello))
sl@0	101	{
sl@0	102	printf ("Bad uncompress");
sl@0	103	return KErrGeneral;
sl@0	104	}
sl@0	105	else
sl@0	106	{
sl@0	107	printf ("uncompress(): %s", (char *)uncompr);
sl@0	108	}
sl@0	109	return err;
sl@0	110	}
sl@0	111
sl@0	112	//------------------------------//deflateSetDictionary//-----------------------------------
sl@0	113
sl@0	114	TInt CTestZlib::sec_deflateSetDictionary01(Byte * compr, uLong comprLen,
sl@0	115	TInt flush, TInt compression)
sl@0	116	{
sl@0	117	z_stream c_stream; // compression stream
sl@0	118	int err;
sl@0	119	const char hello[] = "hello, hello!";
sl@0	120	uLong len = (uLong)strlen(hello)+1;
sl@0	121	const Bytef* dictionary=(const Bytef *) hello;
sl@0	122	c_stream.zalloc = (alloc_func)0;
sl@0	123	c_stream.zfree = (free_func)0;
sl@0	124	c_stream.opaque = (voidpf)0;
sl@0	125
sl@0	126	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	127
sl@0	128	if ( err != Z_OK)
sl@0	129	{
sl@0	130	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	131	return err;
sl@0	132	}
sl@0	133	err = deflateSetDictionary (&c_stream, dictionary, 3);
sl@0	134	if ( err != Z_OK)
sl@0	135	{
sl@0	136	ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
sl@0	137	deflateEnd (&c_stream);
sl@0	138	return err;
sl@0	139	}
sl@0	140	c_stream.next_in = (Bytef*)hello;
sl@0	141	c_stream.next_out = compr;
sl@0	142
sl@0	143	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	144	{
sl@0	145	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	146	err = deflate (&c_stream, flush);
sl@0	147	if ( err != Z_OK)
sl@0	148	{
sl@0	149	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	150	deflateEnd (&c_stream);
sl@0	151	return err;
sl@0	152	}
sl@0	153	}
sl@0	154	// Finish the stream, still forcing small buffers:
sl@0	155	for (;;)
sl@0	156	{
sl@0	157	c_stream.avail_out = 1;
sl@0	158	err = deflate (&c_stream, Z_FINISH);
sl@0	159	if ( err == Z_STREAM_END)
sl@0	160	break;
sl@0	161	if ( err != Z_OK)
sl@0	162	{
sl@0	163	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	164	deflateEnd (&c_stream);
sl@0	165	return err;
sl@0	166	}
sl@0	167	}
sl@0	168
sl@0	169	deflateEnd (&c_stream);
sl@0	170	return KErrNone;
sl@0	171	}
sl@0	172
sl@0	173	TInt CTestZlib::sec_deflateSetDictionary02(TInt compression)
sl@0	174	{
sl@0	175	z_stream c_stream; // compression stream
sl@0	176	int err;
sl@0	177	const char hello[] = "hello, hello!";
sl@0	178	uLong len = (uLong)strlen(hello)+1;
sl@0	179	const Bytef* dictionary=NULL;
sl@0	180	c_stream.zalloc = (alloc_func)0;
sl@0	181	c_stream.zfree = (free_func)0;
sl@0	182	c_stream.opaque = (voidpf)0;
sl@0	183
sl@0	184	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	185
sl@0	186	if ( err != Z_OK)
sl@0	187	{
sl@0	188	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	189	return err;
sl@0	190	}
sl@0	191	err = deflateSetDictionary (&c_stream, dictionary, 30);
sl@0	192	if ( err != Z_OK)
sl@0	193	{
sl@0	194	ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
sl@0	195	deflateEnd (&c_stream);
sl@0	196	return err;
sl@0	197	}
sl@0	198	deflateEnd (&c_stream);
sl@0	199	return KErrNone;
sl@0	200	}
sl@0	201
sl@0	202	//------------------------------//deflateSetDictionary//-----------------------------------
sl@0	203
sl@0	204	TInt CTestZlib::sec_deflateSetDictionary03(Byte * compr, uLong comprLen,
sl@0	205	TInt flush, TInt compression)
sl@0	206	{
sl@0	207	z_stream c_stream; // compression stream
sl@0	208	int err;
sl@0	209	const char hello[] = "hello, hello!";
sl@0	210	uLong len = (uLong)strlen(hello)+1;
sl@0	211	const Bytef* dictionary=(const Bytef *) hello;
sl@0	212	c_stream.zalloc = (alloc_func)0;
sl@0	213	c_stream.zfree = (free_func)0;
sl@0	214	c_stream.opaque = (voidpf)0;
sl@0	215
sl@0	216	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	217
sl@0	218	if ( err != Z_OK)
sl@0	219	{
sl@0	220	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	221	return err;
sl@0	222	}
sl@0	223	c_stream.next_in = (Bytef*)hello;
sl@0	224	c_stream.next_out = compr;
sl@0	225
sl@0	226	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	227	{
sl@0	228	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	229	err = deflate (&c_stream, flush);
sl@0	230	if ( err != Z_OK)
sl@0	231	{
sl@0	232	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	233	deflateEnd (&c_stream);
sl@0	234	return err;
sl@0	235	}
sl@0	236	}
sl@0	237	// Finish the stream, still forcing small buffers:
sl@0	238	for (;;)
sl@0	239	{
sl@0	240	c_stream.avail_out = 1;
sl@0	241	err = deflate (&c_stream, Z_FINISH);
sl@0	242	if ( err == Z_STREAM_END)
sl@0	243	break;
sl@0	244	if ( err != Z_OK)
sl@0	245	{
sl@0	246	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	247	deflateEnd (&c_stream);
sl@0	248	return err;
sl@0	249	}
sl@0	250	}
sl@0	251
sl@0	252	deflateEnd (&c_stream);
sl@0	253	err = deflateSetDictionary (&c_stream, dictionary, 30);
sl@0	254	if ( err != Z_OK)
sl@0	255	{
sl@0	256	ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
sl@0	257	return err;
sl@0	258	}
sl@0	259
sl@0	260	return KErrNone;
sl@0	261	}
sl@0	262
sl@0	263	TInt CTestZlib::sec_deflateSetDictionary04(Byte * compr, uLong comprLen,
sl@0	264	TInt flush, TInt compression)
sl@0	265	{
sl@0	266	z_stream c_stream; // compression stream
sl@0	267	int err;
sl@0	268	const char hello[] = "hello, hello!";
sl@0	269	uLong len = (uLong)strlen(hello)+1;
sl@0	270	const char dict[] = "z";
sl@0	271
sl@0	272	const Bytef* dictionary=(const Bytef *) dict;
sl@0	273	c_stream.zalloc = (alloc_func)0;
sl@0	274	c_stream.zfree = (free_func)0;
sl@0	275	c_stream.opaque = (voidpf)0;
sl@0	276
sl@0	277	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	278
sl@0	279	if ( err != Z_OK)
sl@0	280	{
sl@0	281	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	282	return err;
sl@0	283	}
sl@0	284	err = deflateSetDictionary (&c_stream, dictionary, (uLong)strlen(dict)+1);
sl@0	285	if ( err != Z_OK)
sl@0	286	{
sl@0	287	ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
sl@0	288	deflateEnd (&c_stream);
sl@0	289	return err;
sl@0	290	}
sl@0	291	c_stream.next_in = (Bytef*)hello;
sl@0	292	c_stream.next_out = compr;
sl@0	293
sl@0	294	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	295	{
sl@0	296	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	297	err = deflate (&c_stream, flush);
sl@0	298	if ( err != Z_OK)
sl@0	299	{
sl@0	300	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	301	deflateEnd (&c_stream);
sl@0	302	return err;
sl@0	303	}
sl@0	304	}
sl@0	305	// Finish the stream, still forcing small buffers:
sl@0	306	for (;;)
sl@0	307	{
sl@0	308	c_stream.avail_out = 1;
sl@0	309	err = deflate (&c_stream, Z_FINISH);
sl@0	310	if ( err == Z_STREAM_END)
sl@0	311	break;
sl@0	312	if ( err != Z_OK)
sl@0	313	{
sl@0	314	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	315	deflateEnd (&c_stream);
sl@0	316	return err;
sl@0	317	}
sl@0	318	}
sl@0	319
sl@0	320	deflateEnd (&c_stream);
sl@0	321	return KErrNone;
sl@0	322	}
sl@0	323
sl@0	324	TInt CTestZlib::sec_deflateSetDictionary05(Byte * compr, uLong comprLen,
sl@0	325	TInt flush, TInt compression)
sl@0	326	{
sl@0	327	z_stream c_stream; // compression stream
sl@0	328	int err;
sl@0	329	const char hello[] = "hello, hello!";
sl@0	330	uLong len = (uLong)strlen(hello)+1;
sl@0	331	const char
sl@0	332	dict[] = "abcdefghijklmnopqrstuvwxyz \
sl@0	333	abcdefghijklmnopqrstuvwxyz \
sl@0	334	abcdefghijklmnopqrstuvwxyz \
sl@0	335	abcdefghijklmnopqrstuvwxyz \
sl@0	336	abcdefghijklmnopqrstuvwxyz \
sl@0	337	abcdefghijklmnopqrstuvwxyz \
sl@0	338	abcdefghijklmnopqrstuvwxyz \
sl@0	339	abcdefghijklmnopqrstuvwxyz \
sl@0	340	abcdefghijklmnopqrstuvwxyz \
sl@0	341	abcdefghijklmnopqrstuvwxyz";
sl@0	342
sl@0	343	const Bytef* dictionary=(const Bytef *) dict;
sl@0	344	c_stream.zalloc = (alloc_func)0;
sl@0	345	c_stream.zfree = (free_func)0;
sl@0	346	c_stream.opaque = (voidpf)0;
sl@0	347
sl@0	348	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	349
sl@0	350	if ( err != Z_OK)
sl@0	351	{
sl@0	352	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	353	return err;
sl@0	354	}
sl@0	355	err = deflateSetDictionary (&c_stream, dictionary, (uLong)strlen(dict)+1);
sl@0	356	if ( err != Z_OK)
sl@0	357	{
sl@0	358	ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
sl@0	359	deflateEnd (&c_stream);
sl@0	360	return err;
sl@0	361	}
sl@0	362	c_stream.next_in = (Bytef*)hello;
sl@0	363	c_stream.next_out = compr;
sl@0	364
sl@0	365	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	366	{
sl@0	367	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	368	err = deflate (&c_stream, flush);
sl@0	369	if ( err != Z_OK)
sl@0	370	{
sl@0	371	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	372	deflateEnd (&c_stream);
sl@0	373	return err;
sl@0	374	}
sl@0	375	}
sl@0	376	// Finish the stream, still forcing small buffers:
sl@0	377	for (;;)
sl@0	378	{
sl@0	379	c_stream.avail_out = 1;
sl@0	380	err = deflate (&c_stream, Z_FINISH);
sl@0	381	if ( err == Z_STREAM_END)
sl@0	382	break;
sl@0	383	if ( err != Z_OK)
sl@0	384	{
sl@0	385	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	386	deflateEnd (&c_stream);
sl@0	387	return err;
sl@0	388	}
sl@0	389	}
sl@0	390
sl@0	391	deflateEnd (&c_stream);
sl@0	392	return KErrNone;
sl@0	393	}
sl@0	394	//------------------------------//DEFLATE//-----------------------------------
sl@0	395
sl@0	396	TInt CTestZlib::sec_deflate01( Byte * compr, uLong comprLen, TInt flush,
sl@0	397	TInt compression)
sl@0	398	{
sl@0	399	z_stream c_stream; // compression stream
sl@0	400	int err;
sl@0	401	const char hello[] = "hello, hello!";
sl@0	402	uLong len = (uLong)strlen(hello)+1;
sl@0	403
sl@0	404	c_stream.zalloc = (alloc_func)0;
sl@0	405	c_stream.zfree = (free_func)0;
sl@0	406	c_stream.opaque = (voidpf)0;
sl@0	407
sl@0	408	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	409
sl@0	410	if ( err != Z_OK)
sl@0	411	{
sl@0	412	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	413	return err;
sl@0	414	}
sl@0	415
sl@0	416	c_stream.next_in = (Bytef*)hello;
sl@0	417	c_stream.next_out = compr;
sl@0	418
sl@0	419	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	420	{
sl@0	421	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	422	err = deflate (&c_stream, flush);
sl@0	423	if ( err != Z_OK)
sl@0	424	{
sl@0	425	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	426	deflateEnd (&c_stream);
sl@0	427	return err;
sl@0	428	}
sl@0	429	}
sl@0	430	// Finish the stream, still forcing small buffers:
sl@0	431	for (;;)
sl@0	432	{
sl@0	433	c_stream.avail_out = 1;
sl@0	434	err = deflate (&c_stream, Z_FINISH);
sl@0	435	if ( err == Z_STREAM_END)
sl@0	436	break;
sl@0	437	if ( err != Z_OK)
sl@0	438	{
sl@0	439	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	440	deflateEnd (&c_stream);
sl@0	441	return err;
sl@0	442	}
sl@0	443	}
sl@0	444
sl@0	445	deflateEnd (&c_stream);
sl@0	446	return KErrNone;
sl@0	447	}
sl@0	448
sl@0	449	TInt CTestZlib::sec_deflate02( Byte * compr, uLong comprLen, TInt flush,
sl@0	450	TInt compression)
sl@0	451	{
sl@0	452	z_stream c_stream; // compression stream
sl@0	453	int err;
sl@0	454	const char hello[] = "hello, hello!";
sl@0	455	uLong len = (uLong)strlen(hello)+1;
sl@0	456
sl@0	457	c_stream.zalloc = (alloc_func)0;
sl@0	458	c_stream.zfree = (free_func)0;
sl@0	459	c_stream.opaque = (voidpf)0;
sl@0	460
sl@0	461	err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
sl@0	462
sl@0	463	if ( err != Z_OK)
sl@0	464	{
sl@0	465	INFO_PRINTF2(_L("deflateInit error: %d"), err);
sl@0	466	return err;
sl@0	467	}
sl@0	468
sl@0	469	c_stream.next_in = (Bytef*)hello;
sl@0	470	c_stream.next_out = compr;
sl@0	471
sl@0	472	while (c_stream.total_in != len && c_stream.total_out < comprLen)
sl@0	473	{
sl@0	474	c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
sl@0	475	err = deflate (&c_stream, Z_NO_FLUSH);
sl@0	476	if ( err != Z_OK)
sl@0	477	{
sl@0	478	INFO_PRINTF2(_L("deflate return code: %d"), err);
sl@0	479	deflateEnd (&c_stream);
sl@0	480	return err;
sl@0	481	}
sl@0	482	}
sl@0	483	// Finish the stream, still forcing small buffers:
sl@0	484	for (;;)
sl@0	485	{
sl@0	486	c_stream.avail_out = 1;
sl@0	487	err = deflate (&c_stream, Z_FINISH);
sl@0	488	if ( err == Z_STREAM_END)
sl@0	489	break;
sl@0	490	if ( err != Z_OK)
sl@0	491	{
sl@0	492	INFO_PRINTF2(_L("deflate error: %d"), err);
sl@0	493	deflateEnd (&c_stream);
sl@0	494	return err;
sl@0	495	}
sl@0	496	}
sl@0	497
sl@0	498	//deflate call after a finish
sl@0	499	err = deflate (&c_stream, flush);
sl@0	500	deflateEnd (&c_stream);
sl@0	501	return err;
sl@0	502	}
sl@0	503	//-------------------------------/INFLATE/----------------------------------
sl@0	504
sl@0	505	TInt CTestZlib::sec_inflate( Byte * compr, uLong comprLen, Byte * uncompr,
sl@0	506	uLong uncomprLen, TInt flush)
sl@0	507	{
sl@0	508	int err;
sl@0	509	const char hello[] = "hello, hello!";
sl@0	510	z_stream d_stream; // decompression stream
sl@0	511
sl@0	512	//strcpy((char*)uncompr, "garbage");
sl@0	513
sl@0	514	d_stream.zalloc = (alloc_func)0;
sl@0	515	d_stream.zfree = (free_func)0;
sl@0	516	d_stream.opaque = (voidpf)0;
sl@0	517
sl@0	518	d_stream.next_in = compr;
sl@0	519	d_stream.avail_in = 0;
sl@0	520	d_stream.next_out = uncompr;
sl@0	521
sl@0	522	err = inflateInit (&d_stream);
sl@0	523	CHECK_ERR(err, "inflateInit");
sl@0	524
sl@0	525	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	526	{
sl@0	527	d_stream.avail_in = d_stream.avail_out = 1; // force small buffers
sl@0	528	err = inflate (&d_stream, flush);
sl@0	529	if ( err == Z_STREAM_END)
sl@0	530	break;
sl@0	531	if ( err != Z_OK)
sl@0	532	{
sl@0	533	inflateEnd (&d_stream);
sl@0	534	return err;
sl@0	535	}
sl@0	536	}
sl@0	537
sl@0	538	err = inflateEnd (&d_stream);
sl@0	539	CHECK_ERR(err, "inflateEnd");
sl@0	540
sl@0	541	if ( strcmp ((char*)uncompr, hello))
sl@0	542	{
sl@0	543	ERR_PRINTF1(_L("Bad inflate"));
sl@0	544	return KErrGeneral;
sl@0	545	}
sl@0	546	else
sl@0	547	{
sl@0	548	INFO_PRINTF1(_L("inflate success"));
sl@0	549	}
sl@0	550	return 0;
sl@0	551	}
sl@0	552
sl@0	553	//256K buffer size to hold streams
sl@0	554	TInt CTestZlib::sec_inflate_large_buf( Byte * compr, uLong comprLen,
sl@0	555	Byte * uncompr, uLong uncomprLen, TInt flush)
sl@0	556	{
sl@0	557	int err;
sl@0	558	const char hello[] = "hello, hello!";
sl@0	559	z_stream d_stream; // decompression stream
sl@0	560
sl@0	561	//strcpy((char*)uncompr, "garbage");
sl@0	562
sl@0	563	d_stream.zalloc = (alloc_func)0;
sl@0	564	d_stream.zfree = (free_func)0;
sl@0	565	d_stream.opaque = (voidpf)0;
sl@0	566
sl@0	567	d_stream.next_in = compr;
sl@0	568	d_stream.avail_in = 0;
sl@0	569	d_stream.next_out = uncompr;
sl@0	570
sl@0	571	err = inflateInit (&d_stream);
sl@0	572	CHECK_ERR(err, "inflateInit");
sl@0	573
sl@0	574	while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
sl@0	575	{
sl@0	576	d_stream.avail_in = d_stream.avail_out = 262144; // 256K
sl@0	577	err = inflate (&d_stream, flush);
sl@0	578	if ( err == Z_STREAM_END)
sl@0	579	break;
sl@0	580	if ( err != Z_OK)
sl@0	581	{
sl@0	582	inflateEnd (&d_stream);
sl@0	583	return err;
sl@0	584	}
sl@0	585	}
sl@0	586
sl@0	587	err = inflateEnd (&d_stream);
sl@0	588	CHECK_ERR(err, "inflateEnd");
sl@0	589
sl@0	590	if ( strcmp ((char*)uncompr, hello))
sl@0	591	{
sl@0	592	ERR_PRINTF1(_L("Bad inflate"));
sl@0	593	return KErrGeneral;
sl@0	594	}
sl@0	595	else
sl@0	596	{
sl@0	597	INFO_PRINTF1(_L("inflate success"));
sl@0	598	}
sl@0	599	return 0;
sl@0	600	}
sl@0	601
sl@0	602	//----------------------------//GZ OPERATION//--------------------------------
sl@0	603
sl@0	604	TInt CTestZlib::sec_gzio( const char fname, Byte uncompr, uLong uncomprLen)
sl@0	605	{
sl@0	606	#ifdef NO_GZCOMPRESS
sl@0	607	ERR_PRINTF1(_L("NO_GZCOMPRESS -- gz* functions cannot compress"));
sl@0	608	#else
sl@0	609	const char hello[] = "hello, hello!";
sl@0	610	int len = (int)strlen(hello)+1;
sl@0	611	gzFile file;
sl@0	612	z_off_t pos;
sl@0	613
sl@0	614	file = gzopen (fname, "wb");
sl@0	615	if ( file == NULL)
sl@0	616	{
sl@0	617	ERR_PRINTF1(_L("gzopen error"));
sl@0	618	return KErrGeneral;
sl@0	619	}
sl@0	620	gzputc (file, 'h');
sl@0	621	if ( gzputs (file, "ello")!= 4)
sl@0	622	{
sl@0	623	gzclose (file);
sl@0	624	ERR_PRINTF1(_L("gzputs err"));
sl@0	625	return KErrGeneral;
sl@0	626	}
sl@0	627	if ( gzprintf (file, ", %s!", "hello")!= 8)
sl@0	628	{
sl@0	629	gzclose (file);
sl@0	630	ERR_PRINTF1(_L("gzprintf err:"));
sl@0	631	return KErrGeneral;
sl@0	632	}
sl@0	633
sl@0	634	gzseek (file, 1L, SEEK_CUR); // add one zero byte
sl@0	635	gzclose (file);
sl@0	636
sl@0	637	file = gzopen (fname, "rb");
sl@0	638	if ( file == NULL)
sl@0	639	{
sl@0	640	ERR_PRINTF1(_L("gzopen error"));
sl@0	641	return KErrGeneral;
sl@0	642	}
sl@0	643	strcpy ((char*)uncompr, "garbage");
sl@0	644
sl@0	645	if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
sl@0	646	{
sl@0	647	gzclose (file);
sl@0	648	ERR_PRINTF1(_L("gzread err"));
sl@0	649	return KErrGeneral;
sl@0	650	}
sl@0	651
sl@0	652	if ( strcmp ((char*)uncompr, hello))
sl@0	653	{
sl@0	654	gzclose (file);
sl@0	655	ERR_PRINTF1(_L("bad gzread"));
sl@0	656	return KErrGeneral;
sl@0	657	}
sl@0	658
sl@0	659	pos = gzseek (file, -8L, SEEK_CUR);
sl@0	660	if ( pos != 6 \|\| gztell (file)!= pos)
sl@0	661	{
sl@0	662	gzclose (file);
sl@0	663	ERR_PRINTF3(_L("gzseek error, pos=%ld, gztell=%ld"),(long)pos, (long)gztell(file));
sl@0	664	return KErrGeneral;
sl@0	665	}
sl@0	666
sl@0	667	if ( gzgetc (file)!= ' ')
sl@0	668	{
sl@0	669	gzclose (file);
sl@0	670	ERR_PRINTF1(_L("gzgetc error"));
sl@0	671	return KErrGeneral;
sl@0	672	}
sl@0	673
sl@0	674	if ( gzungetc (' ', file)!= ' ')
sl@0	675	{
sl@0	676	gzclose (file);
sl@0	677	ERR_PRINTF1(_L("gzungetc error"));
sl@0	678	return KErrGeneral;
sl@0	679	}
sl@0	680
sl@0	681	gzgets (file, (char*)uncompr, (int)uncomprLen);
sl@0	682
sl@0	683	if ( strlen ((char*)uncompr)!= 7)
sl@0	684	{
sl@0	685	gzclose (file);
sl@0	686	// " hello!"
sl@0	687	ERR_PRINTF1(_L("gzgets err after gzseek"));
sl@0	688	return KErrGeneral;
sl@0	689	}
sl@0	690
sl@0	691	if ( strcmp ((char*)uncompr, hello + 6))
sl@0	692	{
sl@0	693	gzclose (file);
sl@0	694	ERR_PRINTF1(_L("bad gzgets after gzseek"));
sl@0	695	return KErrGeneral;
sl@0	696	}
sl@0	697
sl@0	698	gzclose (file);
sl@0	699	#endif
sl@0	700	return KErrNone;
sl@0	701	}
sl@0	702
sl@0	703	TInt CTestZlib::Test_zlibVersion()
sl@0	704	{
sl@0	705	INFO_PRINTF1(_L("Zlib Test zlibVersion"));
sl@0	706	int retVal = 0;
sl@0	707
sl@0	708	const char *version = zlibVersion ();
sl@0	709	if ( strcmp (ZLIB_VERSION, version)== 0)
sl@0	710	{
sl@0	711	INFO_PRINTF1(_L("Returned version matches!"));
sl@0	712	retVal=KErrNone;
sl@0	713	}
sl@0	714
sl@0	715	else
sl@0	716	{
sl@0	717	ERR_PRINTF1(_L("Return version mismatch!"));
sl@0	718	retVal=KErrGeneral;
sl@0	719	}
sl@0	720	return retVal;
sl@0	721	}
sl@0	722
sl@0	723	TInt CTestZlib::Test_compress01()
sl@0	724	{
sl@0	725	INFO_PRINTF1(_L("Zlib Test compress"));
sl@0	726	int retVal = 0;
sl@0	727
sl@0	728	Byte comp, uncomp;
sl@0	729	uLong compLen, uncompLen;
sl@0	730	compLen = uncompLen = 30;
sl@0	731
sl@0	732	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	733	if ( comp == NULL)
sl@0	734	{
sl@0	735	INFO_PRINTF1(_L("Could not allocate memory for comp."));
sl@0	736	return KErrNoMemory;
sl@0	737	}
sl@0	738	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	739	if ( uncomp == NULL)
sl@0	740	{
sl@0	741	INFO_PRINTF1(_L("Could not allocate memory for uncomp."));
sl@0	742	free (comp);
sl@0	743	return KErrNoMemory;
sl@0	744	}
sl@0	745
sl@0	746	retVal = sec_compress (comp, compLen, uncomp, uncompLen);
sl@0	747	free (comp);
sl@0	748	free (uncomp);
sl@0	749	return retVal;
sl@0	750	}
sl@0	751
sl@0	752	// Test deflate - normal flow
sl@0	753	TInt CTestZlib::Test_deflate01()
sl@0	754	{
sl@0	755	INFO_PRINTF1(_L("Zlib Test deflate"));
sl@0	756	int retVal = KErrGeneral;
sl@0	757	TInt flush, compression, expRet;
sl@0	758
sl@0	759	Byte *comp;
sl@0	760	uLong compLen;
sl@0	761	compLen = 30;
sl@0	762	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	763
sl@0	764	ReadIntParam (flush);
sl@0	765	ReadIntParam (compression);
sl@0	766	ReadIntParam (expRet);
sl@0	767
sl@0	768	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	769	free (comp);
sl@0	770	if ( retVal != expRet)
sl@0	771	{
sl@0	772	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	773	retVal= KErrGeneral;
sl@0	774	}
sl@0	775	else
sl@0	776	{
sl@0	777	INFO_PRINTF1(_L("Test passes!"));
sl@0	778	retVal= KErrNone;
sl@0	779	}
sl@0	780	return retVal;
sl@0	781	}
sl@0	782
sl@0	783	//Negative test -
sl@0	784	TInt CTestZlib::Test_deflate02()
sl@0	785	{
sl@0	786	INFO_PRINTF1(_L("Zlib Test deflate"));
sl@0	787	int retVal = KErrGeneral;
sl@0	788	TInt flush, compression, expRet;
sl@0	789
sl@0	790	Byte *comp;
sl@0	791	uLong compLen;
sl@0	792	compLen = 30;
sl@0	793	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	794
sl@0	795	ReadIntParam (flush);
sl@0	796	ReadIntParam (compression);
sl@0	797	ReadIntParam (expRet);
sl@0	798
sl@0	799	retVal = sec_deflate02 (comp, compLen, flush, compression);
sl@0	800	free (comp);
sl@0	801	if ( retVal != expRet)
sl@0	802	{
sl@0	803	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	804	retVal= KErrGeneral;
sl@0	805	}
sl@0	806	else
sl@0	807	{
sl@0	808	INFO_PRINTF1(_L("Test passes!"));
sl@0	809	retVal= KErrNone;
sl@0	810	}
sl@0	811	return retVal;
sl@0	812	}
sl@0	813
sl@0	814	// Test deflate small output buffer
sl@0	815	TInt CTestZlib::Test_deflateEnd()
sl@0	816	{
sl@0	817	INFO_PRINTF1(_L("Zlib Test deflateEnd"));
sl@0	818
sl@0	819	Byte *comp;
sl@0	820	uLong compLen;
sl@0	821	compLen = 30;
sl@0	822
sl@0	823	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	824
sl@0	825	z_stream c_stream; // compression stream
sl@0	826	int err;
sl@0	827	const char hello[] = "hello, hello!";
sl@0	828	uLong len = (uLong)strlen(hello)+1;
sl@0	829
sl@0	830	c_stream.zalloc = (alloc_func)0;
sl@0	831	c_stream.zfree = (free_func)0;
sl@0	832	c_stream.opaque = (voidpf)0;
sl@0	833
sl@0	834	err = deflateInit (&c_stream, Z_DEFAULT_COMPRESSION);
sl@0	835	if ( err != Z_OK)
sl@0	836	{
sl@0	837	INFO_PRINTF2(_L("deflateInit failed: %d"), err);
sl@0	838	free (comp);
sl@0	839	return err;
sl@0	840	}
sl@0	841
sl@0	842	c_stream.next_in = (Bytef*)hello;
sl@0	843	c_stream.next_out = comp;
sl@0	844	err = deflateEnd (&c_stream);
sl@0	845	if ( err != Z_OK)
sl@0	846	{
sl@0	847	ERR_PRINTF2(_L("deflateEnd failed: %d"), err);
sl@0	848	free (comp);
sl@0	849	return err;
sl@0	850	}
sl@0	851	if ( c_stream.state != NULL)
sl@0	852	{
sl@0	853	ERR_PRINTF1(_L("Stream state expected NULL"));
sl@0	854	free (comp);
sl@0	855	return err;
sl@0	856	}
sl@0	857	free (comp);
sl@0	858	return KErrNone;
sl@0	859	}
sl@0	860
sl@0	861	TInt CTestZlib::Test_inflate01()
sl@0	862	{
sl@0	863	INFO_PRINTF1(_L("Zlib Test inflate. Positive test"));
sl@0	864	int retVal = KErrGeneral;
sl@0	865	TInt flush, compression, expRet;
sl@0	866	Byte comp, uncomp;
sl@0	867	uLong compLen, uncompLen;
sl@0	868	compLen = uncompLen = 60;
sl@0	869
sl@0	870	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	871	//comp = (Byte*)malloc(compLen);
sl@0	872	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	873	//uncomp = (Byte*)malloc(uncompLen);
sl@0	874
sl@0	875	ReadIntParam (flush);
sl@0	876	ReadIntParam (compression);
sl@0	877	ReadIntParam (expRet);
sl@0	878
sl@0	879	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	880	if ( retVal != KErrNone)
sl@0	881	{
sl@0	882	ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
sl@0	883	retVal= KErrGeneral;
sl@0	884	}
sl@0	885	retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
sl@0	886	if ( retVal != expRet)
sl@0	887	{
sl@0	888	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	889	retVal= KErrGeneral;
sl@0	890	}
sl@0	891	else
sl@0	892	{
sl@0	893	INFO_PRINTF1(_L("Test passes!"));
sl@0	894	retVal= KErrNone;
sl@0	895	}
sl@0	896	free (comp);
sl@0	897	free (uncomp);
sl@0	898	return retVal;
sl@0	899	}
sl@0	900
sl@0	901	//Negative test - invalid deflate data - return Z_DATA_ERROR
sl@0	902	TInt CTestZlib::Test_inflate02()
sl@0	903	{
sl@0	904	INFO_PRINTF1(_L("Zlib Test inflate with invalide deflate data"));
sl@0	905	int retVal = KErrGeneral;
sl@0	906	TInt flush, compression, expRet;
sl@0	907	Byte comp, uncomp;
sl@0	908	uLong compLen, uncompLen;
sl@0	909	compLen = uncompLen = 30;
sl@0	910
sl@0	911	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	912	//comp = (Byte*)malloc(compLen);
sl@0	913	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	914	//uncomp = (Byte*)malloc(uncompLen);
sl@0	915
sl@0	916	ReadIntParam (flush);
sl@0	917	ReadIntParam (compression);
sl@0	918	ReadIntParam (expRet);
sl@0	919
sl@0	920	retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
sl@0	921	if ( retVal != expRet)
sl@0	922	{
sl@0	923	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	924	retVal= KErrGeneral;
sl@0	925	}
sl@0	926	else
sl@0	927	{
sl@0	928	INFO_PRINTF1(_L("Test passes!"));
sl@0	929	retVal= KErrNone;
sl@0	930	}
sl@0	931	free (comp);
sl@0	932	free (uncomp);
sl@0	933	return retVal;
sl@0	934	}
sl@0	935
sl@0	936	// uncompressed data buffer inititalized to NULL
sl@0	937	TInt CTestZlib::Test_inflate03()
sl@0	938	{
sl@0	939	INFO_PRINTF1(_L("Zlib Test inflate with NULL uncompressed data buffer"));
sl@0	940	int retVal = KErrGeneral;
sl@0	941	TInt flush, compression, expRet;
sl@0	942	Byte comp=NULL, uncomp=NULL;
sl@0	943	uLong compLen, uncompLen;
sl@0	944	compLen = uncompLen = 30;
sl@0	945
sl@0	946	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	947	//uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
sl@0	948
sl@0	949	ReadIntParam (flush);
sl@0	950	ReadIntParam (compression);
sl@0	951	ReadIntParam (expRet);
sl@0	952
sl@0	953	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	954	if ( retVal != KErrNone)
sl@0	955	{
sl@0	956	ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
sl@0	957	retVal= KErrGeneral;
sl@0	958	}
sl@0	959	retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
sl@0	960	if ( retVal != expRet)
sl@0	961	{
sl@0	962	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	963	retVal= KErrGeneral;
sl@0	964	}
sl@0	965	else
sl@0	966	{
sl@0	967	INFO_PRINTF1(_L("Test passes!"));
sl@0	968	retVal= KErrNone;
sl@0	969	}
sl@0	970	free (comp); //free(uncomp);
sl@0	971	return retVal;
sl@0	972	}
sl@0	973
sl@0	974	//Not enough buffer size for uncompresed data
sl@0	975	TInt CTestZlib::Test_inflate04()
sl@0	976	{
sl@0	977	INFO_PRINTF1(_L("Zlib Test inflatewith not enough buffer size for uncompressed data"));
sl@0	978	int retVal = KErrGeneral;
sl@0	979	TInt flush, compression, expRet;
sl@0	980	Byte comp=NULL, uncomp=NULL;
sl@0	981	uLong compLen, uncompLen;
sl@0	982	compLen = 30;
sl@0	983	uncompLen = 5;
sl@0	984
sl@0	985	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	986	uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
sl@0	987
sl@0	988	ReadIntParam (flush);
sl@0	989	ReadIntParam (compression);
sl@0	990	ReadIntParam (expRet);
sl@0	991
sl@0	992	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	993	if ( retVal != KErrNone)
sl@0	994	{
sl@0	995	ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
sl@0	996	retVal= KErrGeneral;
sl@0	997	}
sl@0	998	retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
sl@0	999	if ( retVal != expRet)
sl@0	1000	{
sl@0	1001	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1002	retVal= KErrGeneral;
sl@0	1003	}
sl@0	1004	else
sl@0	1005	{
sl@0	1006	INFO_PRINTF1(_L("Test passes!"));
sl@0	1007	retVal= KErrNone;
sl@0	1008	}
sl@0	1009	free (comp);
sl@0	1010	free (uncomp);
sl@0	1011	return retVal;
sl@0	1012	}
sl@0	1013
sl@0	1014	//Use 256K sized chunks for inflating
sl@0	1015	TInt CTestZlib::Test_inflate05()
sl@0	1016	{
sl@0	1017	INFO_PRINTF1(_L("Zlib Test inflate with 256K sized chunks"));
sl@0	1018	int retVal = KErrGeneral;
sl@0	1019	TInt flush, compression, expRet;
sl@0	1020	Byte comp=NULL, uncomp=NULL;
sl@0	1021	uLong compLen, uncompLen;
sl@0	1022	compLen = 30;
sl@0	1023	uncompLen = 30;
sl@0	1024
sl@0	1025	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1026	uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
sl@0	1027
sl@0	1028	ReadIntParam (flush);
sl@0	1029	ReadIntParam (compression);
sl@0	1030	ReadIntParam (expRet);
sl@0	1031
sl@0	1032	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	1033	if ( retVal != KErrNone)
sl@0	1034	{
sl@0	1035	ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
sl@0	1036	retVal= KErrGeneral;
sl@0	1037	}
sl@0	1038	retVal = sec_inflate_large_buf (comp, compLen, uncomp, uncompLen, flush);
sl@0	1039	if ( retVal != expRet)
sl@0	1040	{
sl@0	1041	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1042	retVal= KErrGeneral;
sl@0	1043	}
sl@0	1044	else
sl@0	1045	{
sl@0	1046	INFO_PRINTF1(_L("Test passes!"));
sl@0	1047	retVal= KErrNone;
sl@0	1048	}
sl@0	1049	free (comp);
sl@0	1050	free (uncomp);
sl@0	1051	return retVal;
sl@0	1052	}
sl@0	1053
sl@0	1054	TInt CTestZlib::Test_inflate06()
sl@0	1055	{
sl@0	1056	INFO_PRINTF1(_L("Zlib Test inflate with invalid data"));
sl@0	1057	int retVal = KErrGeneral;
sl@0	1058	TInt flush, compression, expRet;
sl@0	1059	Byte comp, uncomp;
sl@0	1060	uLong compLen, uncompLen;
sl@0	1061	compLen = uncompLen = 60;
sl@0	1062
sl@0	1063	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1064	//comp = (Byte*)malloc(compLen);
sl@0	1065	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	1066	//uncomp = (Byte*)malloc(uncompLen);
sl@0	1067
sl@0	1068	ReadIntParam (flush);
sl@0	1069	ReadIntParam (compression);
sl@0	1070	ReadIntParam (expRet);
sl@0	1071
sl@0	1072	retVal = sec_deflate01 (comp, compLen, flush, compression);
sl@0	1073	if ( retVal != KErrNone)
sl@0	1074	{
sl@0	1075	ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
sl@0	1076	retVal= KErrGeneral;
sl@0	1077	}
sl@0	1078
sl@0	1079	// Corrupt the compressed data
sl@0	1080	comp[0] = 'a';
sl@0	1081	comp[1] = 'a';
sl@0	1082
sl@0	1083	retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
sl@0	1084	if ( retVal != expRet)
sl@0	1085	{
sl@0	1086	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1087	retVal= KErrGeneral;
sl@0	1088	}
sl@0	1089	else
sl@0	1090	{
sl@0	1091	INFO_PRINTF1(_L("Test passes!"));
sl@0	1092	retVal= KErrNone;
sl@0	1093	}
sl@0	1094	free (comp);
sl@0	1095	free (uncomp);
sl@0	1096	return retVal;
sl@0	1097	}
sl@0	1098
sl@0	1099	TInt CTestZlib::Test_inflateEnd()
sl@0	1100	{
sl@0	1101	INFO_PRINTF1(_L("Zlib Test inflateEnd"));
sl@0	1102	Byte comp, uncomp;
sl@0	1103	uLong compLen, uncompLen;
sl@0	1104	compLen = uncompLen = 30;
sl@0	1105
sl@0	1106	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1107	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	1108
sl@0	1109	int err;
sl@0	1110	z_stream d_stream; // decompression stream
sl@0	1111
sl@0	1112	//strcpy((char*)uncompr, "garbage");
sl@0	1113
sl@0	1114	d_stream.zalloc = (alloc_func)0;
sl@0	1115	d_stream.zfree = (free_func)0;
sl@0	1116	d_stream.opaque = (voidpf)0;
sl@0	1117
sl@0	1118	d_stream.next_in = comp;
sl@0	1119	d_stream.avail_in = 0;
sl@0	1120	d_stream.next_out = uncomp;
sl@0	1121
sl@0	1122	err = inflateInit (&d_stream);
sl@0	1123	if ( err != Z_OK)
sl@0	1124	{
sl@0	1125	INFO_PRINTF2(_L("inflateInit error: %d"), err);
sl@0	1126	free (comp);
sl@0	1127	free (uncomp);
sl@0	1128	return err;
sl@0	1129	}
sl@0	1130	//Not inflating
sl@0	1131
sl@0	1132	err = inflateEnd (&d_stream);
sl@0	1133	if ( err != Z_OK)
sl@0	1134	{
sl@0	1135	INFO_PRINTF2(_L("inflateEnd error: %d"), err);
sl@0	1136	free (comp);
sl@0	1137	free (uncomp);
sl@0	1138	return err;
sl@0	1139	}
sl@0	1140	if ( d_stream.state != NULL)
sl@0	1141	{
sl@0	1142	INFO_PRINTF2(_L("inflateEnd error: %d"), err);
sl@0	1143	free (comp);
sl@0	1144	free (uncomp);
sl@0	1145	return err;
sl@0	1146	}
sl@0	1147
sl@0	1148	free (comp);
sl@0	1149	free (uncomp);
sl@0	1150	return KErrNone;
sl@0	1151	}
sl@0	1152
sl@0	1153	// Test deflateSetDictionary - normal flow
sl@0	1154	TInt CTestZlib::Test_deflateSetDictionary01()
sl@0	1155	{
sl@0	1156	INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - positive test"));
sl@0	1157	int retVal = KErrGeneral;
sl@0	1158	TInt flush, compression, expRet;
sl@0	1159
sl@0	1160	Byte *comp;
sl@0	1161	uLong compLen;
sl@0	1162	compLen = 30;
sl@0	1163	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1164
sl@0	1165	ReadIntParam (flush);
sl@0	1166	ReadIntParam (compression);
sl@0	1167	ReadIntParam (expRet);
sl@0	1168
sl@0	1169	retVal = sec_deflateSetDictionary01 (comp, compLen, flush, compression);
sl@0	1170	free (comp);
sl@0	1171	if ( retVal != expRet)
sl@0	1172	{
sl@0	1173	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1174	retVal= KErrGeneral;
sl@0	1175	}
sl@0	1176	else
sl@0	1177	{
sl@0	1178	INFO_PRINTF1(_L("Test passes!"));
sl@0	1179	retVal= KErrNone;
sl@0	1180	}
sl@0	1181	return retVal;
sl@0	1182	}
sl@0	1183
sl@0	1184	// Test deflateSetDictionary - dictionary NULL
sl@0	1185	TInt CTestZlib::Test_deflateSetDictionary02()
sl@0	1186	{
sl@0	1187	INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary with dictionary NULL"));
sl@0	1188	int retVal = KErrGeneral;
sl@0	1189
sl@0	1190	TInt compression, expRet;
sl@0	1191
sl@0	1192	ReadIntParam (compression);
sl@0	1193	ReadIntParam (expRet);
sl@0	1194	retVal = sec_deflateSetDictionary02 (compression);
sl@0	1195
sl@0	1196	if ( retVal != expRet)
sl@0	1197	{
sl@0	1198	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1199	retVal= KErrGeneral;
sl@0	1200	}
sl@0	1201	else
sl@0	1202	{
sl@0	1203	INFO_PRINTF1(_L("Test passes!"));
sl@0	1204	retVal= KErrNone;
sl@0	1205	}
sl@0	1206	return retVal;
sl@0	1207	}
sl@0	1208
sl@0	1209	// Test deflateSetDictionary - set dictionary after deflate, deflateEnd
sl@0	1210	TInt CTestZlib::Test_deflateSetDictionary03()
sl@0	1211	{
sl@0	1212	INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - set dictionary after deflating"));
sl@0	1213	int retVal = KErrGeneral;
sl@0	1214	TInt flush, compression, expRet;
sl@0	1215
sl@0	1216	Byte *comp;
sl@0	1217	uLong compLen;
sl@0	1218	compLen = 30;
sl@0	1219	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1220
sl@0	1221	ReadIntParam (flush);
sl@0	1222	ReadIntParam (compression);
sl@0	1223	ReadIntParam (expRet);
sl@0	1224
sl@0	1225	retVal = sec_deflateSetDictionary03 (comp, compLen, flush, compression);
sl@0	1226	free (comp);
sl@0	1227	if ( retVal != expRet)
sl@0	1228	{
sl@0	1229	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1230	retVal= KErrGeneral;
sl@0	1231	}
sl@0	1232	else
sl@0	1233	{
sl@0	1234	INFO_PRINTF1(_L("Test passes!"));
sl@0	1235	retVal= KErrNone;
sl@0	1236	}
sl@0	1237	return retVal;
sl@0	1238	}
sl@0	1239	// Test deflateSetDictionary - set tiny dictionary < MIN_MATCH
sl@0	1240	TInt CTestZlib::Test_deflateSetDictionary04()
sl@0	1241	{
sl@0	1242	INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - positive test"));
sl@0	1243	int retVal = KErrGeneral;
sl@0	1244	TInt flush, compression, expRet;
sl@0	1245
sl@0	1246	Byte *comp;
sl@0	1247	uLong compLen;
sl@0	1248	compLen = 30;
sl@0	1249	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1250
sl@0	1251	ReadIntParam (flush);
sl@0	1252	ReadIntParam (compression);
sl@0	1253	ReadIntParam (expRet);
sl@0	1254
sl@0	1255	retVal = sec_deflateSetDictionary04 (comp, compLen, flush, compression);
sl@0	1256	free (comp);
sl@0	1257	if ( retVal != expRet)
sl@0	1258	{
sl@0	1259	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1260	retVal= KErrGeneral;
sl@0	1261	}
sl@0	1262	else
sl@0	1263	{
sl@0	1264	INFO_PRINTF1(_L("Test passes!"));
sl@0	1265	retVal= KErrNone;
sl@0	1266	}
sl@0	1267	return retVal;
sl@0	1268	}
sl@0	1269
sl@0	1270	// Test deflateSetDictionary - set large dictionary > MAX_MATCH
sl@0	1271	TInt CTestZlib::Test_deflateSetDictionary05()
sl@0	1272	{
sl@0	1273	INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - set large dictionary > MAX_MATCH"));
sl@0	1274	int retVal = KErrGeneral;
sl@0	1275	TInt flush, compression, expRet;
sl@0	1276
sl@0	1277	Byte *comp;
sl@0	1278	uLong compLen;
sl@0	1279	compLen = 30;
sl@0	1280	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1281
sl@0	1282	ReadIntParam (flush);
sl@0	1283	ReadIntParam (compression);
sl@0	1284	ReadIntParam (expRet);
sl@0	1285
sl@0	1286	retVal = sec_deflateSetDictionary05 (comp, compLen, flush, compression);
sl@0	1287	free (comp);
sl@0	1288	if ( retVal != expRet)
sl@0	1289	{
sl@0	1290	ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
sl@0	1291	retVal= KErrGeneral;
sl@0	1292	}
sl@0	1293	else
sl@0	1294	{
sl@0	1295	INFO_PRINTF1(_L("Test passes!"));
sl@0	1296	retVal= KErrNone;
sl@0	1297	}
sl@0	1298	return retVal;
sl@0	1299	}
sl@0	1300
sl@0	1301	TInt CTestZlib::Test_gzio()
sl@0	1302	{
sl@0	1303	INFO_PRINTF1(_L("Zlib Test gzio"));
sl@0	1304	int retVal = 0;
sl@0	1305
sl@0	1306	Byte comp, uncomp;
sl@0	1307	uLong compLen, uncompLen;
sl@0	1308	compLen = uncompLen = 30;
sl@0	1309
sl@0	1310	comp = (Byte*)calloc((uInt)compLen, 1);
sl@0	1311	if ( comp == NULL)
sl@0	1312	{
sl@0	1313	INFO_PRINTF1(_L("Could not allocate memory for comp."));
sl@0	1314	return KErrNoMemory;
sl@0	1315	}
sl@0	1316
sl@0	1317	uncomp = (Byte*)calloc((uInt)uncompLen, 1);
sl@0	1318	if ( uncomp == NULL)
sl@0	1319	{
sl@0	1320	INFO_PRINTF1(_L("Could not allocate memory for uncomp."));
sl@0	1321	free (comp);
sl@0	1322	return KErrNoMemory;
sl@0	1323	}
sl@0	1324
sl@0	1325	retVal = sec_gzio ("C:\\bye.gz", uncomp, uncompLen);
sl@0	1326	free (comp);
sl@0	1327	free (uncomp);
sl@0	1328	return retVal;
sl@0	1329	}
sl@0	1330
sl@0	1331	TInt CTestZlib::Test_gzdirect()
sl@0	1332	{
sl@0	1333	INFO_PRINTF1(_L("gzdirect test: read gz file"));
sl@0	1334	TInt res = KErrNone;
sl@0	1335	char mode[3];
sl@0	1336	gzFile file;
sl@0	1337	const char * fname= TESTFILE;
sl@0	1338	ReadStringParam (mode);
sl@0	1339	file = gzopen (fname, mode);
sl@0	1340	if ( file == NULL)
sl@0	1341	{
sl@0	1342	res = KErrGeneral;
sl@0	1343	return res;
sl@0	1344	}
sl@0	1345	res = gzdirect (file); //0=success
sl@0	1346	gzclose (file);
sl@0	1347	return res;
sl@0	1348	}
sl@0	1349
sl@0	1350	TInt CTestZlib::Test_gzdirectnull()
sl@0	1351	{
sl@0	1352	INFO_PRINTF1(_L("gzdirect test: read NULL stream"));
sl@0	1353	TInt res = KErrNone;
sl@0	1354	gzFile file=NULL;
sl@0	1355	res = gzdirect (file); //0=success
sl@0	1356	gzclose (file);
sl@0	1357	return res;
sl@0	1358	}
sl@0	1359
sl@0	1360	TInt CTestZlib::Test_gzclearerr_null()
sl@0	1361	{
sl@0	1362	TInt res = KErrNone;
sl@0	1363	int err;
sl@0	1364	gzFile file;
sl@0	1365	const char *fname= NULL;
sl@0	1366	file = gzopen (fname, "wb");
sl@0	1367	if ( file == NULL)
sl@0	1368	{
sl@0	1369	res=KErrGeneral;
sl@0	1370	}
sl@0	1371	gzputc (file, 'h');
sl@0	1372	if ( gzputs (file, "ello")!= 5)
sl@0	1373	{
sl@0	1374	gzprintf (file, "gzputs err");
sl@0	1375	res=KErrGeneral;
sl@0	1376	}
sl@0	1377	err= gzclose (file);
sl@0	1378	if ( err != Z_OK)
sl@0	1379	{
sl@0	1380	res = KErrGeneral;
sl@0	1381	}
sl@0	1382	gzclearerr (file);
sl@0	1383	z_stream s = (z_stream)file;
sl@0	1384	if ( s == NULL)
sl@0	1385	res = KErrNone;
sl@0	1386	else
sl@0	1387	{
sl@0	1388	ERR_PRINTF1(_L("Expected NULL stream. Returned nonNULL"));
sl@0	1389	res = KErrGeneral;
sl@0	1390	}
sl@0	1391	return res;
sl@0	1392	}
sl@0	1393
sl@0	1394	TInt CTestZlib::Test_gzclearerr()
sl@0	1395	{
sl@0	1396
sl@0	1397	Byte compr, uncompr;
sl@0	1398	uLong comprLen = 20*sizeof(int);
sl@0	1399
sl@0	1400	uLong uncomprLen = comprLen;
sl@0	1401	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1402	if ( compr == Z_NULL)
sl@0	1403	{
sl@0	1404	return KErrNoMemory;
sl@0	1405	}
sl@0	1406	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1407	if ( uncompr == Z_NULL)
sl@0	1408	{
sl@0	1409	free (compr);
sl@0	1410	return KErrNoMemory;
sl@0	1411	}
sl@0	1412
sl@0	1413	INFO_PRINTF1(_L("gzclearerr test"));
sl@0	1414	int err;
sl@0	1415	int len = (int)strlen(hello)+1;
sl@0	1416	gzFile file;
sl@0	1417
sl@0	1418	file = gzopen (MYFILE, "wb");
sl@0	1419	if ( file == NULL)
sl@0	1420	{
sl@0	1421	err = KErrGeneral;
sl@0	1422	free (compr);
sl@0	1423	free (uncompr);
sl@0	1424	return err;
sl@0	1425	}
sl@0	1426	gzputc (file, 'h');
sl@0	1427	if ( gzputs (file, "ello")!= 4)
sl@0	1428	{
sl@0	1429	err=KErrGeneral;
sl@0	1430	}
sl@0	1431	if ( gzprintf (file, ", %s!", "hello")!= 8)
sl@0	1432	{
sl@0	1433	err=KErrGeneral;
sl@0	1434	}
sl@0	1435	gzseek (file, 1L, SEEK_CUR); // add one zero byte
sl@0	1436	gzclose (file);
sl@0	1437
sl@0	1438	file = gzopen (MYFILE, "rb");
sl@0	1439	if ( file == NULL)
sl@0	1440	{
sl@0	1441	err = KErrGeneral;
sl@0	1442	free (compr);
sl@0	1443	free (uncompr);
sl@0	1444	return err;
sl@0	1445	}
sl@0	1446	strcpy ((char*)uncompr, "garbage");
sl@0	1447
sl@0	1448	if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
sl@0	1449	{
sl@0	1450	}
sl@0	1451	if ( strcmp ((char*)uncompr, hello))
sl@0	1452	{
sl@0	1453	err=KErrGeneral;
sl@0	1454	}
sl@0	1455	else
sl@0	1456	{
sl@0	1457	err=KErrNone;
sl@0	1458	}
sl@0	1459
sl@0	1460	gzseek (file, -8L, SEEK_CUR);
sl@0	1461	gzclearerr (file);
sl@0	1462	gzgets (file, (char*)uncompr, (int)uncomprLen);
sl@0	1463
sl@0	1464	if ( strlen ((char*)uncompr)!= 7)
sl@0	1465	{
sl@0	1466	//1 " hello!"
sl@0	1467	ERR_PRINTF1(_L("gzegets gets wrong string"));
sl@0	1468	err=KErrGeneral;
sl@0	1469	}
sl@0	1470	gzclose (file);
sl@0	1471
sl@0	1472	free (compr);
sl@0	1473	free (uncompr);
sl@0	1474	return err;
sl@0	1475	}
sl@0	1476
sl@0	1477	TInt CTestZlib::Test_gzerror_streamend()
sl@0	1478	{
sl@0	1479	#ifdef NO_GZCOMPRESS
sl@0	1480	ERR_PRINTF1(_L("NO_GZCOMPRESS -- gz* functions cannot compress"));
sl@0	1481	#else
sl@0	1482	const char *msgptr;
sl@0	1483	char fname[] = "C:\\bye.gz";
sl@0	1484
sl@0	1485	Byte compr, uncompr;
sl@0	1486	uLong comprLen, uncomprLen;
sl@0	1487	comprLen = uncomprLen = 30;
sl@0	1488
sl@0	1489	compr = (Byte*)calloc((uInt)comprLen, 1);
sl@0	1490	if ( compr == NULL)
sl@0	1491	{
sl@0	1492	INFO_PRINTF1(_L("Could not allocate memory for compr."));
sl@0	1493	return KErrNoMemory;
sl@0	1494	}
sl@0	1495
sl@0	1496	uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
sl@0	1497	if ( uncompr == NULL)
sl@0	1498	{
sl@0	1499	INFO_PRINTF1(_L("Could not allocate memory for uncompr."));
sl@0	1500	free (compr);
sl@0	1501	return KErrNoMemory;
sl@0	1502	}
sl@0	1503
sl@0	1504	int err;
sl@0	1505	const char hello[] = "hello, hello!";
sl@0	1506	int len = (int)strlen(hello)+1;
sl@0	1507	gzFile file;
sl@0	1508
sl@0	1509	file = gzopen (fname, "wb");
sl@0	1510	if ( file == NULL)
sl@0	1511	{
sl@0	1512	ERR_PRINTF1(_L("gzopen error"));
sl@0	1513	free (compr);
sl@0	1514	free (uncompr);
sl@0	1515	return KErrGeneral;
sl@0	1516	}
sl@0	1517	gzputc (file, 'h');
sl@0	1518	if ( gzputs (file, "ello")!= 4)
sl@0	1519	{
sl@0	1520	ERR_PRINTF1(_L("gzputs err"));
sl@0	1521	free (compr);
sl@0	1522	free (uncompr);
sl@0	1523	return KErrGeneral;
sl@0	1524	}
sl@0	1525	if ( gzprintf (file, ", %s!", "hello")!= 8)
sl@0	1526	{
sl@0	1527	ERR_PRINTF1(_L("gzprintf err="));
sl@0	1528	free (compr);
sl@0	1529	free (uncompr);
sl@0	1530	return KErrGeneral;
sl@0	1531	}
sl@0	1532
sl@0	1533	gzseek (file, 1L, SEEK_CUR); // add one zero byte
sl@0	1534	gzclose (file);
sl@0	1535
sl@0	1536	file = gzopen (fname, "rb");
sl@0	1537	if ( file == NULL)
sl@0	1538	{
sl@0	1539	ERR_PRINTF1(_L("gzopen error"));
sl@0	1540	free (compr);
sl@0	1541	free (uncompr);
sl@0	1542	return KErrGeneral;
sl@0	1543	}
sl@0	1544	strcpy ((char*)uncompr, "garbage");
sl@0	1545
sl@0	1546	if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
sl@0	1547	{
sl@0	1548	ERR_PRINTF1(_L("gzread err"));
sl@0	1549	free (compr);
sl@0	1550	free (uncompr);
sl@0	1551	return KErrGeneral;
sl@0	1552	}
sl@0	1553
sl@0	1554	if ( strcmp ((char*)uncompr, hello))
sl@0	1555	{
sl@0	1556	ERR_PRINTF1(_L("bad gzread"));
sl@0	1557	free (compr);
sl@0	1558	free (uncompr);
sl@0	1559	return KErrGeneral;
sl@0	1560	}
sl@0	1561
sl@0	1562	INFO_PRINTF2(_L("Reached file position %ld"),gzseek(file, -8L, SEEK_CUR));
sl@0	1563
sl@0	1564	gzgets (file, (char*)uncompr, (int)uncomprLen);
sl@0	1565	msgptr = gzerror (file, &err);
sl@0	1566	if ( strcmp (msgptr, "C:\\bye.gz: stream end")!= 0)
sl@0	1567	{
sl@0	1568	// " hello!"
sl@0	1569	ERR_PRINTF1(_L("gzerror err on streamend"));
sl@0	1570	free (compr);
sl@0	1571	free (uncompr);
sl@0	1572	return KErrGeneral;
sl@0	1573	}
sl@0	1574
sl@0	1575	gzclose (file);
sl@0	1576	free (compr);
sl@0	1577	free (uncompr);
sl@0	1578
sl@0	1579	if ( err != Z_STREAM_END)
sl@0	1580	{
sl@0	1581	return KErrGeneral;
sl@0	1582	}
sl@0	1583	return KErrNone;
sl@0	1584	#endif
sl@0	1585	}
sl@0	1586
sl@0	1587	TInt CTestZlib::Test_gzungetcnegative()
sl@0	1588	{
sl@0	1589	gzFile file=NULL;
sl@0	1590	int ret = gzungetc (' ', file); //NULL stream
sl@0	1591	if ( ret != EOF)
sl@0	1592	{
sl@0	1593	ERR_PRINTF2(_L("gzungetc NULL stream test: Expected EOF but returned %d"),ret);
sl@0	1594	return KErrGeneral;
sl@0	1595	}
sl@0	1596
sl@0	1597	const char hello[] = "hello, hello!";
sl@0	1598	int len = (int)strlen(hello)+1;
sl@0	1599
sl@0	1600	file = gzopen ("C:\\bye.gz", "wb");
sl@0	1601	if ( file == NULL)
sl@0	1602	{
sl@0	1603	ERR_PRINTF1(_L("gzopen error"));
sl@0	1604	return KErrGeneral;
sl@0	1605	}
sl@0	1606	gzputc (file, 'h');
sl@0	1607	if ( gzputs (file, "ello")!= 4)
sl@0	1608	{
sl@0	1609	ERR_PRINTF1(_L("gzputs err"));
sl@0	1610	gzclose (file);
sl@0	1611	return KErrGeneral;
sl@0	1612	}
sl@0	1613
sl@0	1614	ret = gzungetc (' ', file); //non-read mode
sl@0	1615	if ( ret != EOF)
sl@0	1616	{
sl@0	1617	ERR_PRINTF2(_L("gzungetc non-read mode test: Expected EOF but returned %d"),ret);
sl@0	1618	gzclose (file);
sl@0	1619	return KErrGeneral;
sl@0	1620	}
sl@0	1621
sl@0	1622	gzseek (file, 1L, SEEK_CUR); // add one zero byte
sl@0	1623	gzclose (file);
sl@0	1624
sl@0	1625	file = gzopen ("C:\\bye.gz", "rb");
sl@0	1626	if ( file == NULL)
sl@0	1627	{
sl@0	1628	ERR_PRINTF1(_L("gzopen error"));
sl@0	1629	return KErrGeneral;
sl@0	1630	}
sl@0	1631
sl@0	1632	if ( gzungetc (EOF, file)!= EOF) //ungetc EOF
sl@0	1633	{
sl@0	1634	gzclose (file);
sl@0	1635	ERR_PRINTF1(_L("gzungetc error"));
sl@0	1636	return KErrGeneral;
sl@0	1637	}
sl@0	1638	gzclose (file);
sl@0	1639
sl@0	1640	return KErrNone;
sl@0	1641	}
sl@0	1642
sl@0	1643	TInt CTestZlib::Test_gzseeknegative()
sl@0	1644	{
sl@0	1645
sl@0	1646	int err=0;
sl@0	1647
sl@0	1648	int len = (int)strlen(hello)+1;
sl@0	1649	gzFile file;
sl@0	1650
sl@0	1651	file = gzopen (TESTFILE, "wb");
sl@0	1652	if ( file == NULL)
sl@0	1653	{
sl@0	1654	return KErrNoMemory;
sl@0	1655	}
sl@0	1656	gzputc (file, 'h');
sl@0	1657
sl@0	1658	err= gzseek (file, 1L, SEEK_END); /* add one zero byte */
sl@0	1659	if ( err != -1)
sl@0	1660	{
sl@0	1661	gzclose (file);
sl@0	1662	return KErrGeneral;
sl@0	1663	}
sl@0	1664
sl@0	1665	err= gzclose (file);
sl@0	1666	file = gzopen (TESTFILE, "rb");
sl@0	1667	if ( gzgetc (file)!= 'h')
sl@0	1668	{
sl@0	1669	gzclose (file);
sl@0	1670	ERR_PRINTF1(_L("gzgetc error"));
sl@0	1671	return KErrGeneral;
sl@0	1672	}
sl@0	1673	if ( gzgetc (file)!= EOF)
sl@0	1674	{
sl@0	1675	gzclose (file);
sl@0	1676	ERR_PRINTF1(_L("gzgetc error"));
sl@0	1677	return KErrGeneral;
sl@0	1678	}
sl@0	1679	err= gzseek (file, 1L, SEEK_CUR);
sl@0	1680	if ( gzgetc (file)!= -1L)
sl@0	1681	{
sl@0	1682	gzclose (file);
sl@0	1683	ERR_PRINTF1(_L("gzseek error"));
sl@0	1684	return KErrGeneral;
sl@0	1685	}
sl@0	1686	gzclose (file);
sl@0	1687	return KErrNone;
sl@0	1688	}
sl@0	1689
sl@0	1690	/*TInt CTestZlib::TestGzopenRw()
sl@0	1691	{
sl@0	1692	TInt res = KErrNone ;
sl@0	1693	gzFile file;
sl@0	1694	char c;
sl@0	1695	const char *fname = "c:\\Bytes.gz";
sl@0	1696	file = gzopen(fname, "wr");
sl@0	1697	if (file == NULL)
sl@0	1698	{
sl@0	1699	res = KErrGeneral;
sl@0	1700	return res;
sl@0	1701	}
sl@0	1702	else
sl@0	1703	{
sl@0	1704	res=gzputc(file, 'r');
sl@0	1705	if(res<0)
sl@0	1706	{
sl@0	1707	res = KErrGeneral;
sl@0	1708	}
sl@0	1709	else
sl@0	1710	{
sl@0	1711	res = KErrNone;
sl@0	1712	//gzclearerr(file);
sl@0	1713	gzseek(file,0, SEEK_SET);
sl@0	1714	c = gzgetc(file);
sl@0	1715	if(c == 'r')
sl@0	1716	{
sl@0	1717	res = KErrNone;
sl@0	1718	}
sl@0	1719	else
sl@0	1720	{
sl@0	1721	ERR_PRINTF1(_L("gzgetc error in rw mode. Expected r"));
sl@0	1722	res=KErrGeneral;
sl@0	1723	}
sl@0	1724	}
sl@0	1725	}
sl@0	1726	gzclose(file);
sl@0	1727	return res;
sl@0	1728	}
sl@0	1729	*/
sl@0	1730	/**
sl@0	1731	* Function Name : Test_gzdirecttxt
sl@0	1732	* TestCase Description: 1. Checks whether a normal txt file gives a compressed stream or not
sl@0	1733	*/
sl@0	1734	TInt CTestZlib::Test_gzdirecttxt()
sl@0	1735	{
sl@0	1736	gzFile file;
sl@0	1737	int ret=KErrGeneral;
sl@0	1738	char fname[] = "C:\\gzdirecttest.txt";
sl@0	1739	FILE *fp=NULL;
sl@0	1740	fp=fopen (fname, "w");
sl@0	1741	fputc ('\n', fp);
sl@0	1742	fclose (fp);
sl@0	1743	file = gzopen (fname, "rb");
sl@0	1744	ret = gzdirect (file);
sl@0	1745	if ( ret)
sl@0	1746	{
sl@0	1747	INFO_PRINTF1(_L("Reading a Non GzFile"));
sl@0	1748	ret=KErrNone;
sl@0	1749	}
sl@0	1750	else
sl@0	1751	{
sl@0	1752	ERR_PRINTF1(_L("Error in gzdirect. Expeceted 1, returned 0"));
sl@0	1753	ret=KErrGeneral;
sl@0	1754	}
sl@0	1755	gzclose (file);
sl@0	1756	return ret;
sl@0	1757	}
sl@0	1758
sl@0	1759	/**
sl@0	1760	* Function Name : TestGzungetcChain
sl@0	1761	* TestCase Description: 1. Checks whether gzungetc ungets the read chars using getc
sl@0	1762	*/
sl@0	1763	TInt CTestZlib::TestGzungetcChain()
sl@0	1764	{
sl@0	1765	gzFile file;
sl@0	1766	char tmp;
sl@0	1767	char fname[] = "C:\\Hello.gz";
sl@0	1768	file = gzopen (fname, "wb");
sl@0	1769	gzputc (file, 'h');
sl@0	1770	if ( gzputs (file, "ello World")!= 10)
sl@0	1771	{
sl@0	1772	gzclose (file);
sl@0	1773	printf ("Error: gzputs\n");
sl@0	1774	}
sl@0	1775	gzclose (file);
sl@0	1776	file = gzopen (fname, "rb");
sl@0	1777	while (' ' != ( tmp = gzgetc(file) ))
sl@0	1778	{
sl@0	1779	gzungetc (tmp, file);
sl@0	1780	gzseek (file, 1L, SEEK_CUR);
sl@0	1781	}
sl@0	1782	gzclose (file);
sl@0	1783	return KErrNone;
sl@0	1784	}
sl@0	1785
sl@0	1786	/**
sl@0	1787	* Function Name : TestGzseekBack
sl@0	1788	* TestCase Description: 1. Checks whether gzseek returns -1
sl@0	1789	* for backward seeks in files opened in write mode.
sl@0	1790	*/
sl@0	1791	TInt CTestZlib::TestGzseekBack()
sl@0	1792	{
sl@0	1793	int err;
sl@0	1794	int len = (int)strlen(hello)+1;
sl@0	1795	gzFile file;
sl@0	1796
sl@0	1797	const char * fname= TESTFILE;
sl@0	1798
sl@0	1799	file = gzopen (fname, "wb");
sl@0	1800	if ( file == NULL)
sl@0	1801	{
sl@0	1802	err = KErrGeneral;
sl@0	1803	return err;
sl@0	1804	}
sl@0	1805	gzputc (file, 'h');
sl@0	1806	if ( gzputs (file, "ello")!= 4)
sl@0	1807	{
sl@0	1808	err=1;
sl@0	1809	}
sl@0	1810	if ( gzprintf (file, ", %s!", "hello")!= 8)
sl@0	1811	{
sl@0	1812	err=1;
sl@0	1813	}
sl@0	1814	err = (int) gzseek(file,0, SEEK_SET); /* to beg */
sl@0	1815	gzclose (file);
sl@0	1816	if ( err == -1)
sl@0	1817	{
sl@0	1818	return KErrNone;
sl@0	1819	}
sl@0	1820	else
sl@0	1821	{
sl@0	1822	ERR_PRINTF2(_L("Expected -1, returned %d"),err);
sl@0	1823	return KErrGeneral;
sl@0	1824	}
sl@0	1825	}
sl@0	1826
sl@0	1827	/**
sl@0	1828	* Function Name : TestGzseekAppend
sl@0	1829	* TestCase Description:
sl@0	1830	* 1. Writes a text file, closes.
sl@0	1831	* 2. Open using gzopen in append mode
sl@0	1832	* 3. Writes another character.
sl@0	1833	* 4. Seek one down from current position
sl@0	1834	* 5. Checks whether gzseek returns 2
sl@0	1835	*/
sl@0	1836	TInt CTestZlib::TestGzseekAppend()
sl@0	1837	{
sl@0	1838	const char hello[] = "hello, hello!";
sl@0	1839	int len = (int)strlen(hello)+1;
sl@0	1840	int err;
sl@0	1841	gzFile file;
sl@0	1842
sl@0	1843	FILE *fp = fopen ("c:\\file.txt", "wb");
sl@0	1844	fputc ('h', fp);
sl@0	1845	fclose (fp);
sl@0	1846	file = gzopen ("c:\\file.txt", "a");
sl@0	1847	if ( file == NULL)
sl@0	1848	{
sl@0	1849	ERR_PRINTF1(_L("gzopen error"));
sl@0	1850	return KErrGeneral;
sl@0	1851	}
sl@0	1852	gzputc (file, 'h');
sl@0	1853	err = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
sl@0	1854	gzclose (file);
sl@0	1855	if ( err == 2)
sl@0	1856	return KErrNone;
sl@0	1857	else
sl@0	1858	{
sl@0	1859	ERR_PRINTF2(_L("Expected 2, returned %d"),err);
sl@0	1860	return KErrGeneral;
sl@0	1861	}
sl@0	1862	}
sl@0	1863
sl@0	1864	/**
sl@0	1865	* Function Name : TestGzseekHugeOffset
sl@0	1866	* TestCase Description:
sl@0	1867	* 1. Writes a text file, closes.
sl@0	1868	* 2. Open using gzopen in append mode
sl@0	1869	* 3. Writes another character.
sl@0	1870	* 4. Seek 4097 up from current position
sl@0	1871	* 5. Checks whether gzseek returns 16386 or not.
sl@0	1872	*/
sl@0	1873	TInt CTestZlib::TestGzseekHugeOffset()
sl@0	1874	{
sl@0	1875	const char hello[] = "hello, hello!";
sl@0	1876	int len = (int)strlen(hello)+1;
sl@0	1877	int err;
sl@0	1878	gzFile file;
sl@0	1879
sl@0	1880	FILE *fp = fopen ("c:\\file.txt", "wb");
sl@0	1881	fputc ('h', fp);
sl@0	1882	fclose (fp);
sl@0	1883	file = gzopen ("c:\\file.txt", "a");
sl@0	1884	if ( file == NULL)
sl@0	1885	{
sl@0	1886	ERR_PRINTF1(_L("gzopen error"));
sl@0	1887	return KErrGeneral;
sl@0	1888	}
sl@0	1889	gzputc (file, 'h');
sl@0	1890	err = (int) gzseek(file,16385L, SEEK_CUR); /* advance pos by 16385*/
sl@0	1891	gzclose (file);
sl@0	1892	if ( err == 16386)
sl@0	1893	return KErrNone;
sl@0	1894	else
sl@0	1895	{
sl@0	1896	ERR_PRINTF2(_L("Expected 2, returned %d"),err);
sl@0	1897	return KErrGeneral;
sl@0	1898	}
sl@0	1899	}
sl@0	1900
sl@0	1901	/**
sl@0	1902	* Function Name : TestGzseekNoSize
sl@0	1903	* TestCase Description:
sl@0	1904	* 1. Seeks a zero sized file
sl@0	1905	* 2. Checks whether it returns -1 or not
sl@0	1906	*/
sl@0	1907	TInt CTestZlib::TestGzseekNoSize()
sl@0	1908	{
sl@0	1909	TInt res = KErrNone;
sl@0	1910	gzFile file;
sl@0	1911	uInt size, len;
sl@0	1912	const char *s="\0";
sl@0	1913	len=strlen (s);
sl@0	1914	const char * fname= TESTFILE;
sl@0	1915	file = gzopen (fname, "wb");
sl@0	1916	if ( file == Z_NULL)
sl@0	1917	{
sl@0	1918	ERR_PRINTF1(_L("gzopen error"));
sl@0	1919	return KErrGeneral;
sl@0	1920	}
sl@0	1921	size = gzwrite (file, (char*)s, (unsigned)strlen(s));
sl@0	1922	if ( len!=size)
sl@0	1923	{
sl@0	1924	ERR_PRINTF1(_L("gzwrite error"));
sl@0	1925	return KErrGeneral;
sl@0	1926	}
sl@0	1927
sl@0	1928	res = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
sl@0	1929	gzclose (file);
sl@0	1930	if ( res == 1)
sl@0	1931	{
sl@0	1932	return KErrNone;
sl@0	1933	}
sl@0	1934	else
sl@0	1935	{
sl@0	1936	ERR_PRINTF2(_L("Expected -1, returned %d"), res);
sl@0	1937	return KErrGeneral;
sl@0	1938	}
sl@0	1939	}
sl@0	1940
sl@0	1941	/**
sl@0	1942	* Function Name : TestGzopenLongPath
sl@0	1943	* TestCase Description:
sl@0	1944	* 1. Seeks a file with long name
sl@0	1945	* 2. Checks whether gzopen returns NULL or not
sl@0	1946	*/
sl@0	1947	TInt CTestZlib::TestGzopenLongPath01()
sl@0	1948	{
sl@0	1949	gzFile file;
sl@0	1950	const char
sl@0	1951	* fname = "c:\\fffff\
sl@0	1952	fffffffffffffffffffffffffffffff\
sl@0	1953	fffffffffffffffffffffffffffffff\
sl@0	1954	fffffffffffffffffffffffffffffff\
sl@0	1955	fffffffffffffffffffffffffffffff\
sl@0	1956	fffffffffffffffffffffffffffffff\
sl@0	1957	fffffffffffffffffffffffffffffff\
sl@0	1958	fffffffffffffffffffffffffffffff\
sl@0	1959	fffffffffffffffffffffffffffffff\
sl@0	1960	fffffffffffffffffffffffffffffff\
sl@0	1961	fffffffffffffffffffffffffffffff\
sl@0	1962	fffffffffffffffffffffffffffffff.txt";
sl@0	1963	file = gzopen (fname, "wb");
sl@0	1964	if ( file == Z_NULL)
sl@0	1965	{
sl@0	1966	INFO_PRINTF1(_L("Returned NULL"));
sl@0	1967	return KErrNone;
sl@0	1968	}
sl@0	1969	else
sl@0	1970	{
sl@0	1971	ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
sl@0	1972	return KErrGeneral;
sl@0	1973	}
sl@0	1974	}
sl@0	1975
sl@0	1976	/**
sl@0	1977	* Function Name : TestGzseekLongPath
sl@0	1978	* TestCase Description:
sl@0	1979	* 1. Seeks a acceptable long file name
sl@0	1980	* 2. Checks whether it returns 1 or not
sl@0	1981	*/
sl@0	1982	TInt CTestZlib::TestGzseekLongPath01()
sl@0	1983	{
sl@0	1984	TInt res = KErrNone;
sl@0	1985	gzFile file;
sl@0	1986	uInt size, len;
sl@0	1987	const char *s="\0";
sl@0	1988	len=strlen (s);
sl@0	1989	const char
sl@0	1990	* fname = "c:\\fffff\
sl@0	1991	fffffffffffffffffffffffffffffff\
sl@0	1992	fffffffffffffffffffffffffffffff\
sl@0	1993	fffffffffffffffffffffffffffffff\
sl@0	1994	fffffffffffffffffffffffffffffff\
sl@0	1995	fffffffffffffffffffffffffffffff\
sl@0	1996	fffffffffffffffffffffffffffffff.txt";
sl@0	1997	file = gzopen (fname, "wb");
sl@0	1998	if ( file == Z_NULL)
sl@0	1999	{
sl@0	2000	ERR_PRINTF1(_L("gzopen error"));
sl@0	2001	return KErrGeneral;
sl@0	2002	}
sl@0	2003	size = gzwrite (file, (char*)s, (unsigned)strlen(s));
sl@0	2004	if ( len!=size)
sl@0	2005	{
sl@0	2006	ERR_PRINTF1(_L("gzwrite error"));
sl@0	2007	return KErrGeneral;
sl@0	2008	}
sl@0	2009
sl@0	2010	res = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
sl@0	2011	gzclose (file);
sl@0	2012	if ( res == 1)
sl@0	2013	{
sl@0	2014	return KErrNone;
sl@0	2015	}
sl@0	2016	else
sl@0	2017	{
sl@0	2018	ERR_PRINTF2(_L("Expected -1, returned %d"), res);
sl@0	2019	return KErrGeneral;
sl@0	2020	}
sl@0	2021	}
sl@0	2022
sl@0	2023	/**
sl@0	2024	* Function Name : TestGzopenLongPath
sl@0	2025	* TestCase Description:
sl@0	2026	* 1. Seeks a long pathed file
sl@0	2027	* 2. Checks whether it returns NULL or not
sl@0	2028	*/
sl@0	2029	TInt CTestZlib::TestGzopenLongPath02()
sl@0	2030	{
sl@0	2031	gzFile file;
sl@0	2032	int ret = KErrNone;
sl@0	2033	const char
sl@0	2034	* fname = "C:\\fffff\
sl@0	2035	fffffffffffffffffffffffffffffff\
sl@0	2036	fffffffffffffffffffffffffffffff\
sl@0	2037	fffffffffffffffffffffffffffffff\
sl@0	2038	fffffffffffffffffffffffffffffff\
sl@0	2039	fffffffffffffffffffffffffffffff\
sl@0	2040	fffffffffffffffffffffffffffffff";
sl@0	2041
sl@0	2042	file = gzopen (fname, "wb");
sl@0	2043	if ( file == Z_NULL)
sl@0	2044	{
sl@0	2045	ERR_PRINTF1(_L("gzopen error- File NULL"));
sl@0	2046	return KErrGeneral;
sl@0	2047	}
sl@0	2048	else
sl@0	2049	{
sl@0	2050	INFO_PRINTF1(_L("Expected file pointer, returned Success"));
sl@0	2051	}
sl@0	2052	gzclose (file);
sl@0	2053	return ret;
sl@0	2054	}
sl@0	2055
sl@0	2056	/**
sl@0	2057	* Function Name : TestGzseekMixedFile01
sl@0	2058	* TestCase Description:
sl@0	2059	* 1. Open using gzopen in write mode
sl@0	2060	* 2. gzputs a string.
sl@0	2061	* 3. fopen it, writes a text, close.
sl@0	2062	* 4. Seek one down from current position
sl@0	2063	* 5. Checks whether gzseek returns 1 for offset 1L,
sl@0	2064	* 1000L for offset 1000L, -1 for -1L, -1 for -1000L
sl@0	2065	*/
sl@0	2066	TInt CTestZlib::TestGzseekMixedFile01()
sl@0	2067	{
sl@0	2068	const char hello[] = "hello, hello!";
sl@0	2069	int len = (int)strlen(hello)+1;
sl@0	2070	int err;
sl@0	2071	gzFile file;
sl@0	2072
sl@0	2073	TInt offset, expRes;
sl@0	2074
sl@0	2075	ReadIntParam (offset);
sl@0	2076	ReadIntParam (expRes);
sl@0	2077
sl@0	2078	file = gzopen ("c:\\file.txt", "wb");
sl@0	2079	gzputs (file, hello);
sl@0	2080	gzclose (file);
sl@0	2081	FILE *fp = fopen ("c:\\file.txt", "w+");
sl@0	2082	fputc ('h', fp);
sl@0	2083	fclose (fp);
sl@0	2084	file = gzopen ("c:\\file.txt", "rb");
sl@0	2085	if ( file == NULL)
sl@0	2086	{
sl@0	2087	ERR_PRINTF1(_L("gzopen error"));
sl@0	2088	return KErrGeneral;
sl@0	2089	}
sl@0	2090	err = (int) gzseek(file,offset, SEEK_CUR); /* to next pos */
sl@0	2091	gzclose (file);
sl@0	2092	if ( err == expRes)
sl@0	2093	return KErrNone;
sl@0	2094	else
sl@0	2095	{
sl@0	2096	ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
sl@0	2097	return KErrGeneral;
sl@0	2098	}
sl@0	2099	}
sl@0	2100
sl@0	2101	/**
sl@0	2102	* Function Name : TestGzopenNoMode
sl@0	2103	* TestCase Description:
sl@0	2104	* 1. gzopen a file with NULL mode
sl@0	2105	* 2. Checks whether gzopen returns NULL or not
sl@0	2106	*/
sl@0	2107	TInt CTestZlib::TestGzopenNoMode()
sl@0	2108	{
sl@0	2109	gzFile file;
sl@0	2110	const char * fname = "c:\\file.txt";
sl@0	2111	file = gzopen (fname, NULL);
sl@0	2112	if ( file == Z_NULL)
sl@0	2113	{
sl@0	2114	INFO_PRINTF1(_L("Returned NULL"));
sl@0	2115	return KErrNone;
sl@0	2116	}
sl@0	2117	else
sl@0	2118	{
sl@0	2119	ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
sl@0	2120	return KErrGeneral;
sl@0	2121	}
sl@0	2122	}
sl@0	2123
sl@0	2124	/**
sl@0	2125	* Function Name : TestGzopenNoPath
sl@0	2126	* TestCase Description:
sl@0	2127	* 1. gzopen a file with NULL path
sl@0	2128	* 2. Checks whether gzopen returns NULL or not
sl@0	2129	*/
sl@0	2130	TInt CTestZlib::TestGzopenNoPath()
sl@0	2131	{
sl@0	2132	gzFile file;
sl@0	2133	file = gzopen (NULL, "wb");
sl@0	2134	if ( file == Z_NULL)
sl@0	2135	{
sl@0	2136	INFO_PRINTF1(_L("Returned NULL"));
sl@0	2137	return KErrNone;
sl@0	2138	}
sl@0	2139	else
sl@0	2140	{
sl@0	2141	ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
sl@0	2142	return KErrGeneral;
sl@0	2143	}
sl@0	2144	}
sl@0	2145
sl@0	2146	/**
sl@0	2147	* Function Name : TestGzopenNoPath
sl@0	2148	* TestCase Description:
sl@0	2149	* 1. gzopen a file with path,mode empty string,
sl@0	2150	* 2. Checks whether gzopen returns NULL or not
sl@0	2151	*/
sl@0	2152	TInt CTestZlib::TestGzopenNoPathMode()
sl@0	2153	{
sl@0	2154	gzFile file;
sl@0	2155	file = gzopen ("", "");
sl@0	2156	if ( file == Z_NULL)
sl@0	2157	{
sl@0	2158	INFO_PRINTF1(_L("Returned NULL"));
sl@0	2159	return KErrNone;
sl@0	2160	}
sl@0	2161	else
sl@0	2162	{
sl@0	2163	ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
sl@0	2164	return KErrGeneral;
sl@0	2165	}
sl@0	2166	}
sl@0	2167	/**
sl@0	2168	* Function Name : TestGzseekConcatedFile01
sl@0	2169	* TestCase Description:
sl@0	2170	* 1. Open a manually concatinated gz file using gzopen in read mode
sl@0	2171	* 2. Seek one down from current position
sl@0	2172	* 3. Checks whether gzseek returns 1 for offset 1L,
sl@0	2173	* -1 for offset 1000L, -1 for -1L, -1 for -1000L
sl@0	2174	*/
sl@0	2175	TInt CTestZlib::TestGzseekConcatedFile01()
sl@0	2176	{
sl@0	2177	int err;
sl@0	2178	gzFile file;
sl@0	2179
sl@0	2180	TInt offset, expRes;
sl@0	2181	ReadIntParam (offset);
sl@0	2182	ReadIntParam (expRes);
sl@0	2183
sl@0	2184	file = gzopen (FILETESTGZCONCAT, "rb");
sl@0	2185	if ( file == NULL)
sl@0	2186	{
sl@0	2187	ERR_PRINTF1(_L("gzopen error"));
sl@0	2188	return KErrGeneral;
sl@0	2189	}
sl@0	2190	err = (int) gzseek(file,offset, SEEK_CUR); // to next pos
sl@0	2191	gzclose (file);
sl@0	2192	if ( err == expRes)
sl@0	2193	{
sl@0	2194	return KErrNone;
sl@0	2195	}
sl@0	2196	else
sl@0	2197	{
sl@0	2198	ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
sl@0	2199	return KErrGeneral;
sl@0	2200	}
sl@0	2201	}
sl@0	2202
sl@0	2203	/**
sl@0	2204	* Function Name : TestGzopenNoPath
sl@0	2205	* TestCase Description:
sl@0	2206	* 1. gzopen a file with valid path, mode: 9, f, h, R, 9, fb, hb, Rb,
sl@0	2207	* and wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
sl@0	2208	* 2. Checks whether gzopen returns NULL all cases, except the last one.
sl@0	2209	*/
sl@0	2210	TInt CTestZlib::TestGzopenDiffMode()
sl@0	2211	{
sl@0	2212	TInt res = KErrNone;
sl@0	2213	gzFile file=Z_NULL;
sl@0	2214	const char * fname= TESTFILE;
sl@0	2215	char mode[100];
sl@0	2216	TInt expRes;
sl@0	2217	ReadStringParam (mode);
sl@0	2218	ReadIntParam (expRes);
sl@0	2219	file = gzopen (fname, "wb");
sl@0	2220	res = gzputc (file, 'h');
sl@0	2221	res = gzclose (file);
sl@0	2222	file = gzopen (fname, mode);
sl@0	2223	if ( (file == Z_NULL && expRes == 0) \|\| (file != Z_NULL && expRes == 1))
sl@0	2224	{
sl@0	2225	res = KErrNone;
sl@0	2226	}
sl@0	2227	else
sl@0	2228	{
sl@0	2229	res = KErrGeneral;
sl@0	2230	ERR_PRINTF1(_L("Expected NULL, returned nonNULL"));
sl@0	2231	}
sl@0	2232	if ( file)
sl@0	2233	{
sl@0	2234	gzclose (file);
sl@0	2235	}
sl@0	2236	return res;
sl@0	2237	}
sl@0	2238
sl@0	2239	/**
sl@0	2240	* Function Name : TestGzseekConcatedFile02
sl@0	2241	* TestCase Description:
sl@0	2242	* 1. Open a programmatically concatinated gz file using gzopen
sl@0	2243	* in read mode
sl@0	2244	* 2. Seek one down from current position
sl@0	2245	* 3. Checks whether gzseek returns 1 for offset 1L,
sl@0	2246	* -1 for offset 1000L, -1 for -1L, -1 for -1000L
sl@0	2247	*/
sl@0	2248	TInt CTestZlib::TestGzseekConcatedFile02()
sl@0	2249	{
sl@0	2250	int err;
sl@0	2251	gzFile file;
sl@0	2252
sl@0	2253	TInt offset, expRes;
sl@0	2254
sl@0	2255	ReadIntParam (offset);
sl@0	2256	ReadIntParam (expRes);
sl@0	2257	char fname1[13]="c:\\first.gz";
sl@0	2258	char fname2[14]="c:\\second.gz";
sl@0	2259
sl@0	2260	//create 2 gz files
sl@0	2261	file = gzopen (fname1, "w");
sl@0	2262	if ( file == NULL)
sl@0	2263	{
sl@0	2264	ERR_PRINTF1(_L("gzopen error"));
sl@0	2265	return KErrGeneral;
sl@0	2266	}
sl@0	2267	gzputc (file, 'h');
sl@0	2268	gzclose (file);
sl@0	2269	file = gzopen (fname2, "w");
sl@0	2270	if ( file == NULL)
sl@0	2271	{
sl@0	2272	unlink (fname1);
sl@0	2273	ERR_PRINTF1(_L("gzopen error"));
sl@0	2274	return KErrGeneral;
sl@0	2275	}
sl@0	2276	gzputc (file, 'e');
sl@0	2277	gzclose (file);
sl@0	2278
sl@0	2279	//concatenate the two
sl@0	2280	FILE fpFirst=NULL, fpSecond=NULL;
sl@0	2281	fpFirst = fopen (fname1, "a");
sl@0	2282	fpSecond = fopen (fname2, "r");
sl@0	2283	char c;
sl@0	2284	for (; !feof(fpSecond);)
sl@0	2285	{
sl@0	2286	c=fgetc (fpSecond);
sl@0	2287	fputc (c, fpFirst);
sl@0	2288	}
sl@0	2289	fclose (fpFirst);
sl@0	2290	fclose (fpSecond);
sl@0	2291
sl@0	2292	//Now seek
sl@0	2293	file = gzopen (fname1, "r");
sl@0	2294	err = (int) gzseek(file,offset, SEEK_CUR); // to next pos
sl@0	2295	gzclose (file);
sl@0	2296	if ( err == expRes)
sl@0	2297	{
sl@0	2298	unlink (fname1);
sl@0	2299	unlink (fname2);
sl@0	2300	return KErrNone;
sl@0	2301	}
sl@0	2302	else
sl@0	2303	{
sl@0	2304	unlink (fname1);
sl@0	2305	unlink (fname2);
sl@0	2306	ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
sl@0	2307	return KErrGeneral;
sl@0	2308	}
sl@0	2309	}
sl@0	2310
sl@0	2311	/**
sl@0	2312	* Function Name : TestGzprintf01
sl@0	2313	* TestCase Description:
sl@0	2314	* 1. Prints an empty string
sl@0	2315	* 2. Checks whether returns 0
sl@0	2316	*/
sl@0	2317	TInt CTestZlib::TestGzprintf01()
sl@0	2318	{
sl@0	2319	TInt res = KErrGeneral;
sl@0	2320	gzFile file;
sl@0	2321	const char * fname= TESTFILE;
sl@0	2322	file = gzopen (fname, "wb");
sl@0	2323	if ( file == NULL)
sl@0	2324	{
sl@0	2325	res = KErrNoMemory;
sl@0	2326	return res;
sl@0	2327	}
sl@0	2328	res = gzprintf (file, "");
sl@0	2329	if ( res != 0)
sl@0	2330	{
sl@0	2331	ERR_PRINTF1(_L("gzprintf err"));
sl@0	2332	}
sl@0	2333	else
sl@0	2334	{
sl@0	2335	res = KErrNone;
sl@0	2336	}
sl@0	2337	gzclose (file);
sl@0	2338	return res;
sl@0	2339	}
sl@0	2340	/**
sl@0	2341	* Function Name : TestGzprintf02
sl@0	2342	* TestCase Description:
sl@0	2343	* 1. Prints an large string of length 4097, 4096
sl@0	2344	* 2. Checks whether returns 0, 4095
sl@0	2345	*/
sl@0	2346	TInt CTestZlib::TestGzprintf02()
sl@0	2347	{
sl@0	2348	TInt res = KErrGeneral;
sl@0	2349	gzFile file;
sl@0	2350	const char * fname= TESTFILE;
sl@0	2351
sl@0	2352	char largeStr[4098];
sl@0	2353	TInt strLength, expRes;
sl@0	2354	ReadIntParam (strLength);
sl@0	2355	ReadIntParam (expRes);
sl@0	2356
sl@0	2357	//create alarge string
sl@0	2358	for (int i=0; i<strLength;i++)
sl@0	2359	{
sl@0	2360	largeStr[i]='a';
sl@0	2361	}
sl@0	2362	largeStr[strLength]='\0';
sl@0	2363	file = gzopen (fname, "wb");
sl@0	2364	if ( file == NULL)
sl@0	2365	{
sl@0	2366	res = KErrNoMemory;
sl@0	2367	return res;
sl@0	2368	}
sl@0	2369	res = gzprintf (file, largeStr);
sl@0	2370	if ( res != expRes)
sl@0	2371	{
sl@0	2372	ERR_PRINTF1(_L("gzprintf err"));
sl@0	2373	}
sl@0	2374	else
sl@0	2375	{
sl@0	2376	res = KErrNone;
sl@0	2377	}
sl@0	2378	gzclose (file);
sl@0	2379	unlink (TESTFILE);
sl@0	2380	return res;
sl@0	2381	}
sl@0	2382
sl@0	2383	/**
sl@0	2384	* Function Name : TestGzflushNull
sl@0	2385	* TestCase Description:
sl@0	2386	* 1. Flushes a NULL stream
sl@0	2387	* 2. Checks whether returns Z_STREAM_ERROR(-2)
sl@0	2388	*/
sl@0	2389	TInt CTestZlib::TestGzflushNull()
sl@0	2390	{
sl@0	2391	TInt res = KErrNone;
sl@0	2392	gzFile file= NULL;
sl@0	2393	int l= gzflush (file, Z_FULL_FLUSH);
sl@0	2394	if ( l != Z_STREAM_ERROR)
sl@0	2395	{
sl@0	2396	res = KErrGeneral;
sl@0	2397	}
sl@0	2398	return res;
sl@0	2399	}
sl@0	2400
sl@0	2401	/**
sl@0	2402	* Function Name : TestGzflushRepeat
sl@0	2403	* TestCase Description:
sl@0	2404	* 1. Flushes a valid stream twice
sl@0	2405	* 2. Checks whether returns 0
sl@0	2406	*/
sl@0	2407	TInt CTestZlib::TestGzflushRepeat()
sl@0	2408	{
sl@0	2409	TInt res = KErrNone;
sl@0	2410	gzFile file;
sl@0	2411
sl@0	2412	const char * fname= TESTFILE;
sl@0	2413	file = gzopen (fname, "wb");
sl@0	2414	if ( file == Z_NULL)
sl@0	2415	{
sl@0	2416	res = KErrNoMemory;
sl@0	2417	return res;
sl@0	2418	}
sl@0	2419	int l= gzflush (file, Z_FULL_FLUSH);
sl@0	2420	if ( l != Z_OK)
sl@0	2421	{
sl@0	2422	res = KErrGeneral;
sl@0	2423	}
sl@0	2424	l= gzflush (file, Z_SYNC_FLUSH);
sl@0	2425	if ( l != Z_OK)
sl@0	2426	{
sl@0	2427	res = KErrGeneral;
sl@0	2428	}
sl@0	2429	int err= gzclose (file);
sl@0	2430	if ( err != Z_OK)
sl@0	2431	{
sl@0	2432	res = KErrGeneral;
sl@0	2433	}
sl@0	2434	return res;
sl@0	2435	}
sl@0	2436
sl@0	2437	/**
sl@0	2438	* Function Name : TestGzflushHugeBuf
sl@0	2439	* TestCase Description:
sl@0	2440	* 1. Flushes a valid stream
sl@0	2441	* 2. Checks whether returns 0
sl@0	2442	*/
sl@0	2443	TInt CTestZlib::TestGzflushHugeBuf()
sl@0	2444	{
sl@0	2445	TInt res = KErrNone;
sl@0	2446	gzFile file;
sl@0	2447
sl@0	2448	const char * fname= TESTFILE;
sl@0	2449	file = gzopen (fname, "wb");
sl@0	2450	if ( file == Z_NULL)
sl@0	2451	{
sl@0	2452	res = KErrNoMemory;
sl@0	2453	return res;
sl@0	2454	}
sl@0	2455	for (int i=0; i<16385;i++)
sl@0	2456	{
sl@0	2457	gzputc (file, 'a');
sl@0	2458	}
sl@0	2459
sl@0	2460	int l= gzflush (file, Z_FULL_FLUSH);
sl@0	2461	if ( l != Z_OK)
sl@0	2462	{
sl@0	2463	res = KErrGeneral;
sl@0	2464	}
sl@0	2465	int err= gzclose (file);
sl@0	2466	if ( err != Z_OK)
sl@0	2467	{
sl@0	2468	res = KErrGeneral;
sl@0	2469	}
sl@0	2470	return res;
sl@0	2471	}
sl@0	2472
sl@0	2473	/**
sl@0	2474	* Function Name : TestGzrewindNull
sl@0	2475	* TestCase Description:
sl@0	2476	* 1. Rewinds a NULL stream
sl@0	2477	* 2. Checks whether returns -1
sl@0	2478	*/
sl@0	2479	TInt CTestZlib::TestGzrewindNull()
sl@0	2480	{
sl@0	2481	TInt res = KErrNone;
sl@0	2482	res = gzrewind (NULL);
sl@0	2483	if ( res == -1)
sl@0	2484	{
sl@0	2485	res = KErrNone;
sl@0	2486	}
sl@0	2487	else
sl@0	2488	{
sl@0	2489	res = KErrGeneral;
sl@0	2490	}
sl@0	2491	return res;
sl@0	2492	}
sl@0	2493
sl@0	2494	/**
sl@0	2495	* Function Name : TestGzrewindTransparent
sl@0	2496	* TestCase Description:
sl@0	2497	* 1. Rewinds a non-gz file stream
sl@0	2498	* 2. Checks whether returns 1 or not
sl@0	2499	*/
sl@0	2500	TInt CTestZlib::TestGzrewindTransparent()
sl@0	2501	{
sl@0	2502
sl@0	2503	gzFile file;
sl@0	2504	int ret=KErrGeneral;
sl@0	2505	char fname[] = "C:\\gzdirecttest.txt";
sl@0	2506	FILE *fp=NULL;
sl@0	2507	fp=fopen (fname, "w");
sl@0	2508	fputc ('\n', fp);
sl@0	2509	fclose (fp);
sl@0	2510	file = gzopen (fname, "rb");
sl@0	2511	ret = gzdirect (file);
sl@0	2512	if ( ret)
sl@0	2513	{
sl@0	2514	INFO_PRINTF1(_L("Reading a Non GzFile"));
sl@0	2515	ret = gzrewind (file);
sl@0	2516	if ( ret)
sl@0	2517	{
sl@0	2518	ret=KErrGeneral;
sl@0	2519	}
sl@0	2520	else
sl@0	2521	{
sl@0	2522	ret = KErrNone;
sl@0	2523	}
sl@0	2524	}
sl@0	2525	else
sl@0	2526	{
sl@0	2527	ERR_PRINTF1(_L("Error in gzdirect. Expeceted 1, returned 0"));
sl@0	2528	ret=KErrGeneral;
sl@0	2529	}
sl@0	2530	gzclose (file);
sl@0	2531	return ret;
sl@0	2532	}
sl@0	2533
sl@0	2534	/**
sl@0	2535	* Function Name : TestGzgetsBufNull
sl@0	2536	* TestCase Description:
sl@0	2537	* 1. Gets from file into a NULL buffer
sl@0	2538	* 2. Checks whether returns NULL or not
sl@0	2539	*/
sl@0	2540	TInt CTestZlib::TestGzgetsBufNull()
sl@0	2541	{
sl@0	2542
sl@0	2543	const char hello[] = "hello, hello!";
sl@0	2544	int len = (int)strlen(hello)+1;
sl@0	2545	gzFile file;
sl@0	2546	char *buf=NULL;
sl@0	2547	file = gzopen ("c:\\file.gz", "w");
sl@0	2548	if ( file == NULL)
sl@0	2549	{
sl@0	2550	ERR_PRINTF1(_L("gzopen error"));
sl@0	2551	return KErrGeneral;
sl@0	2552	}
sl@0	2553	gzputs (file, hello);
sl@0	2554	gzclose (file);
sl@0	2555	file = gzopen ("c:\\file.gz", "r");
sl@0	2556	buf = gzgets (file, buf, len);
sl@0	2557	gzclose (file);
sl@0	2558	if ( buf == Z_NULL)
sl@0	2559	return KErrNone;
sl@0	2560	else
sl@0	2561	return KErrGeneral;
sl@0	2562	}
sl@0	2563
sl@0	2564	/**
sl@0	2565	* Function Name : TestGzgetsSmallBuf
sl@0	2566	* TestCase Description:
sl@0	2567	* 1. Gets from file into a small buffer
sl@0	2568	* 2. Checks whether returns the string correctly or not
sl@0	2569	*/
sl@0	2570	TInt CTestZlib::TestGzgetsSmallBuf()
sl@0	2571	{
sl@0	2572	const char hello[] = "hello, hello!\n";
sl@0	2573	int len;
sl@0	2574	char expBuf[100];
sl@0	2575	ReadIntParam (len);
sl@0	2576	ReadStringParam (expBuf);
sl@0	2577	gzFile file;
sl@0	2578	char buf=(char )malloc(strlen(hello));
sl@0	2579	file = gzopen ("c:\\file.gz", "w");
sl@0	2580	if ( file == NULL)
sl@0	2581	{
sl@0	2582	ERR_PRINTF1(_L("gzopen error"));
sl@0	2583	free (buf);
sl@0	2584	return KErrGeneral;
sl@0	2585	}
sl@0	2586	gzputs (file, hello);
sl@0	2587	gzclose (file);
sl@0	2588	file = gzopen ("c:\\file.gz", "r");
sl@0	2589	buf = gzgets (file, (char *)buf, len);
sl@0	2590	gzclose (file);
sl@0	2591
sl@0	2592	if ( !strcmp(buf,expBuf))
sl@0	2593	{
sl@0	2594	free (buf);
sl@0	2595	return KErrNone;
sl@0	2596	}
sl@0	2597	else
sl@0	2598	{
sl@0	2599	free (buf);
sl@0	2600	return KErrGeneral;
sl@0	2601	}
sl@0	2602	}

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