// 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;
}
}