--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/compressionlibs/ziplib/test/tef/tlibz/src/tzlibcases.cpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,2602 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Name : tzlibcases.cpp
+//
+//
+#include <errno.h>
+#include "tzlib.h"
+
+#define CHECK_ERR(err, msg) { \
+ if (err != Z_OK) { \
+ INFO_PRINTF2(_L("Error: %d"), err); \
+ return err; \
+ } \
+}
+
+// -----------------------------------------------------------------------------
+//Function Name :ReadStringParam
+//Description:Reads string from ini file
+//Param : aString is populated with the read string
+// -----------------------------------------------------------------------------
+void CTestZlib::ReadStringParam(char* aString)
+ {
+ _LIT( Kparam, "Param%d" );
+ TBuf<100> pNameBuf;
+ TPtrC descriptor;
+ TInt i;
+
+ pNameBuf.Format (Kparam, ++iParamCnt);
+ TBool ret = GetStringFromConfig (ConfigSection (), pNameBuf, descriptor);
+ if ( descriptor == _L("\"\""))
+ {
+ i = 0;
+ }
+ else
+ {
+ // If the string is quoted, take only the insides
+ if ( (descriptor[0] == '\"') && (descriptor[descriptor.Length()-1] == '\"'))
+ {
+ for (i=0; i<descriptor.Length ()-2; i++)
+ {
+ aString[i]=descriptor[i+1];
+ }
+ }
+ // Otherwise,take the whole string
+ else
+ {
+ for (i=0; i<descriptor.Length (); i++)
+ {
+ aString[i]=descriptor[i];
+ }
+ }
+ }
+
+ aString[i]='\0';
+ }
+
+// -----------------------------------------------------------------------------
+//Function Name : ReadIntParam
+//TestCase Description:Reads Int value from ini file
+//Param : TInt to receive the read integer
+// -----------------------------------------------------------------------------
+void CTestZlib::ReadIntParam(TInt &aInt)
+ {
+ _LIT( Kparam, "Param%d" );
+ TBuf<8> pNameBuf;
+ TPtrC string;
+ pNameBuf.Format (Kparam, ++iParamCnt);
+ TBool res = GetIntFromConfig (ConfigSection (), pNameBuf, aInt);
+ }
+
+//---------------/*COMPRESS AND UNCOMPRESS*/----------------------------------
+
+TInt CTestZlib::sec_compress(Byte * compr, uLong comprLen, Byte * uncompr,
+ uLong uncomprLen)
+ {
+
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+
+ err = compress (compr, &comprLen, (const Bytef*)hello, len);
+ CHECK_ERR(err, "compress");
+
+ strcpy ((char*)uncompr, "garbage");
+
+ err = uncompress (uncompr, &uncomprLen, compr, comprLen);
+ CHECK_ERR(err, "uncompress");
+
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ printf ("Bad uncompress");
+ return KErrGeneral;
+ }
+ else
+ {
+ printf ("uncompress(): %s", (char *)uncompr);
+ }
+ return err;
+ }
+
+//------------------------------//deflateSetDictionary//-----------------------------------
+
+TInt CTestZlib::sec_deflateSetDictionary01(Byte * compr, uLong comprLen,
+ TInt flush, TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+ const Bytef* dictionary=(const Bytef *) hello;
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+ err = deflateSetDictionary (&c_stream, dictionary, 3);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, flush);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ deflateEnd (&c_stream);
+ return KErrNone;
+ }
+
+TInt CTestZlib::sec_deflateSetDictionary02(TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+ const Bytef* dictionary=NULL;
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+ err = deflateSetDictionary (&c_stream, dictionary, 30);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ deflateEnd (&c_stream);
+ return KErrNone;
+ }
+
+//------------------------------//deflateSetDictionary//-----------------------------------
+
+TInt CTestZlib::sec_deflateSetDictionary03(Byte * compr, uLong comprLen,
+ TInt flush, TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+ const Bytef* dictionary=(const Bytef *) hello;
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, flush);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ deflateEnd (&c_stream);
+ err = deflateSetDictionary (&c_stream, dictionary, 30);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
+ return err;
+ }
+
+ return KErrNone;
+ }
+
+TInt CTestZlib::sec_deflateSetDictionary04(Byte * compr, uLong comprLen,
+ TInt flush, TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+ const char dict[] = "z";
+
+ const Bytef* dictionary=(const Bytef *) dict;
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+ err = deflateSetDictionary (&c_stream, dictionary, (uLong)strlen(dict)+1);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, flush);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ deflateEnd (&c_stream);
+ return KErrNone;
+ }
+
+TInt CTestZlib::sec_deflateSetDictionary05(Byte * compr, uLong comprLen,
+ TInt flush, TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+ const char
+ dict[] = "abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz \
+ abcdefghijklmnopqrstuvwxyz";
+
+ const Bytef* dictionary=(const Bytef *) dict;
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+ err = deflateSetDictionary (&c_stream, dictionary, (uLong)strlen(dict)+1);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateSetDictionary error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, flush);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ deflateEnd (&c_stream);
+ return KErrNone;
+ }
+//------------------------------//DEFLATE//-----------------------------------
+
+TInt CTestZlib::sec_deflate01( Byte * compr, uLong comprLen, TInt flush,
+ TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, flush);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ deflateEnd (&c_stream);
+ return KErrNone;
+ }
+
+TInt CTestZlib::sec_deflate02( Byte * compr, uLong comprLen, TInt flush,
+ TInt compression)
+ {
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, compression);// Z_DEFAULT_COMPRESSION);
+
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit error: %d"), err);
+ return err;
+ }
+
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen)
+ {
+ c_stream.avail_in = c_stream.avail_out = 1; //* force small buffers
+ err = deflate (&c_stream, Z_NO_FLUSH);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate return code: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+ // Finish the stream, still forcing small buffers:
+ for (;;)
+ {
+ c_stream.avail_out = 1;
+ err = deflate (&c_stream, Z_FINISH);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflate error: %d"), err);
+ deflateEnd (&c_stream);
+ return err;
+ }
+ }
+
+ //deflate call after a finish
+ err = deflate (&c_stream, flush);
+ deflateEnd (&c_stream);
+ return err;
+ }
+//-------------------------------/INFLATE/----------------------------------
+
+TInt CTestZlib::sec_inflate( Byte * compr, uLong comprLen, Byte * uncompr,
+ uLong uncomprLen, TInt flush)
+ {
+ int err;
+ const char hello[] = "hello, hello!";
+ z_stream d_stream; // decompression stream
+
+ //strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = (alloc_func)0;
+ d_stream.zfree = (free_func)0;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 0;
+ d_stream.next_out = uncompr;
+
+ err = inflateInit (&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
+ {
+ d_stream.avail_in = d_stream.avail_out = 1; // force small buffers
+ err = inflate (&d_stream, flush);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ inflateEnd (&d_stream);
+ return err;
+ }
+ }
+
+ err = inflateEnd (&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ ERR_PRINTF1(_L("Bad inflate"));
+ return KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("inflate success"));
+ }
+ return 0;
+ }
+
+//256K buffer size to hold streams
+TInt CTestZlib::sec_inflate_large_buf( Byte * compr, uLong comprLen,
+ Byte * uncompr, uLong uncomprLen, TInt flush)
+ {
+ int err;
+ const char hello[] = "hello, hello!";
+ z_stream d_stream; // decompression stream
+
+ //strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = (alloc_func)0;
+ d_stream.zfree = (free_func)0;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 0;
+ d_stream.next_out = uncompr;
+
+ err = inflateInit (&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
+ {
+ d_stream.avail_in = d_stream.avail_out = 262144; // 256K
+ err = inflate (&d_stream, flush);
+ if ( err == Z_STREAM_END)
+ break;
+ if ( err != Z_OK)
+ {
+ inflateEnd (&d_stream);
+ return err;
+ }
+ }
+
+ err = inflateEnd (&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ ERR_PRINTF1(_L("Bad inflate"));
+ return KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("inflate success"));
+ }
+ return 0;
+ }
+
+//----------------------------//GZ OPERATION//--------------------------------
+
+TInt CTestZlib::sec_gzio( const char *fname, Byte * uncompr, uLong uncomprLen)
+ {
+#ifdef NO_GZCOMPRESS
+ ERR_PRINTF1(_L("NO_GZCOMPRESS -- gz* functions cannot compress"));
+#else
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+ z_off_t pos;
+
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 4)
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzputs err"));
+ return KErrGeneral;
+ }
+ if ( gzprintf (file, ", %s!", "hello")!= 8)
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzprintf err:"));
+ return KErrGeneral;
+ }
+
+ gzseek (file, 1L, SEEK_CUR); // add one zero byte
+ gzclose (file);
+
+ file = gzopen (fname, "rb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ strcpy ((char*)uncompr, "garbage");
+
+ if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzread err"));
+ return KErrGeneral;
+ }
+
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("bad gzread"));
+ return KErrGeneral;
+ }
+
+ pos = gzseek (file, -8L, SEEK_CUR);
+ if ( pos != 6 || gztell (file)!= pos)
+ {
+ gzclose (file);
+ ERR_PRINTF3(_L("gzseek error, pos=%ld, gztell=%ld"),(long)pos, (long)gztell(file));
+ return KErrGeneral;
+ }
+
+ if ( gzgetc (file)!= ' ')
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzgetc error"));
+ return KErrGeneral;
+ }
+
+ if ( gzungetc (' ', file)!= ' ')
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzungetc error"));
+ return KErrGeneral;
+ }
+
+ gzgets (file, (char*)uncompr, (int)uncomprLen);
+
+ if ( strlen ((char*)uncompr)!= 7)
+ {
+ gzclose (file);
+ // " hello!"
+ ERR_PRINTF1(_L("gzgets err after gzseek"));
+ return KErrGeneral;
+ }
+
+ if ( strcmp ((char*)uncompr, hello + 6))
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("bad gzgets after gzseek"));
+ return KErrGeneral;
+ }
+
+ gzclose (file);
+#endif
+ return KErrNone;
+ }
+
+TInt CTestZlib::Test_zlibVersion()
+ {
+ INFO_PRINTF1(_L("Zlib Test zlibVersion"));
+ int retVal = 0;
+
+ const char *version = zlibVersion ();
+ if ( strcmp (ZLIB_VERSION, version)== 0)
+ {
+ INFO_PRINTF1(_L("Returned version matches!"));
+ retVal=KErrNone;
+ }
+
+ else
+ {
+ ERR_PRINTF1(_L("Return version mismatch!"));
+ retVal=KErrGeneral;
+ }
+ return retVal;
+ }
+
+TInt CTestZlib::Test_compress01()
+ {
+ INFO_PRINTF1(_L("Zlib Test compress"));
+ int retVal = 0;
+
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ if ( comp == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for comp."));
+ return KErrNoMemory;
+ }
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+ if ( uncomp == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for uncomp."));
+ free (comp);
+ return KErrNoMemory;
+ }
+
+ retVal = sec_compress (comp, compLen, uncomp, uncompLen);
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+// Test deflate - normal flow
+TInt CTestZlib::Test_deflate01()
+ {
+ INFO_PRINTF1(_L("Zlib Test deflate"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+//Negative test -
+TInt CTestZlib::Test_deflate02()
+ {
+ INFO_PRINTF1(_L("Zlib Test deflate"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate02 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+// Test deflate small output buffer
+TInt CTestZlib::Test_deflateEnd()
+ {
+ INFO_PRINTF1(_L("Zlib Test deflateEnd"));
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ z_stream c_stream; // compression stream
+ int err;
+ const char hello[] = "hello, hello!";
+ uLong len = (uLong)strlen(hello)+1;
+
+ c_stream.zalloc = (alloc_func)0;
+ c_stream.zfree = (free_func)0;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit (&c_stream, Z_DEFAULT_COMPRESSION);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("deflateInit failed: %d"), err);
+ free (comp);
+ return err;
+ }
+
+ c_stream.next_in = (Bytef*)hello;
+ c_stream.next_out = comp;
+ err = deflateEnd (&c_stream);
+ if ( err != Z_OK)
+ {
+ ERR_PRINTF2(_L("deflateEnd failed: %d"), err);
+ free (comp);
+ return err;
+ }
+ if ( c_stream.state != NULL)
+ {
+ ERR_PRINTF1(_L("Stream state expected NULL"));
+ free (comp);
+ return err;
+ }
+ free (comp);
+ return KErrNone;
+ }
+
+TInt CTestZlib::Test_inflate01()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflate. Positive test"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 60;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ //comp = (Byte*)malloc(compLen);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+ //uncomp = (Byte*)malloc(uncompLen);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ if ( retVal != KErrNone)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
+ retVal= KErrGeneral;
+ }
+ retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+//Negative test - invalid deflate data - return Z_DATA_ERROR
+TInt CTestZlib::Test_inflate02()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflate with invalide deflate data"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ //comp = (Byte*)malloc(compLen);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+ //uncomp = (Byte*)malloc(uncompLen);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+// uncompressed data buffer inititalized to NULL
+TInt CTestZlib::Test_inflate03()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflate with NULL uncompressed data buffer"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp=NULL, *uncomp=NULL;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ //uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ if ( retVal != KErrNone)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
+ retVal= KErrGeneral;
+ }
+ retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp); //free(uncomp);
+ return retVal;
+ }
+
+//Not enough buffer size for uncompresed data
+TInt CTestZlib::Test_inflate04()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflatewith not enough buffer size for uncompressed data"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp=NULL, *uncomp=NULL;
+ uLong compLen, uncompLen;
+ compLen = 30;
+ uncompLen = 5;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ if ( retVal != KErrNone)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
+ retVal= KErrGeneral;
+ }
+ retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+//Use 256K sized chunks for inflating
+TInt CTestZlib::Test_inflate05()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflate with 256K sized chunks"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp=NULL, *uncomp=NULL;
+ uLong compLen, uncompLen;
+ compLen = 30;
+ uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1); //Do not alloc for uncompressed data
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ if ( retVal != KErrNone)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
+ retVal= KErrGeneral;
+ }
+ retVal = sec_inflate_large_buf (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+TInt CTestZlib::Test_inflate06()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflate with invalid data"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 60;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ //comp = (Byte*)malloc(compLen);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+ //uncomp = (Byte*)malloc(uncompLen);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflate01 (comp, compLen, flush, compression);
+ if ( retVal != KErrNone)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),KErrNone,retVal);
+ retVal= KErrGeneral;
+ }
+
+ // Corrupt the compressed data
+ comp[0] = 'a';
+ comp[1] = 'a';
+
+ retVal = sec_inflate (comp, compLen, uncomp, uncompLen, flush);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+TInt CTestZlib::Test_inflateEnd()
+ {
+ INFO_PRINTF1(_L("Zlib Test inflateEnd"));
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+
+ int err;
+ z_stream d_stream; // decompression stream
+
+ //strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = (alloc_func)0;
+ d_stream.zfree = (free_func)0;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = comp;
+ d_stream.avail_in = 0;
+ d_stream.next_out = uncomp;
+
+ err = inflateInit (&d_stream);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("inflateInit error: %d"), err);
+ free (comp);
+ free (uncomp);
+ return err;
+ }
+ //Not inflating
+
+ err = inflateEnd (&d_stream);
+ if ( err != Z_OK)
+ {
+ INFO_PRINTF2(_L("inflateEnd error: %d"), err);
+ free (comp);
+ free (uncomp);
+ return err;
+ }
+ if ( d_stream.state != NULL)
+ {
+ INFO_PRINTF2(_L("inflateEnd error: %d"), err);
+ free (comp);
+ free (uncomp);
+ return err;
+ }
+
+ free (comp);
+ free (uncomp);
+ return KErrNone;
+ }
+
+// Test deflateSetDictionary - normal flow
+TInt CTestZlib::Test_deflateSetDictionary01()
+ {
+ INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - positive test"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflateSetDictionary01 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+// Test deflateSetDictionary - dictionary NULL
+TInt CTestZlib::Test_deflateSetDictionary02()
+ {
+ INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary with dictionary NULL"));
+ int retVal = KErrGeneral;
+
+ TInt compression, expRet;
+
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+ retVal = sec_deflateSetDictionary02 (compression);
+
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+// Test deflateSetDictionary - set dictionary after deflate, deflateEnd
+TInt CTestZlib::Test_deflateSetDictionary03()
+ {
+ INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - set dictionary after deflating"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflateSetDictionary03 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+// Test deflateSetDictionary - set tiny dictionary < MIN_MATCH
+TInt CTestZlib::Test_deflateSetDictionary04()
+ {
+ INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - positive test"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflateSetDictionary04 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+// Test deflateSetDictionary - set large dictionary > MAX_MATCH
+TInt CTestZlib::Test_deflateSetDictionary05()
+ {
+ INFO_PRINTF1(_L("Zlib Test test_deflateSetDictionary - set large dictionary > MAX_MATCH"));
+ int retVal = KErrGeneral;
+ TInt flush, compression, expRet;
+
+ Byte *comp;
+ uLong compLen;
+ compLen = 30;
+ comp = (Byte*)calloc((uInt)compLen, 1);
+
+ ReadIntParam (flush);
+ ReadIntParam (compression);
+ ReadIntParam (expRet);
+
+ retVal = sec_deflateSetDictionary05 (comp, compLen, flush, compression);
+ free (comp);
+ if ( retVal != expRet)
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRet,retVal);
+ retVal= KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Test passes!"));
+ retVal= KErrNone;
+ }
+ return retVal;
+ }
+
+TInt CTestZlib::Test_gzio()
+ {
+ INFO_PRINTF1(_L("Zlib Test gzio"));
+ int retVal = 0;
+
+ Byte *comp, *uncomp;
+ uLong compLen, uncompLen;
+ compLen = uncompLen = 30;
+
+ comp = (Byte*)calloc((uInt)compLen, 1);
+ if ( comp == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for comp."));
+ return KErrNoMemory;
+ }
+
+ uncomp = (Byte*)calloc((uInt)uncompLen, 1);
+ if ( uncomp == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for uncomp."));
+ free (comp);
+ return KErrNoMemory;
+ }
+
+ retVal = sec_gzio ("C:\\bye.gz", uncomp, uncompLen);
+ free (comp);
+ free (uncomp);
+ return retVal;
+ }
+
+TInt CTestZlib::Test_gzdirect()
+ {
+ INFO_PRINTF1(_L("gzdirect test: read gz file"));
+ TInt res = KErrNone;
+ char mode[3];
+ gzFile file;
+ const char * fname= TESTFILE;
+ ReadStringParam (mode);
+ file = gzopen (fname, mode);
+ if ( file == NULL)
+ {
+ res = KErrGeneral;
+ return res;
+ }
+ res = gzdirect (file); //0=success
+ gzclose (file);
+ return res;
+ }
+
+TInt CTestZlib::Test_gzdirectnull()
+ {
+ INFO_PRINTF1(_L("gzdirect test: read NULL stream"));
+ TInt res = KErrNone;
+ gzFile file=NULL;
+ res = gzdirect (file); //0=success
+ gzclose (file);
+ return res;
+ }
+
+TInt CTestZlib::Test_gzclearerr_null()
+ {
+ TInt res = KErrNone;
+ int err;
+ gzFile file;
+ const char *fname= NULL;
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ res=KErrGeneral;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 5)
+ {
+ gzprintf (file, "gzputs err");
+ res=KErrGeneral;
+ }
+ err= gzclose (file);
+ if ( err != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ gzclearerr (file);
+ z_stream *s = (z_stream*)file;
+ if ( s == NULL)
+ res = KErrNone;
+ else
+ {
+ ERR_PRINTF1(_L("Expected NULL stream. Returned nonNULL"));
+ res = KErrGeneral;
+ }
+ return res;
+ }
+
+TInt CTestZlib::Test_gzclearerr()
+ {
+
+ Byte *compr, *uncompr;
+ uLong comprLen = 20*sizeof(int);
+
+ uLong uncomprLen = comprLen;
+ compr = (Byte*)calloc((uInt)comprLen, 1);
+ if ( compr == Z_NULL)
+ {
+ return KErrNoMemory;
+ }
+ uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
+ if ( uncompr == Z_NULL)
+ {
+ free (compr);
+ return KErrNoMemory;
+ }
+
+ INFO_PRINTF1(_L("gzclearerr test"));
+ int err;
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+
+ file = gzopen (MYFILE, "wb");
+ if ( file == NULL)
+ {
+ err = KErrGeneral;
+ free (compr);
+ free (uncompr);
+ return err;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 4)
+ {
+ err=KErrGeneral;
+ }
+ if ( gzprintf (file, ", %s!", "hello")!= 8)
+ {
+ err=KErrGeneral;
+ }
+ gzseek (file, 1L, SEEK_CUR); // add one zero byte
+ gzclose (file);
+
+ file = gzopen (MYFILE, "rb");
+ if ( file == NULL)
+ {
+ err = KErrGeneral;
+ free (compr);
+ free (uncompr);
+ return err;
+ }
+ strcpy ((char*)uncompr, "garbage");
+
+ if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
+ {
+ }
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ err=KErrGeneral;
+ }
+ else
+ {
+ err=KErrNone;
+ }
+
+ gzseek (file, -8L, SEEK_CUR);
+ gzclearerr (file);
+ gzgets (file, (char*)uncompr, (int)uncomprLen);
+
+ if ( strlen ((char*)uncompr)!= 7)
+ {
+ //1 " hello!"
+ ERR_PRINTF1(_L("gzegets gets wrong string"));
+ err=KErrGeneral;
+ }
+ gzclose (file);
+
+ free (compr);
+ free (uncompr);
+ return err;
+ }
+
+TInt CTestZlib::Test_gzerror_streamend()
+ {
+#ifdef NO_GZCOMPRESS
+ ERR_PRINTF1(_L("NO_GZCOMPRESS -- gz* functions cannot compress"));
+#else
+ const char *msgptr;
+ char fname[] = "C:\\bye.gz";
+
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+ comprLen = uncomprLen = 30;
+
+ compr = (Byte*)calloc((uInt)comprLen, 1);
+ if ( compr == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for compr."));
+ return KErrNoMemory;
+ }
+
+ uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
+ if ( uncompr == NULL)
+ {
+ INFO_PRINTF1(_L("Could not allocate memory for uncompr."));
+ free (compr);
+ return KErrNoMemory;
+ }
+
+ int err;
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 4)
+ {
+ ERR_PRINTF1(_L("gzputs err"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+ if ( gzprintf (file, ", %s!", "hello")!= 8)
+ {
+ ERR_PRINTF1(_L("gzprintf err="));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+
+ gzseek (file, 1L, SEEK_CUR); // add one zero byte
+ gzclose (file);
+
+ file = gzopen (fname, "rb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+ strcpy ((char*)uncompr, "garbage");
+
+ if ( gzread (file, uncompr, (unsigned)uncomprLen)!= len)
+ {
+ ERR_PRINTF1(_L("gzread err"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+
+ if ( strcmp ((char*)uncompr, hello))
+ {
+ ERR_PRINTF1(_L("bad gzread"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+
+ INFO_PRINTF2(_L("Reached file position %ld"),gzseek(file, -8L, SEEK_CUR));
+
+ gzgets (file, (char*)uncompr, (int)uncomprLen);
+ msgptr = gzerror (file, &err);
+ if ( strcmp (msgptr, "C:\\bye.gz: stream end")!= 0)
+ {
+ // " hello!"
+ ERR_PRINTF1(_L("gzerror err on streamend"));
+ free (compr);
+ free (uncompr);
+ return KErrGeneral;
+ }
+
+ gzclose (file);
+ free (compr);
+ free (uncompr);
+
+ if ( err != Z_STREAM_END)
+ {
+ return KErrGeneral;
+ }
+ return KErrNone;
+#endif
+ }
+
+TInt CTestZlib::Test_gzungetcnegative()
+ {
+ gzFile file=NULL;
+ int ret = gzungetc (' ', file); //NULL stream
+ if ( ret != EOF)
+ {
+ ERR_PRINTF2(_L("gzungetc NULL stream test: Expected EOF but returned %d"),ret);
+ return KErrGeneral;
+ }
+
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+
+ file = gzopen ("C:\\bye.gz", "wb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 4)
+ {
+ ERR_PRINTF1(_L("gzputs err"));
+ gzclose (file);
+ return KErrGeneral;
+ }
+
+ ret = gzungetc (' ', file); //non-read mode
+ if ( ret != EOF)
+ {
+ ERR_PRINTF2(_L("gzungetc non-read mode test: Expected EOF but returned %d"),ret);
+ gzclose (file);
+ return KErrGeneral;
+ }
+
+ gzseek (file, 1L, SEEK_CUR); // add one zero byte
+ gzclose (file);
+
+ file = gzopen ("C:\\bye.gz", "rb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+
+ if ( gzungetc (EOF, file)!= EOF) //ungetc EOF
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzungetc error"));
+ return KErrGeneral;
+ }
+ gzclose (file);
+
+ return KErrNone;
+ }
+
+TInt CTestZlib::Test_gzseeknegative()
+ {
+
+ int err=0;
+
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+
+ file = gzopen (TESTFILE, "wb");
+ if ( file == NULL)
+ {
+ return KErrNoMemory;
+ }
+ gzputc (file, 'h');
+
+ err= gzseek (file, 1L, SEEK_END); /* add one zero byte */
+ if ( err != -1)
+ {
+ gzclose (file);
+ return KErrGeneral;
+ }
+
+ err= gzclose (file);
+ file = gzopen (TESTFILE, "rb");
+ if ( gzgetc (file)!= 'h')
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzgetc error"));
+ return KErrGeneral;
+ }
+ if ( gzgetc (file)!= EOF)
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzgetc error"));
+ return KErrGeneral;
+ }
+ err= gzseek (file, 1L, SEEK_CUR);
+ if ( gzgetc (file)!= -1L)
+ {
+ gzclose (file);
+ ERR_PRINTF1(_L("gzseek error"));
+ return KErrGeneral;
+ }
+ gzclose (file);
+ return KErrNone;
+ }
+
+/*TInt CTestZlib::TestGzopenRw()
+ {
+ TInt res = KErrNone ;
+ gzFile file;
+ char c;
+ const char *fname = "c:\\Bytes.gz";
+ file = gzopen(fname, "wr");
+ if (file == NULL)
+ {
+ res = KErrGeneral;
+ return res;
+ }
+ else
+ {
+ res=gzputc(file, 'r');
+ if(res<0)
+ {
+ res = KErrGeneral;
+ }
+ else
+ {
+ res = KErrNone;
+ //gzclearerr(file);
+ gzseek(file,0, SEEK_SET);
+ c = gzgetc(file);
+ if(c == 'r')
+ {
+ res = KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF1(_L("gzgetc error in rw mode. Expected r"));
+ res=KErrGeneral;
+ }
+ }
+ }
+ gzclose(file);
+ return res;
+ }
+ */
+/**
+ * Function Name : Test_gzdirecttxt
+ * TestCase Description: 1. Checks whether a normal txt file gives a compressed stream or not
+ */
+TInt CTestZlib::Test_gzdirecttxt()
+ {
+ gzFile file;
+ int ret=KErrGeneral;
+ char fname[] = "C:\\gzdirecttest.txt";
+ FILE *fp=NULL;
+ fp=fopen (fname, "w");
+ fputc ('\n', fp);
+ fclose (fp);
+ file = gzopen (fname, "rb");
+ ret = gzdirect (file);
+ if ( ret)
+ {
+ INFO_PRINTF1(_L("Reading a Non GzFile"));
+ ret=KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Error in gzdirect. Expeceted 1, returned 0"));
+ ret=KErrGeneral;
+ }
+ gzclose (file);
+ return ret;
+ }
+
+/**
+ * Function Name : TestGzungetcChain
+ * TestCase Description: 1. Checks whether gzungetc ungets the read chars using getc
+ */
+TInt CTestZlib::TestGzungetcChain()
+ {
+ gzFile file;
+ char tmp;
+ char fname[] = "C:\\Hello.gz";
+ file = gzopen (fname, "wb");
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello World")!= 10)
+ {
+ gzclose (file);
+ printf ("Error: gzputs\n");
+ }
+ gzclose (file);
+ file = gzopen (fname, "rb");
+ while (' ' != ( tmp = gzgetc(file) ))
+ {
+ gzungetc (tmp, file);
+ gzseek (file, 1L, SEEK_CUR);
+ }
+ gzclose (file);
+ return KErrNone;
+ }
+
+/**
+ * Function Name : TestGzseekBack
+ * TestCase Description: 1. Checks whether gzseek returns -1
+ * for backward seeks in files opened in write mode.
+ */
+TInt CTestZlib::TestGzseekBack()
+ {
+ int err;
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+
+ const char * fname= TESTFILE;
+
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ err = KErrGeneral;
+ return err;
+ }
+ gzputc (file, 'h');
+ if ( gzputs (file, "ello")!= 4)
+ {
+ err=1;
+ }
+ if ( gzprintf (file, ", %s!", "hello")!= 8)
+ {
+ err=1;
+ }
+ err = (int) gzseek(file,0, SEEK_SET); /* to beg */
+ gzclose (file);
+ if ( err == -1)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected -1, returned %d"),err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzseekAppend
+ * TestCase Description:
+ * 1. Writes a text file, closes.
+ * 2. Open using gzopen in append mode
+ * 3. Writes another character.
+ * 4. Seek one down from current position
+ * 5. Checks whether gzseek returns 2
+ */
+TInt CTestZlib::TestGzseekAppend()
+ {
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ int err;
+ gzFile file;
+
+ FILE *fp = fopen ("c:\\file.txt", "wb");
+ fputc ('h', fp);
+ fclose (fp);
+ file = gzopen ("c:\\file.txt", "a");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ err = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
+ gzclose (file);
+ if ( err == 2)
+ return KErrNone;
+ else
+ {
+ ERR_PRINTF2(_L("Expected 2, returned %d"),err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzseekHugeOffset
+ * TestCase Description:
+ * 1. Writes a text file, closes.
+ * 2. Open using gzopen in append mode
+ * 3. Writes another character.
+ * 4. Seek 4097 up from current position
+ * 5. Checks whether gzseek returns 16386 or not.
+ */
+TInt CTestZlib::TestGzseekHugeOffset()
+ {
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ int err;
+ gzFile file;
+
+ FILE *fp = fopen ("c:\\file.txt", "wb");
+ fputc ('h', fp);
+ fclose (fp);
+ file = gzopen ("c:\\file.txt", "a");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ err = (int) gzseek(file,16385L, SEEK_CUR); /* advance pos by 16385*/
+ gzclose (file);
+ if ( err == 16386)
+ return KErrNone;
+ else
+ {
+ ERR_PRINTF2(_L("Expected 2, returned %d"),err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzseekNoSize
+ * TestCase Description:
+ * 1. Seeks a zero sized file
+ * 2. Checks whether it returns -1 or not
+ */
+TInt CTestZlib::TestGzseekNoSize()
+ {
+ TInt res = KErrNone;
+ gzFile file;
+ uInt size, len;
+ const char *s="\0";
+ len=strlen (s);
+ const char * fname= TESTFILE;
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ size = gzwrite (file, (char*)s, (unsigned)strlen(s));
+ if ( len!=size)
+ {
+ ERR_PRINTF1(_L("gzwrite error"));
+ return KErrGeneral;
+ }
+
+ res = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
+ gzclose (file);
+ if ( res == 1)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected -1, returned %d"), res);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenLongPath
+ * TestCase Description:
+ * 1. Seeks a file with long name
+ * 2. Checks whether gzopen returns NULL or not
+ */
+TInt CTestZlib::TestGzopenLongPath01()
+ {
+ gzFile file;
+ const char
+ * fname = "c:\\fffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff.txt";
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ INFO_PRINTF1(_L("Returned NULL"));
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzseekLongPath
+ * TestCase Description:
+ * 1. Seeks a acceptable long file name
+ * 2. Checks whether it returns 1 or not
+ */
+TInt CTestZlib::TestGzseekLongPath01()
+ {
+ TInt res = KErrNone;
+ gzFile file;
+ uInt size, len;
+ const char *s="\0";
+ len=strlen (s);
+ const char
+ * fname = "c:\\fffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff.txt";
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ size = gzwrite (file, (char*)s, (unsigned)strlen(s));
+ if ( len!=size)
+ {
+ ERR_PRINTF1(_L("gzwrite error"));
+ return KErrGeneral;
+ }
+
+ res = (int) gzseek(file,1L, SEEK_CUR); /* to next pos */
+ gzclose (file);
+ if ( res == 1)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected -1, returned %d"), res);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenLongPath
+ * TestCase Description:
+ * 1. Seeks a long pathed file
+ * 2. Checks whether it returns NULL or not
+ */
+TInt CTestZlib::TestGzopenLongPath02()
+ {
+ gzFile file;
+ int ret = KErrNone;
+ const char
+ * fname = "C:\\fffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff\
+ fffffffffffffffffffffffffffffff";
+
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error- File NULL"));
+ return KErrGeneral;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Expected file pointer, returned Success"));
+ }
+ gzclose (file);
+ return ret;
+ }
+
+/**
+ * Function Name : TestGzseekMixedFile01
+ * TestCase Description:
+ * 1. Open using gzopen in write mode
+ * 2. gzputs a string.
+ * 3. fopen it, writes a text, close.
+ * 4. Seek one down from current position
+ * 5. Checks whether gzseek returns 1 for offset 1L,
+ * 1000L for offset 1000L, -1 for -1L, -1 for -1000L
+ */
+TInt CTestZlib::TestGzseekMixedFile01()
+ {
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ int err;
+ gzFile file;
+
+ TInt offset, expRes;
+
+ ReadIntParam (offset);
+ ReadIntParam (expRes);
+
+ file = gzopen ("c:\\file.txt", "wb");
+ gzputs (file, hello);
+ gzclose (file);
+ FILE *fp = fopen ("c:\\file.txt", "w+");
+ fputc ('h', fp);
+ fclose (fp);
+ file = gzopen ("c:\\file.txt", "rb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ err = (int) gzseek(file,offset, SEEK_CUR); /* to next pos */
+ gzclose (file);
+ if ( err == expRes)
+ return KErrNone;
+ else
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenNoMode
+ * TestCase Description:
+ * 1. gzopen a file with NULL mode
+ * 2. Checks whether gzopen returns NULL or not
+ */
+TInt CTestZlib::TestGzopenNoMode()
+ {
+ gzFile file;
+ const char * fname = "c:\\file.txt";
+ file = gzopen (fname, NULL);
+ if ( file == Z_NULL)
+ {
+ INFO_PRINTF1(_L("Returned NULL"));
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenNoPath
+ * TestCase Description:
+ * 1. gzopen a file with NULL path
+ * 2. Checks whether gzopen returns NULL or not
+ */
+TInt CTestZlib::TestGzopenNoPath()
+ {
+ gzFile file;
+ file = gzopen (NULL, "wb");
+ if ( file == Z_NULL)
+ {
+ INFO_PRINTF1(_L("Returned NULL"));
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenNoPath
+ * TestCase Description:
+ * 1. gzopen a file with path,mode empty string,
+ * 2. Checks whether gzopen returns NULL or not
+ */
+TInt CTestZlib::TestGzopenNoPathMode()
+ {
+ gzFile file;
+ file = gzopen ("", "");
+ if ( file == Z_NULL)
+ {
+ INFO_PRINTF1(_L("Returned NULL"));
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF2(_L("Expected NULL, returned %d"), file);
+ return KErrGeneral;
+ }
+ }
+/**
+ * Function Name : TestGzseekConcatedFile01
+ * TestCase Description:
+ * 1. Open a manually concatinated gz file using gzopen in read mode
+ * 2. Seek one down from current position
+ * 3. Checks whether gzseek returns 1 for offset 1L,
+ * -1 for offset 1000L, -1 for -1L, -1 for -1000L
+ */
+TInt CTestZlib::TestGzseekConcatedFile01()
+ {
+ int err;
+ gzFile file;
+
+ TInt offset, expRes;
+ ReadIntParam (offset);
+ ReadIntParam (expRes);
+
+ file = gzopen (FILETESTGZCONCAT, "rb");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ err = (int) gzseek(file,offset, SEEK_CUR); // to next pos
+ gzclose (file);
+ if ( err == expRes)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzopenNoPath
+ * TestCase Description:
+ * 1. gzopen a file with valid path, mode: 9, f, h, R, 9, fb, hb, Rb,
+ * and wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
+ * 2. Checks whether gzopen returns NULL all cases, except the last one.
+ */
+TInt CTestZlib::TestGzopenDiffMode()
+ {
+ TInt res = KErrNone;
+ gzFile file=Z_NULL;
+ const char * fname= TESTFILE;
+ char mode[100];
+ TInt expRes;
+ ReadStringParam (mode);
+ ReadIntParam (expRes);
+ file = gzopen (fname, "wb");
+ res = gzputc (file, 'h');
+ res = gzclose (file);
+ file = gzopen (fname, mode);
+ if ( (file == Z_NULL && expRes == 0) || (file != Z_NULL && expRes == 1))
+ {
+ res = KErrNone;
+ }
+ else
+ {
+ res = KErrGeneral;
+ ERR_PRINTF1(_L("Expected NULL, returned nonNULL"));
+ }
+ if ( file)
+ {
+ gzclose (file);
+ }
+ return res;
+ }
+
+/**
+ * Function Name : TestGzseekConcatedFile02
+ * TestCase Description:
+ * 1. Open a programmatically concatinated gz file using gzopen
+ * in read mode
+ * 2. Seek one down from current position
+ * 3. Checks whether gzseek returns 1 for offset 1L,
+ * -1 for offset 1000L, -1 for -1L, -1 for -1000L
+ */
+TInt CTestZlib::TestGzseekConcatedFile02()
+ {
+ int err;
+ gzFile file;
+
+ TInt offset, expRes;
+
+ ReadIntParam (offset);
+ ReadIntParam (expRes);
+ char fname1[13]="c:\\first.gz";
+ char fname2[14]="c:\\second.gz";
+
+ //create 2 gz files
+ file = gzopen (fname1, "w");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'h');
+ gzclose (file);
+ file = gzopen (fname2, "w");
+ if ( file == NULL)
+ {
+ unlink (fname1);
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputc (file, 'e');
+ gzclose (file);
+
+ //concatenate the two
+ FILE *fpFirst=NULL, *fpSecond=NULL;
+ fpFirst = fopen (fname1, "a");
+ fpSecond = fopen (fname2, "r");
+ char c;
+ for (; !feof(fpSecond);)
+ {
+ c=fgetc (fpSecond);
+ fputc (c, fpFirst);
+ }
+ fclose (fpFirst);
+ fclose (fpSecond);
+
+ //Now seek
+ file = gzopen (fname1, "r");
+ err = (int) gzseek(file,offset, SEEK_CUR); // to next pos
+ gzclose (file);
+ if ( err == expRes)
+ {
+ unlink (fname1);
+ unlink (fname2);
+ return KErrNone;
+ }
+ else
+ {
+ unlink (fname1);
+ unlink (fname2);
+ ERR_PRINTF3(_L("Expected %d, returned %d"),expRes, err);
+ return KErrGeneral;
+ }
+ }
+
+/**
+ * Function Name : TestGzprintf01
+ * TestCase Description:
+ * 1. Prints an empty string
+ * 2. Checks whether returns 0
+ */
+TInt CTestZlib::TestGzprintf01()
+ {
+ TInt res = KErrGeneral;
+ gzFile file;
+ const char * fname= TESTFILE;
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ res = KErrNoMemory;
+ return res;
+ }
+ res = gzprintf (file, "");
+ if ( res != 0)
+ {
+ ERR_PRINTF1(_L("gzprintf err"));
+ }
+ else
+ {
+ res = KErrNone;
+ }
+ gzclose (file);
+ return res;
+ }
+/**
+ * Function Name : TestGzprintf02
+ * TestCase Description:
+ * 1. Prints an large string of length 4097, 4096
+ * 2. Checks whether returns 0, 4095
+ */
+TInt CTestZlib::TestGzprintf02()
+ {
+ TInt res = KErrGeneral;
+ gzFile file;
+ const char * fname= TESTFILE;
+
+ char largeStr[4098];
+ TInt strLength, expRes;
+ ReadIntParam (strLength);
+ ReadIntParam (expRes);
+
+ //create alarge string
+ for (int i=0; i<strLength;i++)
+ {
+ largeStr[i]='a';
+ }
+ largeStr[strLength]='\0';
+ file = gzopen (fname, "wb");
+ if ( file == NULL)
+ {
+ res = KErrNoMemory;
+ return res;
+ }
+ res = gzprintf (file, largeStr);
+ if ( res != expRes)
+ {
+ ERR_PRINTF1(_L("gzprintf err"));
+ }
+ else
+ {
+ res = KErrNone;
+ }
+ gzclose (file);
+ unlink (TESTFILE);
+ return res;
+ }
+
+/**
+ * Function Name : TestGzflushNull
+ * TestCase Description:
+ * 1. Flushes a NULL stream
+ * 2. Checks whether returns Z_STREAM_ERROR(-2)
+ */
+TInt CTestZlib::TestGzflushNull()
+ {
+ TInt res = KErrNone;
+ gzFile file= NULL;
+ int l= gzflush (file, Z_FULL_FLUSH);
+ if ( l != Z_STREAM_ERROR)
+ {
+ res = KErrGeneral;
+ }
+ return res;
+ }
+
+/**
+ * Function Name : TestGzflushRepeat
+ * TestCase Description:
+ * 1. Flushes a valid stream twice
+ * 2. Checks whether returns 0
+ */
+TInt CTestZlib::TestGzflushRepeat()
+ {
+ TInt res = KErrNone;
+ gzFile file;
+
+ const char * fname= TESTFILE;
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ res = KErrNoMemory;
+ return res;
+ }
+ int l= gzflush (file, Z_FULL_FLUSH);
+ if ( l != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ l= gzflush (file, Z_SYNC_FLUSH);
+ if ( l != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ int err= gzclose (file);
+ if ( err != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ return res;
+ }
+
+/**
+ * Function Name : TestGzflushHugeBuf
+ * TestCase Description:
+ * 1. Flushes a valid stream
+ * 2. Checks whether returns 0
+ */
+TInt CTestZlib::TestGzflushHugeBuf()
+ {
+ TInt res = KErrNone;
+ gzFile file;
+
+ const char * fname= TESTFILE;
+ file = gzopen (fname, "wb");
+ if ( file == Z_NULL)
+ {
+ res = KErrNoMemory;
+ return res;
+ }
+ for (int i=0; i<16385;i++)
+ {
+ gzputc (file, 'a');
+ }
+
+ int l= gzflush (file, Z_FULL_FLUSH);
+ if ( l != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ int err= gzclose (file);
+ if ( err != Z_OK)
+ {
+ res = KErrGeneral;
+ }
+ return res;
+ }
+
+/**
+ * Function Name : TestGzrewindNull
+ * TestCase Description:
+ * 1. Rewinds a NULL stream
+ * 2. Checks whether returns -1
+ */
+TInt CTestZlib::TestGzrewindNull()
+ {
+ TInt res = KErrNone;
+ res = gzrewind (NULL);
+ if ( res == -1)
+ {
+ res = KErrNone;
+ }
+ else
+ {
+ res = KErrGeneral;
+ }
+ return res;
+ }
+
+/**
+ * Function Name : TestGzrewindTransparent
+ * TestCase Description:
+ * 1. Rewinds a non-gz file stream
+ * 2. Checks whether returns 1 or not
+ */
+TInt CTestZlib::TestGzrewindTransparent()
+ {
+
+ gzFile file;
+ int ret=KErrGeneral;
+ char fname[] = "C:\\gzdirecttest.txt";
+ FILE *fp=NULL;
+ fp=fopen (fname, "w");
+ fputc ('\n', fp);
+ fclose (fp);
+ file = gzopen (fname, "rb");
+ ret = gzdirect (file);
+ if ( ret)
+ {
+ INFO_PRINTF1(_L("Reading a Non GzFile"));
+ ret = gzrewind (file);
+ if ( ret)
+ {
+ ret=KErrGeneral;
+ }
+ else
+ {
+ ret = KErrNone;
+ }
+ }
+ else
+ {
+ ERR_PRINTF1(_L("Error in gzdirect. Expeceted 1, returned 0"));
+ ret=KErrGeneral;
+ }
+ gzclose (file);
+ return ret;
+ }
+
+/**
+ * Function Name : TestGzgetsBufNull
+ * TestCase Description:
+ * 1. Gets from file into a NULL buffer
+ * 2. Checks whether returns NULL or not
+ */
+TInt CTestZlib::TestGzgetsBufNull()
+ {
+
+ const char hello[] = "hello, hello!";
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+ char *buf=NULL;
+ file = gzopen ("c:\\file.gz", "w");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ return KErrGeneral;
+ }
+ gzputs (file, hello);
+ gzclose (file);
+ file = gzopen ("c:\\file.gz", "r");
+ buf = gzgets (file, buf, len);
+ gzclose (file);
+ if ( buf == Z_NULL)
+ return KErrNone;
+ else
+ return KErrGeneral;
+ }
+
+/**
+ * Function Name : TestGzgetsSmallBuf
+ * TestCase Description:
+ * 1. Gets from file into a small buffer
+ * 2. Checks whether returns the string correctly or not
+ */
+TInt CTestZlib::TestGzgetsSmallBuf()
+ {
+ const char hello[] = "hello, hello!\n";
+ int len;
+ char expBuf[100];
+ ReadIntParam (len);
+ ReadStringParam (expBuf);
+ gzFile file;
+ char *buf=(char *)malloc(strlen(hello));
+ file = gzopen ("c:\\file.gz", "w");
+ if ( file == NULL)
+ {
+ ERR_PRINTF1(_L("gzopen error"));
+ free (buf);
+ return KErrGeneral;
+ }
+ gzputs (file, hello);
+ gzclose (file);
+ file = gzopen ("c:\\file.gz", "r");
+ buf = gzgets (file, (char *)buf, len);
+ gzclose (file);
+
+ if ( !strcmp(buf,expBuf))
+ {
+ free (buf);
+ return KErrNone;
+ }
+ else
+ {
+ free (buf);
+ return KErrGeneral;
+ }
+ }