sl@0: /* sl@0: * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). sl@0: * All rights reserved. sl@0: * This component and the accompanying materials are made available sl@0: * under the terms of "Eclipse Public License v1.0" sl@0: * which accompanies this distribution, and is available sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: * sl@0: * Initial Contributors: sl@0: * Nokia Corporation - initial contribution. sl@0: * sl@0: * Contributors: sl@0: * sl@0: * Description: sl@0: * sl@0: */ sl@0: sl@0: sl@0: #include "tzlib.h" sl@0: sl@0: /** sl@0: * Function Name : TestAdlerinit sl@0: * TestCase Description: Testing Adler sl@0: * Return Value: Return KErrNone if adler32=1, else return KErrGeneral sl@0: */ sl@0: TInt CTestZlib::TestAdlerinit() sl@0: { sl@0: TInt res = KErrNone ; sl@0: unsigned long j=0L; sl@0: sl@0: long adler1 = adler32(j,0, 0); sl@0: if(adler1 == 1) sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestAdler sl@0: * TestCase Description: Testing Adler32 sl@0: * Return Value: Return KErrNone if adler32>0, else return KErrGeneral sl@0: */ sl@0: TInt CTestZlib::TestAdler() sl@0: { sl@0: TInt res = KErrNone ; sl@0: unsigned char buffer[5]="1234"; sl@0: unsigned int i=4; sl@0: unsigned long j=0L; sl@0: sl@0: long adler1 = adler32(j,0, 0); sl@0: long adler = adler32(adler1, &buffer[0], i); sl@0: INFO_PRINTF2(_L("buf %x"),adler); sl@0: sl@0: if(adler > 0) sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateReset sl@0: * TestCase Description: Call deflateReset after deflateInit sl@0: * Return Value: Returns KErrNone on deflateReset returning Z_OK, else KErrGeneral sl@0: */ sl@0: TInt CTestZlib::TestDeflateReset() sl@0: { sl@0: INFO_PRINTF1(_L("DeflateReset test with valid input")); sl@0: TInt res = KErrNone ; sl@0: int level = Z_DEFAULT_COMPRESSION ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: int err; sl@0: z_stream stream; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&stream, level); sl@0: if (err != Z_OK) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrGeneral; sl@0: } sl@0: sl@0: Bytef *dest = compr ; sl@0: uLongf *destLen = &comprLen; sl@0: const Bytef *source = (const Bytef*)hello; sl@0: uLong sourceLen = len; sl@0: sl@0: stream.next_in = (Bytef*)source; sl@0: stream.avail_in = (uInt)sourceLen; sl@0: #ifdef MAXSEG_64K sl@0: /* Check for source > 64K on 16-bit machine: */ sl@0: if ((uLong)stream.avail_in != sourceLen) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: #endif sl@0: stream.next_out = dest; sl@0: stream.avail_out = (uInt)*destLen; sl@0: if ((uLong)stream.avail_out != *destLen) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err=deflateReset(&stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: err = deflateEnd(&stream); sl@0: if (err != Z_OK) sl@0: { sl@0: INFO_PRINTF1(_L("Error in deflateEnd")); sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateReset_fail sl@0: * TestCase Description: Call deflateReset before calling deflateInit sl@0: * Return Value: Return KErrNone incase of deflateReset returning Z_STREAM_ERROR, else KErrGeneral sl@0: */ sl@0: TInt CTestZlib::TestDeflateReset_fail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: int err; sl@0: z_stream stream; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: err=deflateReset(&stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateInit2_bits sl@0: * TestCase Description: Call deflateInit2_ with window bits = 15 as argument sl@0: * Return Value: Return KErrNone if deflateInit2_ returns Z_OK sl@0: */ sl@0: TInt CTestZlib::TestDeflateInit2_bits() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: int level=Z_DEFAULT_COMPRESSION; sl@0: sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 10*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err= deflateInit2_(&stream, level, 3, 15, 8, 0, zlibVersion(), sizeof(z_stream)); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateInit2_level sl@0: * TestCase Description: Call deflateInit2_ with window bits = 2 as argument sl@0: * Return Value: Returns KErrNone on deflateInit2_ returning Z_OK sl@0: */ sl@0: TInt CTestZlib::TestDeflateInit2_level() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: int level=Z_DEFAULT_COMPRESSION; sl@0: sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 10*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err= deflateInit2_(&stream, level, 3, 2, 8, sl@0: 0, zlibVersion(), sizeof(z_stream)); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit2_bits sl@0: * TestCase Description: Call inflateInit2_ with window bits = 5 as argument sl@0: * Return Value: Returns KErrNone on inflateInit2_ returning Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateInit2_bits() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: version = zlibVersion(); sl@0: int ret = inflateInit2_(&d_stream,5,version, sizeof(d_stream)); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzread sl@0: * TestCase Description: 1. Open a gz file in read mode sl@0: * 2. gzRead from the opened file. Reads the given number of uncompressed bytes from the compressed file. sl@0: * 3. close the gz file sl@0: * Return Value: Returns KErrNone on reading the gzfile successfully sl@0: */ sl@0: TInt CTestZlib::TestGzread() sl@0: { sl@0: char * buf1 = (char*)malloc(1024); sl@0: if (buf1 == NULL) sl@0: { sl@0: ERR_PRINTF1(_L("Heap out of memory")); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int len1; sl@0: TInt res = KErrNone ; sl@0: char *file=FILETESTGZ; sl@0: char *infile; sl@0: gzFile in; sl@0: infile = file; sl@0: in = gzopen(infile, "rb"); sl@0: if (in == Z_NULL) sl@0: { sl@0: free(buf1); sl@0: ERR_PRINTF1(_L("Could not open the file")); sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: for (;;) sl@0: { sl@0: len1 = gzread(in, buf1, sizeof(buf1)); sl@0: if (len1 == 0 ) sl@0: break; sl@0: else if(len1 < 0 ) sl@0: { sl@0: INFO_PRINTF1(_L("Error in reading the file")); sl@0: free(buf1); sl@0: return KErrGeneral; sl@0: } sl@0: } sl@0: if (gzclose(in) != Z_OK) sl@0: { sl@0: ERR_PRINTF1(_L("Could not close the file")); sl@0: res=KErrGeneral; sl@0: } sl@0: free(buf1); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzread_fail sl@0: * TestCase Description: 1. Open a gz file in write mode sl@0: * 2. gzRead from the file. sl@0: * 3. close the file sl@0: * Return Value: Returns KErrNone on gzread returning -1 sl@0: */ sl@0: TInt CTestZlib::TestGzread_fail() sl@0: { sl@0: char * buf1 = (char*)malloc(1024); sl@0: if(buf1==NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: int len1; sl@0: TInt res = KErrNone ; sl@0: gzFile in = Z_NULL; sl@0: in = gzopen(FILETESTGZ1, "wb"); sl@0: res=(int)in; sl@0: if (0 == res) sl@0: { sl@0: free(buf1); sl@0: return KErrNoMemory;; sl@0: } sl@0: sl@0: len1 = gzread(in, buf1, sizeof(buf1)); sl@0: if (len1 < 0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else if (0 == len1) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: if (gzclose(in) != Z_OK) sl@0: { sl@0: free(buf1); sl@0: INFO_PRINTF1(_L("Error encountered while closing the file")); sl@0: return KErrGeneral; sl@0: } sl@0: sl@0: free(buf1); sl@0: return res; sl@0: } sl@0: /** sl@0: * Function Name : test_uncompress sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_uncompress(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: err = compress(compr, &comprLen, (const Bytef*)hello, len); sl@0: sl@0: if(err == 0) sl@0: { sl@0: strcpy((char*)uncompr, "garbage"); sl@0: err = uncompress(uncompr, &uncomprLen, compr, comprLen); sl@0: if(err < Z_OK) sl@0: { sl@0: res = KErrGeneral ; sl@0: } sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: /** sl@0: * Function Name : TestUncompress sl@0: * TestCase Description: 1. Compress a text sample sl@0: * 2. Uncompress is called with appropriate lengths sl@0: * for compressed and uncompressed data sl@0: * sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestUncompress() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = test_uncompress(compr, comprLen, uncompr, uncomprLen); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestUncompressfail sl@0: * TestCase Description: 1. Uncompress is called with uncompressed length smaller than required sl@0: * sl@0: * Return Value: Z_BUF_ERROR sl@0: */ sl@0: TInt CTestZlib::TestUncompressfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 1*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return Z_MEM_ERROR; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err = test_uncompress(compr, comprLen, uncompr, uncomprLen); sl@0: if(err==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : Test_dict_deflate sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt CTestZlib::Test_dict_deflate( Byte * compr,uLong comprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_BEST_COMPRESSION); sl@0: if(err<0) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: sl@0: err = deflateSetDictionary(&c_stream, sl@0: (const Bytef*)dictionary, sizeof(dictionary)); sl@0: if(err<0) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: dictId = c_stream.adler; sl@0: c_stream.next_out = compr; sl@0: c_stream.avail_out = (uInt)comprLen; sl@0: sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.avail_in = (uInt)strlen(hello)+1; sl@0: sl@0: err = deflate(&c_stream, Z_FINISH); sl@0: if (err != Z_STREAM_END) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err = deflateEnd(&c_stream); sl@0: if (err != 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : Test_dict_inflate sl@0: * TestCase Description: This is an utility function used by many test functions sl@0: */ sl@0: TInt CTestZlib::Test_dict_inflate(Byte * compr,uLong comprLen, Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = (uInt)comprLen; sl@0: sl@0: err = inflateInit(&d_stream); sl@0: if(Z_MEM_ERROR == err) sl@0: { sl@0: return Z_MEM_ERROR; sl@0: } sl@0: else if(Z_VERSION_ERROR == err) sl@0: { sl@0: return Z_VERSION_ERROR; sl@0: } sl@0: sl@0: d_stream.next_out = uncompr; sl@0: d_stream.avail_out = (uInt)uncomprLen; sl@0: sl@0: for (;;) sl@0: { sl@0: err = inflate(&d_stream, Z_NO_FLUSH); sl@0: if (err == Z_NEED_DICT) sl@0: { sl@0: if (d_stream.adler != dictId) sl@0: { sl@0: break; sl@0: } sl@0: err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary, sl@0: sizeof(dictionary)); sl@0: if(err < Z_OK) sl@0: { sl@0: INFO_PRINTF1(_L("Error returned by inflateSetDictionary")); sl@0: break; sl@0: } sl@0: } sl@0: else sl@0: { sl@0: break; sl@0: } sl@0: } // end of for sl@0: sl@0: err = inflateEnd(&d_stream); sl@0: if (strcmp((char*)uncompr, hello)) sl@0: { sl@0: INFO_PRINTF1(_L("Bad inflate with dictionary")); sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: INFO_PRINTF1(_L("Inflate with dictionary successful")); sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateSetDictionary sl@0: * TestCase Description: 1. Deflate string using an existing dictionary sl@0: * 2. Uncompress the compressed text using an existing dictionary sl@0: * Return Value: Z_BUF_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateSetDictionary() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 100*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_dict_deflate(compr, comprLen); sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: if(res==0) sl@0: { sl@0: res=Test_dict_inflate(compr, comprLen, uncompr, uncomprLen); sl@0: } sl@0: else sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestInflateSetDictionary_size sl@0: * TestCase Description: 1. Deflate string using an existing dictionary sl@0: * 2. Uncompress the compresses text using a mismatching dictionary sl@0: * Return Value: Z_DATA_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateSetDictionary_size() sl@0: { sl@0: sl@0: TInt res=KErrNone; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_dict_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: res=KErrGeneral; sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = (uInt)comprLen; sl@0: sl@0: int err = inflateInit(&d_stream); sl@0: sl@0: d_stream.next_out = uncompr; sl@0: d_stream.avail_out = (uInt)uncomprLen; sl@0: sl@0: for (;;) sl@0: { sl@0: int err = inflate(&d_stream, Z_NO_FLUSH); sl@0: if (err == Z_STREAM_END || err == Z_MEM_ERROR) break; sl@0: err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,sizeof(dictionary)+2); sl@0: if(Z_DATA_ERROR == err) sl@0: { sl@0: res=KErrNone; sl@0: break; sl@0: } sl@0: else sl@0: { sl@0: res=KErrGeneral; sl@0: break; sl@0: } sl@0: } sl@0: err = inflateEnd(&d_stream); sl@0: if(err != Z_OK) sl@0: { sl@0: INFO_PRINTF1(_L("InflateEnd failed")); sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateSetDictionary_null sl@0: * TestCase Description: 1. Deflate string using an existing dictionary sl@0: * 2. Pass null pointer to inflateSetDictionary sl@0: * Return Value: Z_DATA_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateSetDictionary_null() sl@0: { sl@0: TInt res=KErrNone; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res= Test_dict_deflate(compr, comprLen); sl@0: if(res == KErrGeneral) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: int err = inflateSetDictionary(NULL, (const Bytef*)dictionary,sizeof(dictionary)); sl@0: if(err != Z_STREAM_ERROR) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_compress sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_compress(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: int err = KErrNone; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: err = compress(compr, &comprLen, (const Bytef*)hello, len); sl@0: sl@0: if(err<0) sl@0: { sl@0: return err; sl@0: } sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: err = uncompress(uncompr, &uncomprLen, compr, comprLen); sl@0: sl@0: if(err<0) sl@0: { sl@0: return err; sl@0: } sl@0: if (strcmp((char*)uncompr, hello)) sl@0: { sl@0: //INFO_PRINTF1(_L("Uncompressed string does not match with original string")); sl@0: err = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: err=0; sl@0: } sl@0: return err; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_gzgets sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: int test_gzgets(const char * fname, Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: int err = KErrNone; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: err = KErrGeneral; sl@0: return err; sl@0: } sl@0: gzputc(file, 'h'); sl@0: if (gzputs(file, "ello") != 4) sl@0: { sl@0: err=1; sl@0: } sl@0: if (gzprintf(file, ", %s!", "hello") != 8) sl@0: { sl@0: err=1; sl@0: } sl@0: err = gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ sl@0: if (err < 0) sl@0: { sl@0: //INFO_PRINTF1(_L("Error returned by gzssek")); sl@0: } sl@0: gzclose(file); sl@0: sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: err = KErrGeneral; sl@0: return err; sl@0: } sl@0: strcpy((char*)uncompr, "garbage"); sl@0: if (gzread(file, uncompr, (unsigned)uncomprLen) != len) sl@0: { sl@0: } sl@0: if (strcmp((char*)uncompr, hello)) sl@0: { sl@0: err=0; sl@0: } sl@0: else sl@0: { sl@0: err=1; sl@0: } sl@0: sl@0: err = gzseek(file, -8L, SEEK_CUR); sl@0: if (err < 0) sl@0: { sl@0: //INFO_PRINTF1(_L("Error returned by gzssek")); sl@0: } sl@0: gzgets(file, (char*)uncompr, (int)uncomprLen); sl@0: sl@0: if (strlen((char*)uncompr) != 7) // " hello!" sl@0: { sl@0: err=0; sl@0: } sl@0: gzclose(file); sl@0: return err; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzgets sl@0: * TestCase Description: 1. Open a gz compressed file in read mode sl@0: * 2. Read certain valid number of bytes from the compressed file sl@0: * Return Value: Returns read buffer sl@0: */ sl@0: TInt CTestZlib::TestGzgets() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err=test_gzgets(MYFILE,uncompr, uncomprLen); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_gzgetsfail sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_gzgetsfail(const char * fname, Byte * uncompr,int uncomprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: char* err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err = gzgets(file, (char*)uncompr, uncomprLen); sl@0: sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: int err1= gzclose(file); sl@0: if (err1 != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestgzgetsFail sl@0: * TestCase Description: 1. Open a gz compressed file in read mode sl@0: * 2. Invalid number of bytes (negative number) for gzgets sl@0: * Return Value: Z_NULL sl@0: */ sl@0: TInt CTestZlib::TestgzgetsFail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: int ret= test_gzgetsfail(TESTFILE,uncompr, -1); sl@0: if(ret == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestgzgetsopenFail sl@0: * TestCase Description: 1. Open a gz compressed file in read mode sl@0: * 2. Invalid number of bytes (negative number) for gzgets sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestgzgetsopenFail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err = test_gzgetsfail(NOFILE,uncompr, uncomprLen); sl@0: sl@0: if(err != 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : Test_deflate sl@0: * TestCase Description: 1. Call deflateInit with valid arguments sl@0: * 2. Call deflate with necessary valid arguments sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::Test_deflate( Byte *compr, uLong comprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: sl@0: if(err<0) sl@0: { sl@0: return err; sl@0: } sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: } sl@0: /* Finish the stream, still forcing small buffers: */ sl@0: for (;;) sl@0: { sl@0: c_stream.avail_out = 1; sl@0: err = deflate(&c_stream, Z_FINISH); sl@0: if (err == Z_STREAM_END) break; sl@0: if(err!=Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: } sl@0: err = deflateEnd(&c_stream); sl@0: if(err!=Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestInflate sl@0: * TestCase Description: 1. Compress the data using deflate sl@0: * 2. inflateInit to initialize internal stream state for decompression sl@0: * 3. inflate with necessary valid arguments sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflate() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: // test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int err=0; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: sl@0: res = inflateInit(&d_stream); sl@0: sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) sl@0: { sl@0: d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ sl@0: err = inflate(&d_stream, Z_SYNC_FLUSH); sl@0: sl@0: if (err == Z_STREAM_END || err == Z_MEM_ERROR) break; sl@0: } sl@0: //inflate() should normally be called until it returns Z_STREAM_END sl@0: sl@0: if(err == Z_MEM_ERROR) sl@0: { sl@0: err = inflateEnd(&d_stream); sl@0: free(compr); sl@0: free(uncompr); sl@0: return err; sl@0: } sl@0: err = inflateEnd(&d_stream); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestInflate_fail1 sl@0: * TestCase Description: 1. Compress the data using deflate sl@0: * 2. inflateInit to initialize internal stream state for decompression sl@0: * 3. Set avail_in = 0 and call inflate sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflate_fail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: // test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int err; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = NULL; sl@0: sl@0: err = inflateInit(&d_stream); sl@0: sl@0: while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) sl@0: { sl@0: d_stream.avail_in = 0; sl@0: d_stream.avail_out = 1; /* force small buffers */ sl@0: err = inflate(&d_stream, Z_NO_FLUSH); sl@0: if (err == Z_STREAM_ERROR) break; sl@0: } sl@0: //inflate() should normally be called until it returns Z_STREAM_END sl@0: sl@0: err = inflateEnd(&d_stream); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflate_fail1 sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Call inflateInit to initialize internal stream state for decompression sl@0: * 3. Pass Z_NULL to inflate sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflate_fail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int err; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: sl@0: err = inflateInit(&d_stream); sl@0: sl@0: while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) sl@0: { sl@0: d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ sl@0: err = inflate(NULL, Z_NO_FLUSH); sl@0: if (err == Z_STREAM_ERROR) break; sl@0: } sl@0: //inflate() should normally be called until it returns Z_STREAM_END sl@0: err = inflateEnd(&d_stream); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflate_fail3 sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Call inflateInit to initialize internal stream state for decompression sl@0: * 3. Set avail_out = 0 and call inflate with necessary valid arguments sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflate_fail3() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int err; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = NULL; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: sl@0: err = inflateInit(&d_stream); sl@0: sl@0: while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) sl@0: { sl@0: d_stream.avail_in = 1; sl@0: d_stream.avail_out = 0; /* force small buffers */ sl@0: err = inflate(&d_stream, Z_NO_FLUSH); sl@0: if (err == Z_STREAM_ERROR) break; sl@0: } sl@0: //inflate() should normally be called until it returns Z_STREAM_END sl@0: sl@0: err = inflateEnd(&d_stream); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_compress_positive sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_compress_positive(Byte * compr,uLong comprLen,Byte * /*uncompr*/,uLong /*uncomprLen*/) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: err = compress(compr, &comprLen, (const Bytef*)hello, len); sl@0: if(err < 0) sl@0: { sl@0: res = KErrNoMemory; sl@0: } sl@0: sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_inflateend_positive sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_inflateend_positive(Byte * compr,uLong comprLen,Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: z_stream d_stream; // decompression stream sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: sl@0: err = inflateInit(&d_stream); sl@0: if(err <0) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) sl@0: { sl@0: d_stream.avail_in = d_stream.avail_out = 1; // force small buffers sl@0: err = inflate(&d_stream, Z_NO_FLUSH); sl@0: if (err == Z_STREAM_END) break; sl@0: if(err<0) break; sl@0: } sl@0: sl@0: err = inflateEnd(&d_stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone ; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestInflateend sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. inflate to decompress the data sl@0: * 3. inflateEnd sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateend() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res= test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = test_inflateend_positive(compr, comprLen, uncompr, uncomprLen); sl@0: if(res <0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: else if(res==0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateend_fail sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. inflate to decompress the data sl@0: * 3. Pass Z_NULL as argument to inflateEnd sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateend_fail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int ret= inflateEnd(NULL); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateReset sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Call inflateInit to initialize internal stream state for decompression sl@0: * 3. Call inflateReset with valid arguments sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateReset() sl@0: { sl@0: TInt res=KErrNone; sl@0: z_stream d_stream; /* decompression stream */ sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: int err; sl@0: err = inflateInit_(&d_stream,(char*)version, sizeof(d_stream)); sl@0: if(err<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: err=inflateReset(&d_stream); sl@0: if(err<0) sl@0: { sl@0: inflateEnd(&d_stream); sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: if(err!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: res=inflateEnd(&d_stream); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestInflateResetfail1 sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Call inflateInit to initialize internal stream state for decompression sl@0: * 3. Pass Z_NULL as argument to inflateReset sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateResetfail1() sl@0: { sl@0: TInt res=KErrNone; sl@0: z_stream d_stream; /* decompression stream */ sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: inflateInit_(&d_stream,(char*)version, sizeof(d_stream)); sl@0: res=inflateReset(NULL); sl@0: if(res!=Z_STREAM_ERROR) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: res=inflateEnd(&d_stream); sl@0: if(res!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit2_ sl@0: * TestCase Description: Test inflateInit2_ sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateInit2_() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: version = zlibVersion(); sl@0: TInt ret = inflateInit2_(&d_stream,15,version, sizeof(d_stream)); sl@0: if(ret==0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: return ret; sl@0: } sl@0: inflateEnd(&d_stream); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit_ sl@0: * TestCase Description: Test inflateInit_ sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateInit_() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res= test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: int ret = inflateInit_(&d_stream,(char*)version, sizeof(d_stream)); sl@0: if(ret==0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: inflateEnd(&d_stream); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit2_negative sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. inflateInit2_ with stream size less than required sl@0: * Return Value: Z_MEM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateInit2_negative() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: int ret = inflateInit2_(&d_stream, 15, version, sizeof(d_stream)-5); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: // inflateEnd(&d_stream); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit_negative sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Call inflateInit_ with stream size less than required sl@0: * Return Value: Z_MEM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestInflateInit_negative() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: int ret = inflateInit_(&d_stream,(char*)version, sizeof(d_stream) - 5); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: // inflateEnd(&d_stream); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit2_versioncheck sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. inflateInit2_ with valid zlib version as argument sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateInit2_versioncheck() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: INFO_PRINTF2(_L("Version : %d"),version); sl@0: int ret = inflateInit2_(&d_stream, 15, "1.2.4", sizeof(d_stream)-5); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestInflateInit_versioncheck sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. inflateInit_ with valid zlib version as argument sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestInflateInit_versioncheck() sl@0: { sl@0: TInt res = KErrNone ; sl@0: sl@0: z_stream d_stream; // decompression stream sl@0: const char * version; sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); // don't overflow on MSDOS sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_deflate(compr, comprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 0; sl@0: d_stream.next_out = uncompr; sl@0: version=zlibVersion(); sl@0: INFO_PRINTF2(_L("Version : %d"),version); sl@0: int ret = inflateInit_(&d_stream,(char*) "1.2.4", sizeof(d_stream) - 5); sl@0: if(ret==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCompress sl@0: * TestCase Description: Test compress() sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestCompress() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_compress_negative sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_compress_negative(Byte * compr,uLong comprLen,Byte * /*uncompr*/,uLong /*uncomprLen*/) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: err = compress(compr, &comprLen, (const Bytef*)hello, len); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCompress_negative sl@0: * TestCase Description: Call compress with compression length less than required sl@0: * Return Value: Z_BUF_ERROR sl@0: */ sl@0: TInt CTestZlib::TestCompress_negative() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 1*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=test_compress_negative(compr, comprLen, uncompr, uncomprLen); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCompress2_positive sl@0: * TestCase Description: Test compress2 with valid arguments sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestCompress2_positive() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: err=compress2(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION); sl@0: sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCompress2_negative sl@0: * TestCase Description: Test compress2 with compression length less than required sl@0: * Return Value: Z_BUF_ERROR sl@0: */ sl@0: TInt CTestZlib::TestCompress2_negative() sl@0: { sl@0: int err; sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: err=compress2(compr, &comprLen, (const Bytef*)hello, len,14); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : test_compressbound sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_compressbound(Byte * compr,uLong comprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: err=compress(compr, &comprLen, (const Bytef*)hello, sourceLen); sl@0: if(err==0) sl@0: { sl@0: int x = compressBound(sourceLen); sl@0: if(x > sourceLen) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCompressbound sl@0: * TestCase Description: 1. Call compress with appropriate arguments sl@0: * 2. Then verify the length of the compressed buffer using compressBound sl@0: * Return Value: Returns an upper bound on the compressed size after compression sl@0: * sl@0: */ sl@0: TInt CTestZlib::TestCompressbound() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr; sl@0: uLong comprLen =20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = test_compressbound(compr, comprLen); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : test_deflatebound sl@0: * TestCase Description: This is a global function used by many test functions sl@0: */ sl@0: TInt test_deflatebound(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: z_stream stream; sl@0: stream.next_in = (Bytef*)source; sl@0: stream.avail_in = (uInt)sourceLen; sl@0: stream.next_out = dest; sl@0: stream.avail_out = (uInt)*destLen; sl@0: if ((uLong)stream.avail_out != *destLen) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&stream, level); sl@0: if (err == Z_OK) sl@0: { sl@0: int y= deflateBound(&stream, sourceLen); sl@0: if(y > sourceLen) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: err=deflateEnd(&stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflatebound sl@0: * TestCase Description: 1. Compress the sample data using deflate sl@0: * 2. Then verify the length of the compressed buffer using deflateBound sl@0: * Return Value: Returns an upper bound on the compressed size after compression sl@0: */ sl@0: TInt CTestZlib::TestDeflatebound() sl@0: { sl@0: TInt res = KErrNone ; sl@0: sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if(uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=test_deflatebound(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateparams sl@0: * TestCase Description: 1. deflateInit to initialize the internal stream state for compression sl@0: * 2. deflateParams with valid compression level and strategy sl@0: * sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestDeflateparams() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err <0) sl@0: { sl@0: free(compr); sl@0: return err; sl@0: } sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: err= deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); sl@0: if(err != 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: deflateEnd(&c_stream); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateparamsfail1 sl@0: * TestCase Description: 1. deflateInit to initialize the internal stream state for compression sl@0: * 2. deflateParams with invalid compression level sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflateparamsfail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err<0) sl@0: { sl@0: free(compr); sl@0: return err; sl@0: } sl@0: sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: err= deflateParams(&c_stream, 12, Z_DEFAULT_STRATEGY); sl@0: if(err != 0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: deflateEnd(&c_stream); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateparamsfail2 sl@0: * TestCase Description: 1. deflateInit to initialize the internal stream state for compression sl@0: * 2. Pass NULL stream as argument to deflateParams sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflateparamsfail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err= deflateParams(NULL, 12, Z_DEFAULT_STRATEGY); sl@0: if(err != 0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCrcinit sl@0: * TestCase Description: Test crc32 with proper arguments sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestCrcinit() sl@0: { sl@0: TInt res = KErrNone ; sl@0: unsigned long j=0L; sl@0: long crc = crc32(j,0, 0); sl@0: sl@0: if(crc==0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestCrc sl@0: * TestCase Description: 1. Call crc32 with proper arguments sl@0: * 2. Call crc32 with with one of the arguments as an updated crc generated from previous call to crc32 sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestCrc() sl@0: { sl@0: TInt res = KErrNone ; sl@0: unsigned char buffer[5]="1234"; sl@0: unsigned int i=4; sl@0: unsigned long j=0L; sl@0: sl@0: long crc1 = crc32(j,0, 0); sl@0: sl@0: long crc = crc32(crc1, &buffer[0], i); sl@0: sl@0: INFO_PRINTF2(_L("buf %x"),crc); sl@0: sl@0: if(crc==(long)2615402659LL) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGet_crc_table sl@0: * TestCase Description: Test get_crc_table sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGet_crc_table() sl@0: { sl@0: TInt res = KErrNone ; sl@0: const unsigned long* pcrc_32_tab; sl@0: sl@0: pcrc_32_tab = get_crc_table(); sl@0: sl@0: if(pcrc_32_tab) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateInit_ sl@0: * TestCase Description: deflateInit_ with all valid arguments sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestDeflateInit_() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 10*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err= deflateInit_(&stream, Z_DEFAULT_COMPRESSION, zlibVersion(), sizeof(z_stream)); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: free(compr); sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: deflateEnd(&stream); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflateInit_level sl@0: * TestCase Description: deflateInit_ with invalid compression level sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflateInit_level() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 10*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err= deflateInit_(&stream, 11, zlibVersion(), sizeof(z_stream)); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestDeflateInit2_ sl@0: * TestCase Description: deflateInit2_ with invalid compression level sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflateInit2_() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: sl@0: uLong sourceLen = (uLong)strlen(hello)+1; sl@0: Byte *compr; sl@0: uLong comprLen = 10*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err= deflateInit2_(&stream, 11, 8, 15, 8, 0, zlibVersion(), sizeof(z_stream)); sl@0: sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: /** sl@0: * Function Name : TestDeflatefail sl@0: * TestCase Description: Set stream next_in and next_out to NULL and call deflateEnd sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflatefail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: res = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(res <0) sl@0: { sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: c_stream.next_in = NULL;//(Bytef*)hello; sl@0: c_stream.next_out = NULL;//compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone; sl@0: break; sl@0: } sl@0: } sl@0: /* Finish the stream, still forcing small buffers: */ sl@0: res = deflateEnd(&c_stream); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestDeflatefail sl@0: * TestCase Description: Set stream avail_out to NULL and call deflateEnd sl@0: * Return Value: Z_STREAM_ERROR sl@0: */ sl@0: TInt CTestZlib::TestDeflatefail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: sl@0: if(err <0) sl@0: { sl@0: free(compr); sl@0: return err; sl@0: } sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = 1; sl@0: c_stream.avail_out = 0; /* fail */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res=KErrNone; sl@0: break; sl@0: } sl@0: } sl@0: sl@0: err = deflateEnd(&c_stream); sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestZlibversion sl@0: * TestCase Description: Test Zlibversion sl@0: * Return Value: Z_OK sl@0: */ sl@0: TInt CTestZlib::TestZlibversion() sl@0: { sl@0: TInt res = KErrNone ; sl@0: if(strcmp(zlibVersion(), "1.2.3") != 0) sl@0: { sl@0: res=KErrGeneral; sl@0: ERR_PRINTF1(_L("using incorrect zlib version ")); sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzputc sl@0: * TestCase Description: 1. Open a gzfile in read mode sl@0: * 2. Write a character in the file using gzputc sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzputc() sl@0: { sl@0: TInt res = KErrNone ; sl@0: TInt res1 = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: else sl@0: { sl@0: res1=gzputc(file, 'r'); sl@0: if(res1<0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzopen sl@0: * TestCase Description: 1. Open a gzfile in read mode sl@0: * 2. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzopen() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: int err=gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzopenmode sl@0: * TestCase Description: 1. Open a gzfile mentioning invalid mode sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzopenmode() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "xyz"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzopenfail sl@0: * TestCase Description: Open a gzfile mentioning invalid path sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzopenfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = NOFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res =KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzputcfail sl@0: * TestCase Description: 1. Open a gzfile mentioning invalid path sl@0: * 2. Use gzputc to write a character sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzputcfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: TInt res1 = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = NOFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file != NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: else sl@0: { sl@0: res1=gzputc(file, 'r'); sl@0: if(res1<0) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzputcreturn sl@0: * TestCase Description: 1. Open a gzfile in write mode sl@0: * 2. Write a character in the file using gzputc sl@0: * 3. Verify the character written by comparing it with what is written sl@0: * 4. Close the file sl@0: * Return Value: returns the value of the character that was written sl@0: */ sl@0: TInt CTestZlib::TestGzputcreturn() sl@0: { sl@0: TInt res = KErrNone ; sl@0: TInt res1 = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: else sl@0: { sl@0: res1=gzputc(file, 'r'); sl@0: if(res1!=(int)'r') sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzputs sl@0: * TestCase Description: 1. Open a gzfile in write mode sl@0: * 2. Write a string into file sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzputs() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: if (gzputs(file, "ello") != 4) sl@0: { sl@0: ERR_PRINTF1(_L("gzputs err")); sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzputsfail sl@0: * TestCase Description: 1. Open a gzfile in read mode sl@0: * 2. Write a string into file sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzputsfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char *fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: if(gzputs(file, "ello") == 4) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzprintf sl@0: * TestCase Description: 1. Open a gzfile in write mode sl@0: * 2. Write a string into file mentioning the valid format specifier sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzprintf() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if(file == NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: if(gzprintf(file, ", %s!", "hello") != 8) sl@0: { sl@0: ERR_PRINTF1(_L("gzprintf err")); sl@0: return KErrNone; sl@0: } sl@0: sl@0: int err = gzclose(file); sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res =res= KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzprintf_trying sl@0: * TestCase Description: 1. Open a gzfile in read mode sl@0: * 2. Write a string into file mentioning the valid format specifier sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzprintf_trying() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: if (gzprintf(file, ", %s!", "hello") != 8) sl@0: { sl@0: gzclose(file); sl@0: res=KErrGeneral; sl@0: ERR_PRINTF1(_L("gzprintf err")); sl@0: return KErrNone; sl@0: } sl@0: int err = gzclose(file); sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzprintf_trying sl@0: * TestCase Description: 1. Open a gzfile in write mode sl@0: * 2. Write a string into file mentioning the valid arguments for gzwrite sl@0: * 3. Close the file sl@0: * Return Value: KErrNone sl@0: */ sl@0: TInt CTestZlib::TestGzwrite() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: uInt size ,len; sl@0: const char *s="ritesh"; sl@0: len=strlen(s); sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: size = gzwrite(file, (char*)s, (unsigned)strlen(s)); sl@0: if(len!=size) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: /** sl@0: * Function Name : TestGzwritefail sl@0: * TestCase Description: 1. Open a gzfile in read mode sl@0: * 2. Write a string into file mentioning the valid arguments for gzwrite sl@0: * 3. Close the file sl@0: * Return Value: Z_NULL sl@0: */ sl@0: TInt CTestZlib::TestGzwritefail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: uInt size ,len; sl@0: const char *s="ritesh"; sl@0: len=strlen(s); sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); //read mode sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: size = gzwrite(file, (char*)s, (unsigned)strlen(s)); sl@0: if(len!=size) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt testgztell( const char * fname, Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: int err=0; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: z_off_t pos; sl@0: sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: if (file == NULL) sl@0: { sl@0: err = KErrGeneral; sl@0: return err; sl@0: } sl@0: sl@0: } sl@0: gzputc(file, 'h'); sl@0: if(gzputs(file, "ello") != 4) sl@0: { sl@0: //fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err)); sl@0: } sl@0: if(gzprintf(file, ", %s!", "hello") != 8) sl@0: { sl@0: //fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err)); sl@0: } sl@0: gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ sl@0: gzclose(file); sl@0: sl@0: file = gzopen(fname, "rb"); sl@0: if(file == NULL) sl@0: { sl@0: err = KErrGeneral; sl@0: return err; sl@0: } sl@0: strcpy((char*)uncompr, "garbage"); sl@0: if(gzread(file, uncompr, (unsigned)uncomprLen) != len) sl@0: { sl@0: //fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); sl@0: //exit(1); sl@0: } sl@0: if(strcmp((char*)uncompr, hello)) sl@0: { sl@0: //fprintf(stderr, "bad gzread: %s\n", (char*)uncompr); sl@0: ////exit(1); sl@0: } sl@0: else sl@0: { sl@0: //printf("gzread(): %s\n", (char*)uncompr); sl@0: } sl@0: sl@0: pos = gzseek(file, -8L, SEEK_CUR); sl@0: if (pos != 6 || gztell(file) != pos) sl@0: { sl@0: err=-1; sl@0: } sl@0: err= gzclose(file); sl@0: return err; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGztell() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: int err = testgztell(TESTFILE,uncompr, uncomprLen); sl@0: if(err<0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGztell1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: gzFile file; sl@0: file = gzopen(TESTFILE, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: err=gztell(file) ; sl@0: if(err<0) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: err= gzclose(file); sl@0: if(err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGztellfail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: gzFile file; sl@0: file = gzopen(NOFILE, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrNone; sl@0: return res; sl@0: } sl@0: err=gztell(file) ; sl@0: if(err>0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: int test_deflatecopy (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: z_stream stream1; sl@0: int err; sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: stream.next_in = (Bytef*)source; sl@0: stream.avail_in = (uInt)sourceLen; sl@0: sl@0: stream.next_out = dest; sl@0: stream.avail_out = (uInt)*destLen; sl@0: if ((uLong)stream.avail_out != *destLen) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: err = deflateInit(&stream, level); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: err=deflateCopy(&stream1 , &stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err=deflateEnd(&stream); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err=deflateEnd(&stream1); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestDeflatecopy() sl@0: { sl@0: TInt res; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res= test_deflatecopy(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflatecopyfail() sl@0: { sl@0: TInt res = KErrNone ;int err; sl@0: z_stream stream1; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: Byte *compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: err=deflateCopy(&stream1 , NULL); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzclose() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: const char * fname = TESTFILE; sl@0: file = gzopen(fname, "wb"); sl@0: gzputc(file, 'h'); sl@0: sl@0: err= gzclose(file); sl@0: sl@0: if(err != 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzclose_fail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = NOFILE; sl@0: sl@0: file = gzopen(fname, "wb"); sl@0: sl@0: err=gzclose(file); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzeof() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: sl@0: if (gzputs(file, "ello") != 4) sl@0: { sl@0: ERR_PRINTF1(_L("gzputs err")); sl@0: return KErrNone; sl@0: } sl@0: int x=gzeof(file); sl@0: if(x!=0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzeoffail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: int x=gzeof(file); sl@0: if(x!=Z_STREAM_END) sl@0: { sl@0: res= KErrNone; sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzeoffail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = NOFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: int x=gzeof(file); sl@0: if(x!=0) sl@0: { sl@0: res= KErrNone; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzgetc() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: int l= gzgetc(file); sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzflush() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: int l= gzflush(file,Z_FULL_FLUSH); sl@0: if(l != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: int err=gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzflushsync() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: int l= gzflush(file,Z_SYNC_FLUSH); sl@0: if (l != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if(err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzflushfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: int l= gzflush(file,Z_FULL_FLUSH); sl@0: if (l == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzerror() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: gzputc(file, 'h'); sl@0: if (gzputs(file, "ello") != 5) sl@0: { sl@0: gzprintf(file, "gzputs err: %s\n", gzerror(file, &err)); sl@0: res=KErrGeneral; sl@0: } sl@0: err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzerrorfail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = NOFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file != NULL) sl@0: { sl@0: res=KErrGeneral; sl@0: return res; sl@0: } sl@0: gzputc(file, 'h'); sl@0: if (gzputs(file, "ello") != 5) sl@0: { sl@0: gzprintf(file, "gzputs err: %s\n", gzerror(file, &err)); sl@0: res=KErrNone; sl@0: } sl@0: err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzgetcfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == Z_NULL) sl@0: { sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: int l= gzgetc(file); sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflateSetDictionary() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res = test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: res=Test_dict_deflate(compr, comprLen); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflateSetDictionary_nodict() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_BEST_COMPRESSION); sl@0: if(err < 0) sl@0: { sl@0: return Z_MEM_ERROR; sl@0: } sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: err = deflateSetDictionary(&c_stream,NULL, sizeof(dictionary)); sl@0: if(err != 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err = deflateEnd(&c_stream); sl@0: if (err) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestDeflateSetDictionary_fail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res=test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: res = Test_dict_deflate(compr, comprLen); sl@0: if(res < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err = deflateSetDictionary(NULL,(const Bytef*)dictionary, sizeof(dictionary)); sl@0: if(err != 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflateend() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: err=test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if(err <0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return err; sl@0: } sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err <0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return err; sl@0: } sl@0: sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: } sl@0: /* Finish the stream, still forcing small buffers: */ sl@0: for (;;) sl@0: { sl@0: c_stream.avail_out = 1; sl@0: err = deflate(&c_stream, Z_FINISH); sl@0: if (err == Z_STREAM_END) break; sl@0: } sl@0: err = deflateEnd(&c_stream); sl@0: if (err) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflateendfail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err<0) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: } sl@0: sl@0: err = deflateEnd(&c_stream); sl@0: if (!err) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestDeflate() sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: Byte * compr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err <0) sl@0: { sl@0: free(compr); sl@0: return err; sl@0: } sl@0: sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: sl@0: while (c_stream.total_in != len && c_stream.total_out < comprLen) sl@0: { sl@0: c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ sl@0: err = deflate(&c_stream, Z_NO_FLUSH); sl@0: if(err != 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: } sl@0: sl@0: err = deflateEnd(&c_stream); sl@0: free(compr); sl@0: sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzseek() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err; sl@0: err = test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if (err < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: file = gzopen(TESTFILE, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: res = KErrNoMemory; sl@0: return res; sl@0: } sl@0: gzputc(file, 'h'); sl@0: if (gzputs(file, "ello") != 4) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: if (gzprintf(file, ", %s!", "hello") != 8) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: err= gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ sl@0: if(err<0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzseekfail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err; sl@0: err = test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if (err < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: file = gzopen(NOFILE, "wb"); sl@0: sl@0: err = gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ sl@0: if(err>=0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzseekfail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if(uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: int err; sl@0: err = test_compress(compr, comprLen, uncompr, uncomprLen); sl@0: if (err < 0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: file = gzopen(TESTFILE, "wb"); sl@0: sl@0: err = gzseek(file, -1L, SEEK_CUR); /* add one zero byte */ sl@0: if(err>=0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzsetparams() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE; sl@0: sl@0: file = gzopen(fname, "wb"); sl@0: gzputc(file, 'h'); sl@0: sl@0: int u = gzsetparams(file, Z_BEST_SPEED, Z_DEFAULT_STRATEGY); sl@0: if(u!=0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzsetparams_fail1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE; sl@0: file = gzopen(fname, "wb"); sl@0: gzputc(file, 'h'); sl@0: sl@0: int u = gzsetparams(file, Z_BEST_SPEED, -2); sl@0: if(u==0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzsetparams_fail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: const char * fname = TESTFILE; sl@0: file = gzopen(fname, "wb"); sl@0: gzputc(file, 'h'); sl@0: sl@0: int u = gzsetparams(file, -2, Z_DEFAULT_STRATEGY); sl@0: if(u==0) sl@0: { sl@0: res= KErrGeneral; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzsetparams_fail3() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE; sl@0: sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: return res; sl@0: } sl@0: gzputc(file, 'h'); sl@0: sl@0: int u = gzsetparams(file, Z_BEST_SPEED, Z_DEFAULT_STRATEGY); sl@0: if(u==0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzrewind() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: const char * fname = TESTFILE; sl@0: file = gzopen(fname, "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: gzputc(file, 'h'); sl@0: err = gzrewind(file); sl@0: if(err == 0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err = gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: sl@0: TInt CTestZlib::TestGzrewindfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: sl@0: const char * fname = TESTFILE; sl@0: file = gzopen(fname, "wb"); sl@0: if (file == NULL) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: gzputc(file, 'h'); sl@0: err = gzrewind(file); sl@0: if(err == 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: else sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestGzdopen() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: FILE* fp = fopen(fname, "rb"); sl@0: file = gzdopen(fileno(fp), "rb"); sl@0: if (file == NULL) sl@0: { sl@0: res = Z_MEM_ERROR; sl@0: fclose(fp); sl@0: return res; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err != Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: fclose(fp); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzdopen_fail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: FILE* fp = fopen(fname, "rb"); sl@0: file = gzdopen(fileno(fp), "xyz"); sl@0: if (file == NULL) sl@0: { sl@0: res=KErrNone; sl@0: fclose(fp); sl@0: return res; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: fclose(fp); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestGzdopen_fail2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: int len = (int)strlen(hello)+1; sl@0: gzFile file; sl@0: const char * fname = TESTFILE ; sl@0: FILE* fp = fopen(fname, "rb"); sl@0: file = gzdopen(-1, "xyz"); sl@0: if (file == NULL) sl@0: { sl@0: fclose(fp); sl@0: res=KErrNone; sl@0: return res; sl@0: } sl@0: int err= gzclose(file); sl@0: if (err == Z_OK) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: fclose(fp); sl@0: return res; sl@0: } sl@0: sl@0: /* =========================================================================== sl@0: * Test deflate() with full flush sl@0: */ sl@0: TInt CTestZlib::Test_flush( Byte * compr,uLong * comprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream c_stream; /* compression stream */ sl@0: int err; sl@0: uInt len = (uInt)strlen(hello)+1; sl@0: sl@0: c_stream.zalloc = (alloc_func)0; sl@0: c_stream.zfree = (free_func)0; sl@0: c_stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); sl@0: if(err<0) sl@0: { sl@0: return Z_MEM_ERROR; sl@0: } sl@0: sl@0: c_stream.next_in = (Bytef*)hello; sl@0: c_stream.next_out = compr; sl@0: c_stream.avail_in = 3; sl@0: c_stream.avail_out = (uInt)*comprLen; sl@0: err = deflate(&c_stream, Z_FULL_FLUSH); sl@0: sl@0: int h=inflateSyncPoint(&c_stream); sl@0: compr[3]++; /* force an error in first compressed block */ sl@0: c_stream.avail_in = len - 3; sl@0: sl@0: err = deflate(&c_stream, Z_FINISH); sl@0: if (err != Z_STREAM_END) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: err = deflateEnd(&c_stream); sl@0: if (err != 0) sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: *comprLen = c_stream.total_out; sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt test_sync(Byte * compr,uLong comprLen, Byte * uncompr,uLong uncomprLen) sl@0: { sl@0: TInt res = KErrNone ; sl@0: int err; sl@0: z_stream d_stream; /* decompression stream */ sl@0: sl@0: strcpy((char*)uncompr, "garbage"); sl@0: sl@0: d_stream.zalloc = (alloc_func)0; sl@0: d_stream.zfree = (free_func)0; sl@0: d_stream.opaque = (voidpf)0; sl@0: sl@0: d_stream.next_in = compr; sl@0: d_stream.avail_in = 2; /* just read the zlib header */ sl@0: sl@0: err = inflateInit(&d_stream); sl@0: if(err!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: d_stream.next_out = uncompr; sl@0: d_stream.avail_out = (uInt)uncomprLen; sl@0: sl@0: err= inflate(&d_stream, Z_NO_FLUSH); sl@0: if(err!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */ sl@0: err = inflateSync(&d_stream); /* but skip the damaged part */ sl@0: if(err!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: err = inflate(&d_stream, Z_FINISH); sl@0: if(err==0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: err = inflateEnd(&d_stream); sl@0: if(err!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestInflateSync() sl@0: { sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if(uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res= test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: Test_flush(compr, &comprLen); sl@0: res = test_sync(compr, comprLen, uncompr, uncomprLen); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestinflateSyncfail() sl@0: { sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: sl@0: res= test_compress_positive(compr, comprLen, uncompr, uncomprLen); sl@0: if(res<0) sl@0: { sl@0: free(compr); sl@0: free(uncompr); sl@0: return KErrNoMemory; sl@0: } sl@0: int err = test_sync(compr, comprLen, uncompr, uncomprLen); sl@0: if(err!=0) sl@0: { sl@0: res = KErrNone ; sl@0: } sl@0: else sl@0: { sl@0: res = KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: int test_syncpoint (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) sl@0: { sl@0: TInt res = KErrNone ; sl@0: z_stream stream; sl@0: int err; sl@0: sl@0: stream.next_in = (Bytef*)source; sl@0: stream.avail_in = (uInt)sourceLen; sl@0: stream.next_out = dest; sl@0: stream.avail_out = (uInt)*destLen; sl@0: sl@0: stream.zalloc = (alloc_func)0; sl@0: stream.zfree = (free_func)0; sl@0: stream.opaque = (voidpf)0; sl@0: sl@0: err = deflateInit(&stream, level); sl@0: if (err != Z_OK) return err; sl@0: sl@0: err = deflate(&stream, Z_FINISH); sl@0: if (err != Z_STREAM_END) sl@0: { sl@0: deflateEnd(&stream); sl@0: return err == Z_OK ? Z_BUF_ERROR : err; sl@0: } sl@0: *destLen = stream.total_out; sl@0: int h=inflateSyncPoint(&stream); sl@0: if(h!=0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: deflateEnd(&stream); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestInflateSyncPoint() sl@0: { sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: res= test_syncpoint(compr, &comprLen, (const Bytef*)hello, len,Z_DEFAULT_COMPRESSION); sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestInflateSyncPoint_null() sl@0: { sl@0: TInt res = KErrNone ; sl@0: uLong len = (uLong)strlen(hello)+1; sl@0: Byte *compr, *uncompr; sl@0: uLong comprLen = 20*sizeof(int); sl@0: uLong uncomprLen = comprLen; sl@0: compr = (Byte*)calloc((uInt)comprLen, 1); sl@0: if (compr == Z_NULL) sl@0: { sl@0: return KErrNoMemory; sl@0: } sl@0: uncompr = (Byte*)calloc((uInt)uncomprLen, 1); sl@0: if (uncompr == Z_NULL) sl@0: { sl@0: free(compr); sl@0: return KErrNoMemory; sl@0: } sl@0: int h=inflateSyncPoint(NULL); sl@0: if(h==0) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: free(compr); sl@0: free(uncompr); sl@0: return res; sl@0: } sl@0: sl@0: sl@0: TInt CTestZlib::TestZerror() sl@0: { sl@0: TInt res = KErrNone ; sl@0: const char * s = zError(1); sl@0: if(strcmp(s,"stream end")) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestZerror1() sl@0: { sl@0: TInt res = KErrNone ; sl@0: const char * s = zError(-3); sl@0: if(strcmp(s,"data error")) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: sl@0: TInt CTestZlib::TestZerror2() sl@0: { sl@0: TInt res = KErrNone ; sl@0: const char * s = zError(0); sl@0: if(strcmp(s,"")) sl@0: { sl@0: res=KErrGeneral; sl@0: } sl@0: sl@0: return res; sl@0: } sl@0: