diff -r 000000000000 -r e4d67989cc36 compressionlibs/ziplib/test/tef/tlibz/src/tzlibcases.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/compressionlibs/ziplib/test/tef/tlibz/src/tzlibcases.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -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 "tzlib.h" +extern int errno; +#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 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