diff -r 000000000000 -r e4d67989cc36 compressionlibs/ziplib/test/tef/tlibz/src/tzlibadvanced.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/compressionlibs/ziplib/test/tef/tlibz/src/tzlibadvanced.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,2438 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Name : tzlibadvanced.cpp +// +// + +#include "tzlib.h" +#include "zutil.h" +//#include "deflate.h" + +#define COMPRESSED_DATA_BUFFER_LENGTH 200*sizeof(int) +#define FAILURE_RATE_LIMIT 100 +#define TEST_MID_MEM_LEVEL 5 + +// Add this to the windowBits value to use a GZip header instead of a Zlib header +#define TEST_GZIP_HEADER 16 + +// Add this to the windowBits when calling inflateInit2() to use automatic header detection +#define TEST_AUTO_HEADER_DETECTION 32 + +#define CHECK_CONDITION0L(condition, leaveErr, errMessage) \ + if (condition) \ + { \ + ERR_PRINTF1(_L(errMessage)); \ + User::Leave(leaveErr); \ + } + +#define CHECK_CONDITION1L(condition, leaveErr, errMessage, p1) \ + if (condition) \ + { \ + ERR_PRINTF2(_L(errMessage), p1); \ + User::Leave(leaveErr); \ + } + +_LIT(KParam1, "Param1"); +_LIT(KParam2, "Param2"); +_LIT(KParam3, "Param3"); +_LIT(KParam4, "Param4"); + +// bufferDescriptor holds extra information required by in_func and out_func to perform their jobs +struct bufferDescriptor + { + Byte *buffer; + int next; + int length; + }; + +/* + * Helper member function that sets up the deflate stream for use. + */ +void CTestZlib::DeflateInitL(z_stream &aStream, const int aLevel, const int expectedResult) + { + TInt err = Z_OK; + + aStream.zalloc = Z_NULL; + aStream.zfree = Z_NULL; + aStream.opaque = Z_NULL; + + err = deflateInit(&aStream, aLevel); + CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit error: %d", err); + } + +/* + * Helper member function that sets up the deflate stream for use. + */ +void CTestZlib::DeflateInit2L(z_stream &aStream, const int aLevel, const int aMethod, const int aWindowBits, const int aMemLevel, const int aStrategy, const int expectedResult) + { + int err; + + aStream.zalloc = Z_NULL; + aStream.zfree = Z_NULL; + aStream.opaque = Z_NULL; + + err = deflateInit2(&aStream, aLevel, aMethod, aWindowBits, aMemLevel, aStrategy); + CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "deflateInit2 error: %d", err); + } + +/* + * Helper member function that compresses data using the deflate function. + */ +TInt CTestZlib::DeflateCompress(z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength) + { + int err; + int flush; + + // Compress data in the input buffer and place compressed data in the output buffer + aStream.next_in = aInputData; + aStream.next_out = aCompressedDataBuffer; + + do + { + if (aStream.total_in < aInputDataLength) + { + aStream.avail_in = 1; // force small buffer + } + + flush = (aStream.total_in == aInputDataLength) ? Z_FINISH : Z_NO_FLUSH; + + // Run deflate() on input until output buffer not full + // Finish compression if all of input buffer has been read in + do + { + if (aStream.total_out < aCompressedDataBufferLength) + { + aStream.avail_out = 1; // force small buffer + } + + err = deflate(&aStream, flush); + if(err != Z_OK && err != Z_STREAM_END) + { + return err; + } + } while(aStream.avail_out == 0 && err == Z_OK); + } while(err != Z_STREAM_END); + + return Z_OK; + } + +/* + * Helper member function that cleans up a deflate stream. + */ +void CTestZlib::DeflateEnd(TAny *aStream) + { + if(((z_stream *)aStream)->state != NULL) + { + deflateEnd((z_stream *)aStream); + } + } + +/* + * Helper member function that sets up the inflate stream for use. + */ +void CTestZlib::InflateInitL(z_stream &aStream, const int expectedResult) + { + TInt err = Z_OK; + + aStream.zalloc = Z_NULL; + aStream.zfree = Z_NULL; + aStream.opaque = Z_NULL; + + err = inflateInit(&aStream); + CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit error: %d", err); + } + +/* + * Helper member function that sets up the inflate stream for use. + */ +void CTestZlib::InflateInit2L(z_stream &aStream, const int aWindowBits, const int expectedResult) + { + TInt err = Z_OK; + + aStream.zalloc = Z_NULL; + aStream.zfree = Z_NULL; + aStream.opaque = Z_NULL; + + err = inflateInit2(&aStream, aWindowBits); + CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateInit2 error: %d", err); + } + +void CTestZlib::InflateBackInitL(z_stream &aStream, const int aWindowBits, Bytef *aWindow, const int expectedResult) + { + int err; + + aStream.zalloc = Z_NULL; + aStream.zfree = Z_NULL; + aStream.opaque = Z_NULL; + + err = inflateBackInit(&aStream, aWindowBits, aWindow); + CHECK_CONDITION1L(err != expectedResult, KErrNoMemory, "inflateBackInit error: %d", err); + } + +/* + * Helper member function that decompresses data using the inflate function. + */ +TInt CTestZlib::InflateDecompress(z_stream &aStream, Byte *aCompressedDataBuffer, int aCompressedDataLength, Byte *aDecompressedDataBuffer, int aDecompressedDataBufferLength) + { + int err; + + // Decompress data in the aCompressedDataBuffer and place it in the aDecompressedDataBuffer + aStream.next_in = aCompressedDataBuffer; + aStream.next_out = aDecompressedDataBuffer; + + // Keep providing input data and output space for deflate() + do + { + if(aStream.total_in < aCompressedDataLength) + { + aStream.avail_in = 1; // force small buffer + } + + if (aStream.total_out < aDecompressedDataBufferLength) + { + aStream.avail_out = 1; // force small buffer + } + + err = inflate(&aStream, Z_NO_FLUSH); + if(err != Z_OK && err != Z_STREAM_END) + { + return err; + } + } while(err != Z_STREAM_END); + + return Z_OK; + } + +/* + * Helper member function that cleans up a inflate stream. + */ +void CTestZlib::InflateEnd(TAny *aStream) + { + if(((z_stream *)aStream)->state != NULL) + { + inflateEnd((z_stream *)aStream); + } + } + +/* + * Helper member function that cleans up an inflate back stream. + */ +void CTestZlib::InflateBackEnd(TAny *aStream) + { + if(((z_stream *)aStream)->state != NULL) + { + inflateBackEnd((z_stream *)aStream); + } + } + +/* + * Helper member function that compares the contents of two GZip headers to make + * sure they are the same. + */ +TBool CTestZlib::GZipHeadersEqual(const gz_header &header1, const gz_header &header2) + { + TBool headersEqual = true; + + if(header1.text != header2.text) + { + INFO_PRINTF3(_L("readGZipHeader.text - Expected %d and got %d"), header1.text, header2.text); + headersEqual = false; + } + + if(header1.time != header2.time) + { + INFO_PRINTF3(_L("readGZipHeader.time - Expected %d and got %d"), header1.time, header2.time); + headersEqual = false; + } + + if(header1.xflags != header2.xflags) + { + INFO_PRINTF3(_L("readGZipHeader.xflags - Expected %d and got %d"), header1.xflags, header2.xflags); + headersEqual = false; + } + + if(header1.os != header2.os) + { + INFO_PRINTF3(_L("readGZipHeader.os - Expected %d and got %d"), header1.os, header2.os); + headersEqual = false; + } + + if(header1.extra != NULL & header2.extra != NULL) + { + if(header1.extra_len != header2.extra_len) + { + INFO_PRINTF1(_L("readGZipHeader.extra_len - Unexpected value.")); + headersEqual = false; + } + else if(memcmp(header1.extra, header2.extra, header1.extra_len) != 0) + { + INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value.")); + headersEqual = false; + } + } + else if(header1.extra == NULL && header2.extra != NULL + || header1.extra != NULL && header2.extra == NULL) + { + INFO_PRINTF1(_L("readGZipHeader.extra - Unexpected value.")); + headersEqual = false; + } + + if(header1.name != NULL && header2.name != NULL) + { + if(strcmp((char *)header1.name, (char *)header2.name) != 0) + { + INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. The headers contained different strings.")); + headersEqual = false; + } + } + else if((header1.name == NULL && header2.name != NULL) + || (header1.name != NULL && header2.name == NULL)) + { + INFO_PRINTF1(_L("readGZipHeader.name - Unexpected value. One of the headers contained a NULL value.")); + headersEqual = false; + } + + if(header1.comment != NULL && header2.comment != NULL) + { + if(strcmp((char *)header1.comment, (char *)header2.comment) != 0) + { + INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. The headers contained different strings.")); + headersEqual = false; + } + } + else if((header1.comment == NULL && header2.comment != NULL) + || (header1.comment != NULL && header2.comment == NULL)) + { + INFO_PRINTF1(_L("readGZipHeader.comment - Unexpected value. One of the headers contained a NULL value.")); + headersEqual = false; + } + + if(header1.hcrc != header2.hcrc) + { + INFO_PRINTF3(_L("readGZipHeader.hcrc - Expected %d and got %d"), header1.hcrc, header2.hcrc); + headersEqual = false; + } + + if(header1.done != header2.done) + { + INFO_PRINTF3(_L("readGZipHeader.done - Expected %d and got %d"), header1.done, header2.done); + headersEqual = false; + } + + return headersEqual; + } + +/* + * Helper member function that checks to see if the header is the default GZip header + */ +TBool CTestZlib::IsDefaultGZipHeader(const gz_header &header) + { + gz_header defaultHeader; + + // gz_header default values + defaultHeader.text = 0; + defaultHeader.time = 0; + defaultHeader.xflags = 0; + defaultHeader.os = OS_CODE; + defaultHeader.extra = NULL; + defaultHeader.name = NULL; + defaultHeader.comment = NULL; + defaultHeader.hcrc = 0; + defaultHeader.done = 1; + + return GZipHeadersEqual(defaultHeader, header); + } + +/* + * Helper member function that compresses an input buffer and place it in a compressed output buffer + */ +void CTestZlib::CompressDataL(StreamSettings &aStreamSettings, z_stream &aStream, Byte *aInputData, int aInputDataLength, Byte *aCompressedDataBuffer, int aCompressedDataBufferLength, gz_headerp aHeader) + { + TInt err = Z_OK; + + // Initialise the deflate stream + if(aStreamSettings.deflateInit2 == false) + { + this->DeflateInitL(aStream, aStreamSettings.level); + } + else + { + this->DeflateInit2L(aStream, aStreamSettings.level, aStreamSettings.method, aStreamSettings.deflateWindowBits, aStreamSettings.memLevel, aStreamSettings.strategy); + } + CleanupStack::PushL(TCleanupItem(DeflateEnd, &aStream)); + + // If a GZip header is specified insert the gzip header information to the + // start of the output when deflate is called + if(aHeader != NULL) + { + err = deflateSetHeader(&aStream, aHeader); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateSetHeader error: %d", err); + } + + // Compress the input + err = this->DeflateCompress(aStream, aInputData, aInputDataLength, aCompressedDataBuffer, aCompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err); + + // Clean up the deflateStream + err = deflateEnd(&aStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + } + +/* + * Helper function that deflates some input data as a gzip stream and then inflates + * the compressed data. + */ +TVerdict CTestZlib::DefInfGZipHeaderL(const TBool aIgnoreHeader, const TBool aAutoDetectHeader, gz_headerp aSpecifiedGZipHeader) + { + int err = Z_OK; + TVerdict verdict = EPass; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Headers + gz_header readGZipHeader; + readGZipHeader.extra = NULL; + readGZipHeader.name = NULL; + readGZipHeader.comment = NULL; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; // data to compress + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateInit2 arguments + StreamSettings streamSettings; + streamSettings.deflateInit2 = true; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.method = Z_DEFLATED; + streamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER; + streamSettings.inflateWindowBits = MAX_WBITS; + streamSettings.memLevel = TEST_MID_MEM_LEVEL; + streamSettings.strategy = Z_DEFAULT_STRATEGY; + + streamSettings.inflateWindowBits += (aAutoDetectHeader == true) ? TEST_AUTO_HEADER_DETECTION : TEST_GZIP_HEADER; + + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + // Allocate memory, if required, for readGZipHeader if header data is being + // checked and if a specified GZip header has been given. This is because + // extra, name and comment may have been set in the specified GZip header. + if(aIgnoreHeader == false && aSpecifiedGZipHeader != NULL) + { + if(aSpecifiedGZipHeader->extra != NULL) + { + readGZipHeader.extra_max = aSpecifiedGZipHeader->extra_max; + readGZipHeader.extra = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->extra_max * sizeof(Bytef)); + CHECK_CONDITION0L(readGZipHeader.extra == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.extra."); + CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.extra)); + } + + if(aSpecifiedGZipHeader->name != NULL) + { + readGZipHeader.name_max = aSpecifiedGZipHeader->name_max; + readGZipHeader.name = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->name_max * sizeof(Bytef)); + CHECK_CONDITION0L(readGZipHeader.name == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.name."); + CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.name)); + } + + if(aSpecifiedGZipHeader->comment != NULL) + { + readGZipHeader.comm_max = aSpecifiedGZipHeader->comm_max; + readGZipHeader.comment = (Bytef *)User::AllocZ(aSpecifiedGZipHeader->comm_max * sizeof(Bytef)); + CHECK_CONDITION0L(readGZipHeader.comment == NULL, KErrNoMemory, "Failed to allocate memory for readGZipHeader.comment."); + CleanupStack::PushL(TCleanupItem(User::Free, readGZipHeader.comment)); + } + } + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength, aSpecifiedGZipHeader); + + // Initialise the inflateStream + this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + // If the header information is not to be ignored get the GZip + // header information when inflate is called + if(aIgnoreHeader == false) + { + err = inflateGetHeader(&inflateStream, &readGZipHeader); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateGetHeader error: %d", err); + } + + err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err); + + // Clean up the inflateStream + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err); + CleanupStack::Pop(1); + + // If the header information hasn't been ignored Check the GZip header + // contains the expected information + if(aIgnoreHeader == false) + { + if(aSpecifiedGZipHeader != NULL) + { + verdict = GZipHeadersEqual(*aSpecifiedGZipHeader, readGZipHeader) ? EPass : EFail; + } + else + { + verdict = IsDefaultGZipHeader(readGZipHeader) ? EPass : EFail; + } + } + + if(readGZipHeader.comment != NULL) + { + CleanupStack::PopAndDestroy(1); + } + + if(readGZipHeader.name != NULL) + { + CleanupStack::PopAndDestroy(1); + } + + if(readGZipHeader.extra != NULL) + { + CleanupStack::PopAndDestroy(1); + } + + // Free buffers + CleanupStack::PopAndDestroy(2); + + return verdict; + } + +/* + * Helper function that deflates some input data as a gzip stream with a specified header + * and then inflates the compressed data. + */ +TVerdict CTestZlib::DefInfGZipSpecifiedHeaderL(TBool aIgnoreHeader, TBool aAutoDetectHeader) + { + gz_header specifiedGZipHeader; + + Bytef extra[] = "12345"; + Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0"; + Bytef comment[] = "This is a test comment.\0"; + + // gz_header user specified values. Set the specifiedGZipHeader ready for deflateSetHeader + specifiedGZipHeader.text = 1; + specifiedGZipHeader.time = 101; + specifiedGZipHeader.xflags = 0; // Set so that the value can be compared to the value in the header read from the deflated data + specifiedGZipHeader.os = 1; // Amiga + specifiedGZipHeader.extra = extra; + specifiedGZipHeader.extra_len = TEST_MID_MEM_LEVEL; + specifiedGZipHeader.extra_max = specifiedGZipHeader.extra_len + 10; // Add extra 10 to check readGZipHeader.extra_len is set properly + specifiedGZipHeader.name = name; + specifiedGZipHeader.name_max = strlen((char *)name) + 1; + specifiedGZipHeader.comment = comment; + specifiedGZipHeader.comm_max = strlen((char *)comment) + 1; + specifiedGZipHeader.hcrc = 0; + specifiedGZipHeader.done = 1; // Finished reading header. Set so that the value can be compared to the value in the header read from the deflated data + + return DefInfGZipHeaderL(aIgnoreHeader, aAutoDetectHeader, &specifiedGZipHeader); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4259 +@SYMTestCaseDesc To ensure deflation works after tuning the deflate stream using + deflateTune(). +@SYMTestPriority Medium +@SYMTestActions 1. Create a stream and initialise it. + 2. Call deflateTune() passing it the specified parameters. + 3. Check the state of the stream to make sure that the values + are identical to the specified parameters. Also check that + Z_OK is returned. + 4. Deflate the input and cleanup using deflateEnd(), checking + Z_OK is returned. + + Note: The test should be repeated for deflateInit() parameter values: + • 3 and 4 for level + + and for deflateTune() parameter values: + • 0 and a high value for good_length + • 0 and a high value for max_lazy + • 0 and a high value for nice_length + • 0 and a high value for max_chain + Appropriate high values can be picked based on the global + configuration_table array in deflate.cpp. +@SYMTestExpectedResults deflateTune() should return Z_OK and the input should be compressed. +@SYMDEF REQ7362 +*/ +TVerdict CTestZlib::TestDeflateTuneL() + { + int err = Z_OK; + TBool ret; + + // Streams + z_stream deflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer; + + // deflateInit arguments + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + int level = Z_DEFAULT_COMPRESSION; + int goodLength = 0; + int maxLazy = 0; + int niceLength = 0; + int maxChain = 0; + + // Allocate memory for output buffer + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for output buffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + // Read in the values for deflate tune from the ini file + ret = GetIntFromConfig(ConfigSection(), KParam1, goodLength); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param1 from ini file"); + + ret = GetIntFromConfig(ConfigSection(), KParam2, maxLazy); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param2 from ini file"); + + ret = GetIntFromConfig(ConfigSection(), KParam3, niceLength); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param3 from ini file"); + + ret = GetIntFromConfig(ConfigSection(), KParam4, maxChain); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param4 from ini file"); + + // Initialise the stream + this->DeflateInitL(deflateStream, level); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream)); + + // Tune the deflate stream + err = deflateTune(&deflateStream, goodLength, maxLazy, niceLength, maxChain); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateTune error: %d", err); + + // Check deflateTune has set the streams state values correctly + /* + internal_state *s = deflateStream.state; + CHECK_CONDITION0L(s->good_match != goodLength || s->max_lazy_match != maxLazy || s->nice_match != niceLength || s->max_chain_length != maxChain, KErrGeneral, "deflateTune did not set the stream->state values correctly"); + */ + + err = this->DeflateCompress(deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err); + + // Clean up the deflate stream + err = deflateEnd(&deflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + + // Free buffer + CleanupStack::PopAndDestroy(1); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4260 +@SYMTestCaseDesc Check deflateTune() fails when given an invalid stream. +@SYMTestPriority Medium +@SYMTestActions 1. Create a stream and initialise it. + 2. Call deflateTune() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is NULL for the stream argument +@SYMTestExpectedResults deflateTune() fails returning Z_STREAM_ERROR in both cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDeflateTuneFailL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + + // deflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + + // Initialise the stream + this->DeflateInitL(deflateStream, level); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream)); + + // Try tuning a NULL deflate stream + err = deflateTune(NULL, 0, 0, 0, 0); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateTune on a NULL stream returned an unexpected value: %d", err); + + // Keep a pointer to the streams state so we can clean up properly with deflateEnd() + internal_state *deflateState = deflateStream.state; + + // Try tuning a deflate stream that has a NULL state + deflateStream.state = NULL; + err = deflateTune(&deflateStream, 0, 0, 0, 0); + deflateStream.state = deflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateTune on a stream with a NULL state returned an unexpected value: %d", err); + + // Clean up the deflate stream + err = deflateEnd(&deflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4261 +@SYMTestCaseDesc Check input can be compressed and decompressed with default gzip + header not being read. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + adding 16 to windowBits. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2(), + adding 16 to windowBits. + 4. Inflate the input and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and + decompressed with inflateEnd() returning Z_OK. There should be no + header information stored. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfGZipDefaultHeaderIgnoreL() + { + return DefInfGZipHeaderL(true, false, NULL); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4262 +@SYMTestCaseDesc Check input can be compressed and decompressed with default gzip + header being read using automatic header detection. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + adding 16 to windowBits. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2(), + adding 32 to windowBits. + 4. Use inflateGetHeader() to get the default header information + and make sure the gzip header information is set correctly. + 5. Inflate the input and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and + decompressed with inflateEnd() returning Z_OK. There should be + correct header information stored. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfGZipDefaultHeaderAutoL() + { + return DefInfGZipHeaderL(false, true, NULL); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4263 +@SYMTestCaseDesc Check input can be compressed and decompressed with specified gzip + header being read. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + adding 16 to windowBits. + 2. Use deflateSetHeader() to specify header information and check + that the gzip header information is set correctly. + 3. Deflate the input and cleanup using deflateEnd(). + 4. Create an inflate stream and initialise it using inflateInit2(), + adding 16 to windowBits. + 5. Use inflateGetHeader() to get the header information and make + sure that it matches the header information originally entered. + 6. Inflate the input and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and + the header details being set correctly. The data should also be + decompressed with inflateEnd() returning Z_OK and the header details + matching the original header information. There should also be header + information stored. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderManualL() + { + return DefInfGZipSpecifiedHeaderL(false, false); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4264 +@SYMTestCaseDesc Check input can be compressed and decompressed with specified gzip + header being read using automatic header detection. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + adding 16 to windowBits. + 2. Use deflateSetHeader() to specify header information and check + that the gzip header information is set correctly. + 3. Deflate the input and cleanup using deflateEnd(). + 4. Create an inflate stream and initialise it using inflateInit2(), + adding 32 to windowBits. + 5. Use inflateGetHeader() to get the header information and make + sure that it matches the header information originally entered. + 6. Inflate the input and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK and + the header details being set correctly. The data should also be + decompressed with inflateEnd() returning Z_OK and the header details + matching the original header information. There should also be header + information stored. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfGZipSpecifiedHeaderAutoL() + { + return DefInfGZipSpecifiedHeaderL(false, true); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4265 +@SYMTestCaseDesc Check input can be compressed and decompressed with zlib header + using automatic header detection. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2(), + adding 32 to windowBits. + 4. Inflate the input and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd() returning Z_OK + and decompressed with inflateEnd returning Z_OK. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfZlibHeaderAutoL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Stream settings + StreamSettings streamSettings; + streamSettings.deflateInit2 = false; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.inflateWindowBits = MAX_WBITS + TEST_AUTO_HEADER_DETECTION; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; // data to compress + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflateStream + this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err); + + // Clean up the inflateStream + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err); + CleanupStack::Pop(1); + + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4266 +@SYMTestCaseDesc Check deflateSetHeader() fails when given an invalid stream. +@SYMTestPriority High +@SYMTestActions 1. Create a stream and initialise it using deflateInit2(), adding + 16 to windowBits. + 2. Call deflateSetHeader() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is set to NULL for the stream argument + c. a zlib stream for the stream argument + d. a raw stream for the stream argument +@SYMTestExpectedResults deflateSetHeader() fails returning Z_STREAM_ERROR in all four cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDeflateSetHeaderFailsL() + { + int err; + + // Streams + z_stream gZipDeflateStream; + z_stream zLibDeflateStream; + z_stream rawDeflateStream; + + // GZip headers + gz_header specifiedGZipHeader; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + + // deflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + int method = Z_DEFLATED; + int gZipDeflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER; + int memLevel = TEST_MID_MEM_LEVEL; + int strategy = Z_DEFAULT_STRATEGY; + + // GZip header user specified values + Bytef extra[] = "12345"; + Bytef name[] = "TestDefInfGZipSpecifiedHeaderManual\0"; + Bytef comment[] = "This is a test comment.\0"; + + // Set the specifiedGZipHeader ready for deflateSetHeader + specifiedGZipHeader.text = 1; + specifiedGZipHeader.time = 101; + specifiedGZipHeader.os = 1; + specifiedGZipHeader.extra = extra; + specifiedGZipHeader.extra_len = 5; + specifiedGZipHeader.extra_max = specifiedGZipHeader.extra_len + 10; // Add extra 10 to check readGZipHeader.extra_len is set properly + specifiedGZipHeader.name = name; + specifiedGZipHeader.name_max = strlen((char *)name) + 1; + specifiedGZipHeader.comment = comment; + specifiedGZipHeader.comm_max = strlen((char *)comment) + 1; + specifiedGZipHeader.hcrc = 0; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + // Initialise the deflate streams + this->DeflateInit2L(gZipDeflateStream, level, method, gZipDeflateWindowBits, memLevel, strategy); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &gZipDeflateStream)); + + this->DeflateInitL(zLibDeflateStream, level); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &zLibDeflateStream)); + + this->DeflateInit2L(rawDeflateStream, level, method, -MAX_WBITS, memLevel, strategy); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &rawDeflateStream)); + + // Try setting a NULL streams header + err = deflateSetHeader(NULL, &specifiedGZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a NULL stream returned an unexpected value: %d", err); + + // Try setting the header for a deflate stream that has a NULL state + // we must keep a pointer to the streams state so we can clean up properly with deflateEnd + internal_state *deflateState = gZipDeflateStream.state; + gZipDeflateStream.state = NULL; + + err = deflateSetHeader(&gZipDeflateStream, &specifiedGZipHeader); + + gZipDeflateStream.state = deflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a stream with a NULL state returned an unexpected value: %d", err); + + // Try setting a header for a zlib stream + err = deflateSetHeader(&zLibDeflateStream, &specifiedGZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a zlib stream returned an unexpected value: %d", err); + + // Try setting a header for a raw stream + err = deflateSetHeader(&rawDeflateStream, &specifiedGZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflateSetHeader on a raw stream returned an unexpected value: %d", err); + + // Clean up the deflate streams + err = deflateEnd(&gZipDeflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "gZipDeflateStream - deflateEnd error: %d", err); + + err = deflateEnd(&zLibDeflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "zLibDeflateStream - deflateEnd error: %d", err); + + // deflateInit2() leaves a raw stream in a busy state. This results in deflateEnd() + // returning a Z_DATA_ERROR, unless deflate() has been called on the stream. + err = deflateEnd(&rawDeflateStream); + CHECK_CONDITION1L(err != Z_DATA_ERROR, KErrGeneral, "rawDeflateStream - deflateEnd error: %d", err); + + CleanupStack::Pop(3); + CleanupStack::PopAndDestroy(1); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4267 +@SYMTestCaseDesc Check inflateGetHeader() fails when given an invalid gzip stream. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), adding 16 to windowBits. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2(), adding 16 to windowBits. + 4. Call inflateGetHeader() passing it parameter values: + e. NULL for the stream argument + f. a stream whose state is set to NULL for the stream argument + g. a zlib stream for the stream argument + h. a raw stream for the stream argument +@SYMTestExpectedResults inflateGetHeader() should fail returning Z_STREAM_ERROR for the + first 2 cases and Z_DATA_ERROR for the second 2 case. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateGetHeaderFailsL() + { + int err = Z_OK; + + // Streams + z_stream gZipDeflateStream; + z_stream zLibDeflateStream; + z_stream rawDeflateStream; + z_stream gZipInflateStream; + z_stream zLibInflateStream; + z_stream rawInflateStream; + + // GZip headers + gz_header gZipHeader; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *gZipCompressedDataBuffer = NULL; + Byte *zLibCompressedDataBuffer = NULL; + Byte *rawCompressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + + // deflateInit2 and inflateInit2 arguments + StreamSettings gZipStreamSettings; + gZipStreamSettings.deflateInit2 = true; + gZipStreamSettings.level = Z_DEFAULT_COMPRESSION; + gZipStreamSettings.method = Z_DEFLATED; + gZipStreamSettings.deflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER; + gZipStreamSettings.inflateWindowBits = MAX_WBITS + TEST_GZIP_HEADER; + gZipStreamSettings.memLevel = TEST_MID_MEM_LEVEL; + gZipStreamSettings.strategy = Z_DEFAULT_STRATEGY; + + StreamSettings zLibStreamSettings; + zLibStreamSettings.deflateInit2 = false; + zLibStreamSettings.level = Z_DEFAULT_COMPRESSION; + + StreamSettings rawStreamSettings; + rawStreamSettings.deflateInit2 = true; + rawStreamSettings.level = Z_DEFAULT_COMPRESSION; + rawStreamSettings.method = Z_DEFLATED; + rawStreamSettings.deflateWindowBits = -MAX_WBITS; + rawStreamSettings.inflateWindowBits = -MAX_WBITS; + rawStreamSettings.memLevel = TEST_MID_MEM_LEVEL; + rawStreamSettings.strategy = Z_DEFAULT_STRATEGY; + + // Allocate memory for buffers + gZipCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(gZipCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for gZipCompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, gZipCompressedDataBuffer)); + + zLibCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(zLibCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for zLibCompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, zLibCompressedDataBuffer)); + + rawCompressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(rawCompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for rawCompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, rawCompressedDataBuffer)); + + // Compress data + INFO_PRINTF1(_L("Compress gzip:")); + this->CompressDataL(gZipStreamSettings, gZipDeflateStream, (Byte *)inputData, inputDataLength, gZipCompressedDataBuffer, compressedDataBufferLength); + INFO_PRINTF1(_L("Compress zlib:")); + this->CompressDataL(zLibStreamSettings, zLibDeflateStream, (Byte *)inputData, inputDataLength, zLibCompressedDataBuffer, compressedDataBufferLength); + INFO_PRINTF1(_L("Compress raw:")); + this->CompressDataL(rawStreamSettings, rawDeflateStream, (Byte *)inputData, inputDataLength, rawCompressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflateStreams + INFO_PRINTF1(_L("gZipInflateStream:")); + this->InflateInit2L(gZipInflateStream, gZipStreamSettings.inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &gZipInflateStream)); + + INFO_PRINTF1(_L("zLibInflateStream:")); + this->InflateInitL(zLibInflateStream); + CleanupStack::PushL(TCleanupItem(InflateEnd, &zLibInflateStream)); + + INFO_PRINTF1(_L("rawInflateStream:")); + this->InflateInit2L(rawInflateStream, rawStreamSettings.inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &rawInflateStream)); + + // Try and get header information from a NULL stream + err = inflateGetHeader(NULL, &gZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a NULL stream returned an unexpected value: %d", err); + + // Try getting the header for a deflate stream that has a NULL state + // we must keep a pointer to the streams state so we can clean up properly with deflateEnd + internal_state *deflateState = gZipDeflateStream.state; + gZipDeflateStream.state = NULL; + + err = inflateGetHeader(&gZipDeflateStream, &gZipHeader); + + gZipDeflateStream.state = deflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a stream with a NULL state returned an unexpected value: %d", err); + + // Try and get header information from a zlib stream + err = inflateGetHeader(&zLibDeflateStream, &gZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a zlib stream returned an unexpected value: %d", err); + + // Try and get header information from a raw stream + err = inflateGetHeader(&rawDeflateStream, &gZipHeader); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateGetHeader on a raw stream returned an unexpected value: %d", err); + + // Clean up the inflateStreams + err = inflateEnd(&gZipInflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "gZipInflateStream - inflateEnd error: %d", err); + + err = inflateEnd(&zLibInflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "zLibInflateStream - inflateEnd error: %d", err); + + err = inflateEnd(&rawInflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "rawInflateStream - inflateEnd error: %d", err); + + CleanupStack::Pop(3); + CleanupStack::PopAndDestroy(3); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4268 +@SYMTestCaseDesc Check output can be deflated in raw format and inflated. +@SYMTestPriority High +@SYMTestActions 1. Create a stream and initialise it using deflateInit2(), + setting windowBits between -8 and -15. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2(), + setting windowBits to be equal or less than the windowBits + value used for deflateInit2(). + 4. Inflate the input using inflate() and cleanup using inflateEnd(). +@SYMTestExpectedResults The data should be compressed with deflateEnd returning Z_OK and + decompressed with inflateEnd returning Z_OK. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfRawL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateInit2 arguments + StreamSettings streamSettings; + streamSettings.deflateInit2 = true; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.method = Z_DEFLATED; + streamSettings.deflateWindowBits = -MAX_WBITS; + streamSettings.inflateWindowBits = streamSettings.deflateWindowBits; + streamSettings.memLevel = TEST_MID_MEM_LEVEL; + streamSettings.strategy = Z_DEFAULT_STRATEGY; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflateStream + this->InflateInit2L(inflateStream, streamSettings.inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err); + + // Clean up the inflateStream + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err); + + CleanupStack::Pop(1); + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4269 +@SYMTestCaseDesc Check output is not generated in raw format when windowBits < -15 + or > -8. +@SYMTestPriority High +@SYMTestActions 1. Create a stream and initialise it using deflateInit2() passing + it the specified parameters. + + Note: The test should be repeated for deflateInit2() parameter values: + • < -15 and > -8 for windowBits +@SYMTestExpectedResults deflateInit2() should fail returning Z_STREAM_ERROR. Note: if + windowBits is set between 8-15 and 24-31 there will be no error + as the input will be deflated as a zlib/gzip stream. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefRawFailsL() + { + TBool ret; + + // Streams + z_stream deflateStream; + + // deflateInit2 and inflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + int method = Z_DEFLATED; + int deflateWindowBits; + int memLevel = TEST_MID_MEM_LEVEL; + int strategy = Z_DEFAULT_STRATEGY; + + // Read in the value for windowBits from the ini file + ret = GetIntFromConfig(ConfigSection(), KParam1, deflateWindowBits); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param1 from ini file"); + + // Initialise the deflate stream + this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy, Z_STREAM_ERROR); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4270 +@SYMTestCaseDesc Check raw input is not inflated when windowBits < -15 or > -8. +@SYMTestPriority High +@SYMTestActions 1. Create a stream and initialise it using deflateInit2(), + setting windowBits between -8 and -15. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit2() + passing it the specified parameters. + + Note: The test should be repeated for inflateInit2() parameter values: + • < -15, > -8 & < 8, >= 8 & <= 15 and >= 24 & <= 31 for windowBits + For cases >= 8 & <= 15 and >= 24 & <= 31 inflate the compressed data + and call inflateEnd() to clean up. +@SYMTestExpectedResults inflateInit2() should fail returning Z_STREAM_ERROR. Note: if + windowBits is set between 8-15 and 24-31 a Z_DATA_ERROR will be + given as it will inflate as a zlib/gzip stream. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDefInfRawFailsL() + { + int err = Z_OK; + TBool ret; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + int method = Z_DEFLATED; + int deflateWindowBits = -MAX_WBITS; + int inflateWindowBits; + int memLevel = TEST_MID_MEM_LEVEL; + int strategy = Z_DEFAULT_STRATEGY; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + // Read in the value for windowBits from the ini file + ret = GetIntFromConfig(ConfigSection(), KParam1, inflateWindowBits); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param1 from ini file"); + + // Initialise the deflate stream + this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream)); + + // Compress the input + err = this->DeflateCompress(deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + CHECK_CONDITION1L(err!= Z_OK, KErrGeneral, "deflate error: %d", err); + + // Clean up the deflate stream + err = deflateEnd(&deflateStream); + CHECK_CONDITION1L(err!= Z_OK, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + + // Initialise the inflateStream + // If windowBits are used that specify a zlib or gzip stream we get a different error + if((inflateWindowBits >= 8 && inflateWindowBits <= 15) || (inflateWindowBits >= 24 && inflateWindowBits <= 31)) + { + this->InflateInit2L(inflateStream, inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength); + CHECK_CONDITION1L(err!= Z_DATA_ERROR, KErrGeneral, "inflate error: %d", err); + + // Clean up the inflateStream + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err!= Z_OK, KErrGeneral, "inflateEnd error: %d", err); + CleanupStack::Pop(1); + } + else + { + this->InflateInit2L(inflateStream, inflateWindowBits, Z_STREAM_ERROR); + } + + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4271 +@SYMTestCaseDesc To check the specified bits are added to the start of a raw stream + correctly using deflatePrime(). +@SYMTestPriority Low +@SYMTestActions 1. Create a stream and initialise it using deflateInit2(), setting + windowBits between -8 and -15. + 2. Call deflatePrime() passing it the specified parameters. + 3. Deflate the input and cleanup using deflateEnd(). + 4. Check the bits at the front of the output are the expected ones. + + Note: The test should be repeated for deflatePrime() parameter values: + • 0, 8 and 16 for bits + • 0, 216 and a number between 0 - 216 for value +@SYMTestExpectedResults deflatePrime() should return Z_OK and the bits at the front of the + output are the expected ones. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDeflatePrimeL() + { + int err = Z_OK; + TBool ret; + + // Streams + z_stream deflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + + // deflateInit2 and inflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + int method = Z_DEFLATED; + int deflateWindowBits = -MAX_WBITS; + int memLevel = TEST_MID_MEM_LEVEL; + int strategy = Z_DEFAULT_STRATEGY; + + // deflatePrime arguments + int bits; + int value; + + // Bits added to the start of the compressed stream + Byte bit1 = 0; + Byte bit2 = 0; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + // Read in the values for bits and value from the ini file + ret = GetIntFromConfig(ConfigSection(), KParam1, bits); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param1 from ini file."); + + ret = GetIntFromConfig(ConfigSection(), KParam2, value); + CHECK_CONDITION0L(!ret, KErrGeneral, "Failed to read Param2 from ini file."); + + // Initialise the deflate stream + this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream)); + + // Call deflatePrime on the stream + err = deflatePrime(&deflateStream, bits, value); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflatePrime error: %d", err); + + // Compress the input + err = this->DeflateCompress(deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflate error: %d", err); + + // Clean up the deflate stream + err = deflateEnd(&deflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + + // Check the bits at the start of the compressed data are the same as intended + // when using deflatePrime() + switch(bits) + { + case 16: + bit1 = value & 0xFF; + bit2 = (value >> 8) & 0xFF; + break; + case 8: + bit1 = value & 0xFF; + bit2 = compressedDataBuffer[1]; + break; + case 0: + bit1 = compressedDataBuffer[0]; + bit2 = compressedDataBuffer[1]; + break; + default: + INFO_PRINTF1(_L("The test only works with bits set to 0, 8 or 16.")); + User::Leave(KErrGeneral); + } + CHECK_CONDITION0L(compressedDataBuffer[0] != bit1 || compressedDataBuffer[1] != bit2, KErrGeneral, "The bits at the start of the compressed data buffer do not match the specified bits in deflatePrime."); + + CleanupStack::PopAndDestroy(1); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4272 +@SYMTestCaseDesc Check deflatePrime() fails when given an invalid stream. +@SYMTestPriority Medium +@SYMTestActions 1. Create a stream and initialise it using deflateInit2(), + setting windowBits between -8 and -15. + 2. Call deflatePrime() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is NULL for the stream argument +@SYMTestExpectedResults deflatePrime() fails returning Z_STREAM_ERROR in both cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestDeflatePrimeFailsL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + + // deflateInit2 and inflateInit2 arguments + int level = Z_DEFAULT_COMPRESSION; + int method = Z_DEFLATED; + int deflateWindowBits = -MAX_WBITS; + int memLevel = TEST_MID_MEM_LEVEL; + int strategy = Z_DEFAULT_STRATEGY; + + // deflatePrime arguments + int bits = 0; + int value = 0; + + // Initialise the deflate stream + this->DeflateInit2L(deflateStream, level, method, deflateWindowBits, memLevel, strategy); + CleanupStack::PushL(TCleanupItem(DeflateEnd, &deflateStream)); + + // Call deflatePrime on a NULL stream + err = deflatePrime(NULL, bits, value); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflatePrime on a NULL stream returned an unexpected value: %d", err); + + // Try calling deflatePrime on a deflate stream that has a NULL state + // We must keep a pointer to the streams state so we can clean up properly with deflateEnd + internal_state *deflateState = deflateStream.state; + deflateStream.state = NULL; + + err = deflatePrime(&deflateStream, bits, value); + + deflateStream.state = deflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "deflatePrime on a stream with a NULL state returned an unexpected value: %d", err); + + // deflateInit2() leaves a raw stream in a busy state. This results in deflateEnd() + // returning a Z_DATA_ERROR, unless deflate() has been called on the stream, + // meaning we have to set err back to Z_OK for the test to pass + err = deflateEnd(&deflateStream); + CHECK_CONDITION1L(err != Z_DATA_ERROR, KErrGeneral, "deflateEnd error: %d", err); + CleanupStack::Pop(1); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4274 +@SYMTestCaseDesc Check inflatePrime() fails when given an invalid stream or parameters. +@SYMTestPriority Medium +@SYMTestActions 1. Create an inflate stream and initialise it using inflateInit2(), + setting windowBits to be equal or less than the windowBits value + used for deflateInit2(). + 2. Call inflatePrime() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is NULL for the stream argument + c. > 16 for bits + d. (32 – stream->bits) for bits +@SYMTestExpectedResults inflatePrime() fails returning Z_STREAM_ERROR in all cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflatePrimeFailsL() + { + int err = Z_OK; + + // Streams + z_stream inflateStream; + + // inflateInit2 argument + int inflateWindowBits = -MAX_WBITS; + + // deflatePrime arguments + int bits = 0; + int value = 0; + + // Initialise the inflate stream + this->InflateInit2L(inflateStream, inflateWindowBits); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + // Call inflatePrime on a NULL stream + err = inflatePrime(NULL, bits, value); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime on a NULL stream returned an unexpected value: %d", err); + + // Try calling inflatePrime on a deflate stream that has a NULL state + // We must keep a pointer to the streams state so we can clean up properly with deflateEnd + struct internal_state FAR *inflateState = inflateStream.state; + inflateStream.state = NULL; + + err = inflatePrime(&inflateStream, bits, value); + + inflateStream.state = inflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime on a stream with a NULL state returned an unexpected value: %d", err); + + // Call inflatePrime with bits > 16 + err = inflatePrime(&inflateStream, 17, value); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime using bits > 16 returned an unexpected value: %d", err); + + // Call inflatePrime with inflateStream->state->bits + bits > 32 + // This test cannot be implemented due to inflate_state requiring the definition for + // the code struct which is in a header file that is included by one of the zlib + // cpp files. + /* + inflateState = inflateStream.state; + inflateState->bits(33 - bits); + err = inflatePrime(&inflateStream, bits, value); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflatePrime, setting inflateStream->state->bits, returned an unexpected value: %d", err); + */ + + // Clean up the inflate stream + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateEnd error: %d", err); + CleanupStack::Pop(1); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4275 +@SYMTestCaseDesc Check that a stream is duplicated correctly when using inflateCopy(). +@SYMTestPriority High +@SYMTestActions 1. Create a stream and initialise it using deflateInit(). + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using inflateInit(). + 4. Create a second inflate stream and copy the first stream to the + second stream using inflateCopy(). + 5. Call inflate() and inflateEnd() on both streams. + 6. Compare the output of both streams. +@SYMTestExpectedResults inflateCopy() should return Z_OK and the output of both streams will + be identical. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateCopyL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + z_stream inflateStreamCopy; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + Byte *copiedDecompressedDataBuffer = NULL; + uLong copiedDecompressedDataBufferLength = decompressedDataBufferLength; + + // deflateInit argument + StreamSettings streamSettings; + streamSettings.deflateInit2 = false; + streamSettings.level = Z_DEFAULT_COMPRESSION; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + copiedDecompressedDataBuffer = (Byte *)User::AllocZ(copiedDecompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(copiedDecompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for copiedDecompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, copiedDecompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflate streams + this->InflateInitL(inflateStream); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + // Copy the inflateStream + err = inflateCopy(&inflateStreamCopy, &inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrNoMemory, "inflateCopy error: %d", err); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStreamCopy)); + + // Decompress the data in the compressedDataBuffer + err = this->InflateDecompress(inflateStream, compressedDataBuffer, deflateStream.total_out, decompressedDataBuffer, decompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err); + + // Decompress the data in the copiedDecompressedDataBuffer + err = this->InflateDecompress(inflateStreamCopy, compressedDataBuffer, deflateStream.total_out, copiedDecompressedDataBuffer, copiedDecompressedDataBufferLength); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflate error: %d", err); + + // Clean up the inflate streams + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateStream - inflateEnd error: %d", err); + + err = inflateEnd(&inflateStreamCopy); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateStreamCopy - inflateEnd error: %d", err); + CleanupStack::Pop(2); + + // Check that both inflate streams produced identical output + CHECK_CONDITION0L(memcmp((char *)copiedDecompressedDataBuffer, (char *)decompressedDataBuffer, decompressedDataBufferLength) != 0, KErrGeneral, "The copied stream did not produce the same decompressed output as the original stream."); + + CleanupStack::PopAndDestroy(3); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4276 +@SYMTestCaseDesc Check inflateCopy() fails when given an invalid stream or parameters. +@SYMTestPriority High +@SYMTestActions 1. Create an inflate stream and initialise it using inflateInit(). + 2. Create a second inflate stream and call inflateCopy() passing + it parameter values: + a. NULL for the dest stream argument + b. NULL for the source stream argument + c. a stream whose state is NULL for the source stream argument + d. a stream whose zalloc is Z_NULL for the source stream argument + e. a stream whose zfree is Z_NULL for the source stream argument +@SYMTestExpectedResults inflateCopy() fails returning Z_STREAM_ERROR in all cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateCopyFailsParamsL() + { + int err = Z_OK; + + // Streams + z_stream inflateStream; + z_stream inflateStreamCopy; + + // Initialise the inflate streams + this->InflateInitL(inflateStream); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + // Try to copy from a NULL stream + err = inflateCopy(&inflateStreamCopy, NULL); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a NULL stream returned an unexpected value: %d", err); + + // Try to copy to a NULL stream + err = inflateCopy(NULL, &inflateStream); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy to a NULL stream returned an unexpected value: %d", err); + + // Try calling deflateCopy on a deflate stream that has a NULL state + // We must keep a pointer to the streams state so we can clean up properly with deflateEnd + struct internal_state FAR *state = inflateStream.state; + inflateStream.state = NULL; + + err = inflateCopy(&inflateStreamCopy, &inflateStream); + + inflateStream.state = state; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream whose state is NULL returned an unexpected value: %d", err); + + // Try to copy from a stream with zalloc set to Z_NULL + inflateStream.zalloc = Z_NULL; + err = inflateCopy(&inflateStreamCopy, &inflateStream); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream with zalloc set to NULL returned an unexpected value: %d", err); + + // Try to copy from a stream with zfree set to Z_NULL + free_func zfree = inflateStream.zfree; + inflateStream.zfree = Z_NULL; + + err = inflateCopy(&inflateStreamCopy, &inflateStream); + + inflateStream.zfree = zfree; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "inflateCopy from a stream with zfree set to NULL returned an unexpected value: %d", err); + + // Clean up the inflate streams + err = inflateEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateStream - inflateEnd error: %d", err); + CleanupStack::Pop(1); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4277 +@SYMTestCaseDesc Check inflateCopy() fails when there is not enough memory to copy + the stream. +@SYMTestPriority High +@SYMTestActions 1. Create an inflate stream and initialise it using inflateInit(). + 2. Create a second inflate stream and set memory allocation to + fail on the first attempt. + 3. Copy the first stream to the second stream using inflateCopy(). + 4. Check that the memory is the same before and after calling + inflateCopy(). Note: If Z_OK is returned it will be necessary + to call inflateEnd() before checking the amount of memory. + 5. Repeat this process until inflateCopy() returns Z_OK, increasing + the number of allocations that can be performed before failing. +@SYMTestExpectedResults inflateCopy() fails at first, returning Z_MEM_ERROR, and then it + will succeed with Z_OK. No memory should be leaked. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateCopyFailsMemL() + { + int err; + TVerdict verdict = EPass; + + // Streams + z_stream inflateStream; + z_stream inflateStreamCopy; + + // Initialise the inflate streams + this->InflateInitL(inflateStream); + CleanupStack::PushL(TCleanupItem(InflateEnd, &inflateStream)); + + TInt failureRate; + for(failureRate = 1, err = Z_MEM_ERROR; err != Z_OK && failureRate <= FAILURE_RATE_LIMIT; failureRate++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic, failureRate); + __UHEAP_MARK; + + // Copy the inflateStream + err = inflateCopy(&inflateStreamCopy, &inflateStream); + + // Memory has been allocated so we need to clean up + if(err == Z_OK) + { + err = inflateEnd(&inflateStreamCopy); + if(err != Z_OK) + { + INFO_PRINTF2(_L("inflateStreamCopy - inflateEnd error: %d"), err); + verdict = EAbort; + break; + } + } + else if(err != Z_MEM_ERROR) + { + INFO_PRINTF2(_L("inflateStreamCopy - unexpected error: %d"), err); + verdict = EFail; + break; + } + + __UHEAP_MARKEND; + __UHEAP_RESET; + } + + if(err == Z_OK) + { + INFO_PRINTF2(_L("The test succeeded at heap failure rate = %d."), --failureRate); + } + else if(failureRate > FAILURE_RATE_LIMIT) + { + INFO_PRINTF1(_L("Exceeded FAILURE_RATE_LIMIT. Either the test has failed or the limit needs increasing.")); + verdict = EFail; + } + + CleanupStack::PopAndDestroy(1); + + return verdict; + } + +/* + * in function required by inflateBack. + * Provides a pointer to the next piece of input data and returns the length of the data + */ +unsigned in OF((void FAR *in_desc, unsigned char FAR * FAR *in_buf)) + { + struct bufferDescriptor *compressedDataBufferDescriptor = (struct bufferDescriptor *)in_desc; + *in_buf = &compressedDataBufferDescriptor->buffer[compressedDataBufferDescriptor->next]; + + // Check that there is more input + if(compressedDataBufferDescriptor->next + 1 < compressedDataBufferDescriptor->length) + { + compressedDataBufferDescriptor->next++; + return 1; + } + + return 0; + } + +/* + * out function required by inflateBack. + * Provides a pointer to which the next space in memory data can be output and returns the length of this space + */ +int out OF((void FAR *out_desc, unsigned char FAR *out_buf, unsigned len)) + { + struct bufferDescriptor *decompressedDataBufferDescriptor = (struct bufferDescriptor *)out_desc; + + // Make sure there is output space + if(decompressedDataBufferDescriptor->next + len <= decompressedDataBufferDescriptor->length) + { + memcpy(decompressedDataBufferDescriptor->buffer + decompressedDataBufferDescriptor->next, out_buf, len); + decompressedDataBufferDescriptor->next += len; + } + else + { + int leftOver = decompressedDataBufferDescriptor->length - decompressedDataBufferDescriptor->next; + memcpy(decompressedDataBufferDescriptor->buffer + decompressedDataBufferDescriptor->next, out_buf, leftOver); + } + + return 0; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4278 +@SYMTestCaseDesc Check a stream can be inflated using inflateBackInit(), + inflateBack() and inflateBackEnd(). +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + setting windowBits between -8 and -15. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using + inflateBackInit() setting windowBits to be equal to or greater + than the windowBits value used for deflateInit2(). + 4. Call inflateBack() to uncompress the stream and call + inflateBackEnd() to clean up. + 5. Compare the original stream with the uncompressed stream. +@SYMTestExpectedResults inflateBackInit() and inflateBackEnd() should both return Z_OK. + inflateBack() should return Z_STREAM_END when it has finished + inflating the input stream. The original stream should be + identical to the final uncompressed stream. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateBackL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateBackInit arguments + StreamSettings streamSettings; + streamSettings.deflateInit2 = true; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.method = Z_DEFLATED; + streamSettings.deflateWindowBits = -MAX_WBITS; + streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits; + streamSettings.memLevel = TEST_MID_MEM_LEVEL; + streamSettings.strategy = Z_DEFAULT_STRATEGY; + Bytef inflateWindow[32 * 1024]; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflate stream + InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow); + CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream)); + + // This must be set to NULL otherwise inflateBack will assume there is input and try to decompress it + inflateStream.next_in = NULL; + + struct bufferDescriptor compressedDataBufferDescriptor; + compressedDataBufferDescriptor.buffer = compressedDataBuffer; + compressedDataBufferDescriptor.next = 0; + compressedDataBufferDescriptor.length = compressedDataBufferLength; + + struct bufferDescriptor decompressedDataBufferDescriptor; + decompressedDataBufferDescriptor.buffer = decompressedDataBuffer; + decompressedDataBufferDescriptor.next = 0; + decompressedDataBufferDescriptor.length = decompressedDataBufferLength; + + // Decompress the input + err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_STREAM_END, KErrGeneral, "inflateBack error: %d", err); + + // Clean up the inflate stream + err = inflateBackEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateBackEnd error: %d", err); + CleanupStack::Pop(1); + + // Check that the decompressed data is identical to the original data + CHECK_CONDITION0L(strcmp(inputData, (char *)decompressedDataBuffer) != 0, KErrGeneral, "The deflated data did no match the original data."); + + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4279 +@SYMTestCaseDesc Check inflateBackEnd() fails when given an invalid stream or parameters. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + setting windowBits between -8 and -15. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using + nflateBackInit() setting windowBits to be equal to or greater + than the windowBits value used for deflateInit2(). + 4. Call inflateBack() to uncompress the stream. + 5. Call inflateBackEnd() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is NULL for the stream argument + c. a stream whose zfree is Z_NULL for the stream argument +@SYMTestExpectedResults inflateBackEnd() fails returning Z_STREAM_ERROR in all cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateBackEndFailsL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateBackInit arguments + StreamSettings streamSettings; + streamSettings.deflateInit2 = true; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.method = Z_DEFLATED; + streamSettings.deflateWindowBits = -MAX_WBITS; + streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits; + streamSettings.memLevel = TEST_MID_MEM_LEVEL; + streamSettings.strategy = Z_DEFAULT_STRATEGY; + Bytef inflateWindow[32 * 1024]; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflate stream + InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow); + CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream)); + + inflateStream.next_in = (unsigned char *)compressedDataBuffer; + inflateStream.avail_in = compressedDataBufferLength; + inflateStream.next_out = (unsigned char *)decompressedDataBuffer; + inflateStream.avail_out = decompressedDataBufferLength; + + struct bufferDescriptor compressedDataBufferDescriptor; + compressedDataBufferDescriptor.buffer = compressedDataBuffer; + compressedDataBufferDescriptor.next = 0; + compressedDataBufferDescriptor.length = compressedDataBufferLength; + + struct bufferDescriptor decompressedDataBufferDescriptor; + decompressedDataBufferDescriptor.buffer = decompressedDataBuffer; + decompressedDataBufferDescriptor.next = 0; + decompressedDataBufferDescriptor.length = decompressedDataBufferLength; + + // Decompress the input + err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_STREAM_END, KErrGeneral, "inflateBack error: %d", err); + + // Try cleaning up a NULL stream + err = inflateBackEnd(NULL); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackEnd on a NULL stream returned an unexpected value: %d", err); + + // Keep a pointer to the streams state so we can clean up properly with inflateBackEnd() + struct internal_state FAR *inflateState = inflateStream.state; + + // Try cleaning up an inflate stream with a NULL state + inflateStream.state = NULL; + err = inflateBackEnd(&inflateStream); + inflateStream.state = inflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackEnd on a stream with a NULL state returned an unexpected value: %d", err); + + // Try cleaning up an inflate stream with no free function + free_func zfree = inflateStream.zfree; + inflateStream.zfree = Z_NULL; + err = inflateBackEnd(NULL); + inflateStream.zfree = zfree; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackEnd on a stream with zfree set to NULL returned an unexpected value: %d", err); + + // Clean up the inflate stream + err = inflateBackEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateBackEnd error: %d", err); + CleanupStack::Pop(1); + + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/* + * in function required by inflateBack. + * Returning 0 indicates failure. + */ +unsigned inNoInput OF((void FAR *, unsigned char FAR * FAR *)) + { + return 0; + } + +/* + * out function required by inflateBack. + * Returning non 0 indicates failure. + */ +int outNoOutput OF((void FAR *, unsigned char FAR *, unsigned)) + { + return 1; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4280 +@SYMTestCaseDesc Check inflateBack() fails when given an invalid stream or parameters. +@SYMTestPriority High +@SYMTestActions 1. Create a deflate stream and initialise it using deflateInit2(), + setting windowBits between -8 and-15. + 2. Deflate the input and cleanup using deflateEnd(). + 3. Create an inflate stream and initialise it using + inflateBackInit() setting windowBits to be equal to or greater + than the windowBits value used for deflateInit2(). + 4. Call inflateBack() passing it parameter values: + a. NULL for the stream argument + b. a stream whose state is NULL for the stream argument + c. an input function that returns 0 for the in argument + d. an output function that doesn’t return 0 for the out argument + e. corrupted deflate output + 5. Call inflateBackEnd() to clean up +@SYMTestExpectedResults inflateBack() fails returning Z_STREAM_ERROR for the first two + cases, Z_BUF_ERROR for the second two cases and Z_DATA_ERROR + for the final case. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateBackFailsL() + { + int err = Z_OK; + + // Streams + z_stream deflateStream; + z_stream inflateStream; + + // Buffers + const char inputData[] = "This is a piece of data to compress.\0"; + uLong inputDataLength = (uLong)strlen(inputData) + 1; + Byte *compressedDataBuffer = NULL; + uLong compressedDataBufferLength = COMPRESSED_DATA_BUFFER_LENGTH; + Byte *decompressedDataBuffer = NULL; + uLong decompressedDataBufferLength = inputDataLength; + + // deflateInit2 and inflateBackInit arguments + StreamSettings streamSettings; + streamSettings.deflateInit2 = true; + streamSettings.level = Z_DEFAULT_COMPRESSION; + streamSettings.method = Z_DEFLATED; + streamSettings.deflateWindowBits = -MAX_WBITS; + streamSettings.inflateWindowBits = -streamSettings.deflateWindowBits; // inflateBackInit expects the positive equivalent of the windowBits used to make a raw stream + streamSettings.memLevel = TEST_MID_MEM_LEVEL; + streamSettings.strategy = Z_DEFAULT_STRATEGY; + Bytef inflateWindow[32 * 1024]; + + // Allocate memory for buffers + compressedDataBuffer = (Byte *)User::AllocZ(compressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(compressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for compressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, compressedDataBuffer)); + + decompressedDataBuffer = (Byte *)User::AllocZ(decompressedDataBufferLength * sizeof(Byte)); + CHECK_CONDITION0L(decompressedDataBuffer == NULL, KErrNoMemory, "Failed to allocate memory for decompressedDataBuffer."); + CleanupStack::PushL(TCleanupItem(User::Free, decompressedDataBuffer)); + + this->CompressDataL(streamSettings, deflateStream, (Byte *)inputData, inputDataLength, compressedDataBuffer, compressedDataBufferLength); + + // Initialise the inflate stream + InflateBackInitL(inflateStream, streamSettings.inflateWindowBits, inflateWindow); + CleanupStack::PushL(TCleanupItem(InflateBackEnd, &inflateStream)); + + // This must be set to NULL otherwise inflateBack will assume there is input and try to decompress it + inflateStream.next_in = NULL; + + struct bufferDescriptor compressedDataBufferDescriptor; + compressedDataBufferDescriptor.buffer = compressedDataBuffer; + compressedDataBufferDescriptor.next = 0; + compressedDataBufferDescriptor.length = compressedDataBufferLength; + + struct bufferDescriptor decompressedDataBufferDescriptor; + decompressedDataBufferDescriptor.buffer = decompressedDataBuffer; + decompressedDataBufferDescriptor.next = 0; + decompressedDataBufferDescriptor.length = decompressedDataBufferLength; + + // Try inflating a NULL stream + err = inflateBack(NULL, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBack on a NULL stream returned an unexpected value: %d", err); + + // Try calling inflateBack on a deflate stream that has a NULL state + // We must keep a pointer to the streams state so we can clean up properly with deflateBackEnd + struct internal_state FAR *inflateState = inflateStream.state; + inflateStream.state = NULL; + + err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + + inflateStream.state = inflateState; + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBack on a stream with a NULL state returned an unexpected value: %d", err); + + // Try inflating a stream with an in_func that returns no input data + err = inflateBack(&inflateStream, &inNoInput, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_BUF_ERROR, KErrGeneral, "Calling inflateBack with an in function that returns no input returned an unexpected value: %d", err); + + // Try inflating a stream with an out_func that does not output any data + err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &outNoOutput, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_BUF_ERROR, KErrGeneral, "Calling inflateBack with an in function that returns no input returned an unexpected value: %d", err); + + // Try inflating a corrupt stream + compressedDataBuffer[1] = 'a'; + compressedDataBuffer[2] = 'a'; + compressedDataBuffer[3] = 'a'; + err = inflateBack(&inflateStream, &in, &compressedDataBufferDescriptor, &out, &decompressedDataBufferDescriptor); + CHECK_CONDITION1L(err != Z_DATA_ERROR, KErrGeneral, "Calling inflateBack on a corrupt stream returned an unexpected value: %d", err); + + // Clean up the inflate stream + err = inflateBackEnd(&inflateStream); + CHECK_CONDITION1L(err != Z_OK, KErrGeneral, "inflateBackEnd error: %d", err); + CleanupStack::Pop(1); + + CleanupStack::PopAndDestroy(2); + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4281 +@SYMTestCaseDesc Check inflateBackInit() fails when given an invalid stream or parameters. +@SYMTestPriority High +@SYMTestActions 1. Create an inflate stream and initialise it using + inflateBackInit() passing it parameter values: + a. NULL for the stream argument + b. a stream whose window is NULL for the stream argument + c. < 8 for the windowBits argument + d. > 5 for the windowBits argument +@SYMTestExpectedResults inflateBackInit() should fail returning Z_STREAM_ERROR for all cases. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateBackInitFailsParamsL() + { + int err = Z_OK; + + // Streams + z_stream inflateStream; + + // inflateBackInit arguments + int inflateBackWindowBits = MAX_WBITS; + Bytef inflateWindow[32 * 1024]; + + // Try initialising a NULL stream + inflateStream.zalloc = Z_NULL; + inflateStream.zfree = Z_NULL; + inflateStream.opaque = Z_NULL; + + err = inflateBackInit(NULL, inflateBackWindowBits, inflateWindow); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a NULL stream returned an unexpected value: %d", err); + + // Try initialising a stream with a NULL inflate window + err = inflateBackInit(&inflateStream, inflateBackWindowBits, NULL); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with a NULL window returned an unexpected value: %d", err); + + // Try initialising a stream with window bits < 8 + err = inflateBackInit(&inflateStream, 7, inflateWindow); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with windowBits < 8 returned an unexpected value: %d", err); + + // Try initialising a stream with window bits > 15 + err = inflateBackInit(&inflateStream, 16, inflateWindow); + CHECK_CONDITION1L(err != Z_STREAM_ERROR, KErrGeneral, "Calling inflateBackInit on a stream with windowBits > 15 returned an unexpected value: %d", err); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4282 +@SYMTestCaseDesc Check inflateBackInit() fails when there is not enough memory. +@SYMTestPriority High +@SYMTestActions 1. Create an inflate stream and set the next memory allocation to fail. + 2. Initialise the stream using inflateBackInit() setting + windowBits to be between 8 and 15. + 3. Check that the memory is the same before and after calling + inflateBackInit(). Note: If Z_OK is returned it will be + necessary to call inflateEnd() before checking the amount of memory. + 4. Repeat this process until inflateBackInit() returns Z_OK, + increasing the number of allocations that can be performed before failing. +@SYMTestExpectedResults inflateBackInit () fails at first, returning Z_MEM_ERROR, and then + it will succeed with Z_OK. No memory should be leaked. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestInflateBackInitFailsMem() + { + TInt err; + TVerdict verdict = EPass; + + // Streams + z_stream inflateStream; + + // inflateBackInit arguments + int inflateBackWindowBits = MAX_WBITS; + Bytef inflateWindow[32 * 1024]; + + inflateStream.zalloc = Z_NULL; + inflateStream.zfree = Z_NULL; + inflateStream.opaque = Z_NULL; + + TInt failureRate; + for(failureRate = 1, err = Z_MEM_ERROR; err != Z_OK && failureRate <= FAILURE_RATE_LIMIT; failureRate++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic, failureRate); + __UHEAP_MARK; + + err = inflateBackInit(&inflateStream, inflateBackWindowBits, inflateWindow); + + // Memory has been allocated so we need to clean up + if(err == Z_OK) + { + err = inflateBackEnd(&inflateStream); + if(err != Z_OK) + { + INFO_PRINTF2(_L("inflateBackInit error: %d"), err); + verdict = EAbort; + break; + } + } + else if(err != Z_MEM_ERROR) + { + INFO_PRINTF2(_L("inflateBackInit unexpected error: %d"), err); + verdict = EFail; + break; + } + + __UHEAP_MARKEND; + __UHEAP_RESET; + } + + if(err == Z_OK) + { + INFO_PRINTF2(_L("The test succeeded at heap failure rate = %d."), --failureRate); + } + else if(failureRate > FAILURE_RATE_LIMIT) + { + INFO_PRINTF1(_L("Exceeded FAILURE_RATE_LIMIT. Either the test has failed or the limit needs increasing.")); + verdict = EFail; + } + + return verdict; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4283 +@SYMTestCaseDesc Check adler32_combine() generates the correct adler32 checksum. +@SYMTestPriority High +@SYMTestActions 1. Create two byte buffers, both containing different data, and + use these to create two checksums using adler32(). + 2. Create a third checksum using adler32_combine(), providing it + with the first two checksums and the length of the second checksum. + 3. Concatenate the two byte buffers and create a fourth checksum + using adler32() and the concatenated buffer as input. + 4. Compare the third and fourth checksums. +@SYMTestExpectedResults The third and fourth checksums should be identical. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestAdler32CombineL() + { + // Byte buffers from which the adler32 checksums will be generated + const Byte *string1 = (Byte *)"Hello"; + const Byte *string2 = (Byte *)"World"; + const int string1Length = 5; + const int string2Length = 5; + const int string3Length = 10; + + // Initialise the adler32 variables + uLong adlerString1 = adler32(0L, NULL, 0); + uLong adlerString2 = adler32(0L, NULL, 0); + uLong adlerString3 = adler32(0L, NULL, 0); + uLong adlerCombined; + + // Generate the checksums from the byte buffers + adlerString1 = adler32(adlerString1, string1, string1Length); + adlerString2 = adler32(adlerString2, string2, string2Length); + + // Generate the checksum from combining adlerString1 and adlerString2 + adlerCombined = adler32_combine(adlerString1, adlerString2, string2Length); + + // Concatenate the byte buffers so that a checksum can be generated + Byte string3[string3Length]; + memcpy((char *)string3, (char *)string1, string1Length); + memcpy((char *)string3 + string1Length, (char *)string2, string2Length); + + // Generate checksum + adlerString3 = adler32(adlerString3, string3, string3Length); + + // Compare the checksums to see if they are the same + CHECK_CONDITION0L(adlerString3 != adlerCombined, KErrGeneral, "The combined checksum is not correct."); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4284 +@SYMTestCaseDesc Check crc32_combine() generates the correct crc32 checksum. +@SYMTestPriority High +@SYMTestActions 1. Create two byte buffers, both containing different data, and + use these to create two checksums using crc32(). + 2. Create a third checksum using crc32_combine(), providing it + with the first two checksums and the length of the second checksum. + 3. Concatenate the two byte buffers and create a fourth checksum + using crc32() and the concatenated buffer as input. + 4. Compare the third and fourth checksums. +@SYMTestExpectedResults The third and fourth checksums should be identical. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestCrc32CombineL() + { + // Byte buffers from which the crc32 checksums will be generated + const Byte *string1 = (Byte *)"Hello"; + const Byte *string2 = (Byte *)"World"; + const int string1Length = 5; + const int string2Length = 5; + const int string3Length = 10; + + // Initialise the crc32 variables + uLong crcString1 = crc32(0L, NULL, 0); + uLong crcString2 = crc32(0L, NULL, 0); + uLong crcString3 = crc32(0L, NULL, 0); + uLong crcCombined; + + // Generate the checksums from the byte buffers + crcString1 = crc32(crcString1, string1, string1Length); + crcString2 = crc32(crcString2, string2, string2Length); + + // Generate the checksum from combining adlerString1 and adlerString2 + crcCombined = crc32_combine(crcString1, crcString2, string2Length); + + // Concatenate the byte buffers so that a checksum can be generated + Byte string3[string3Length]; + memcpy((char *)string3, (char *)string1, string1Length); + memcpy((char *)string3 + string1Length, (char *)string2, string2Length); + + // Generate checksum + crcString3 = crc32(crcString3, string3, string3Length); + + // Compare the checksums to see if they are the same + CHECK_CONDITION0L(crcString3 != crcCombined, KErrGeneral, "The combined checksum is not correct."); + + return EPass; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4284 +@SYMTestCaseDesc Check zlibCompileFlags() returns a uLong with the correct + compile flags set. +@SYMTestPriority Medium +@SYMTestActions 1. Call zlibCompileFlags() and compare the first 2 bits with the + size of uInt, the second 2 bits with the size of uLong and + bits 16 and 17 with 0 (GZip APIs are being used). +@SYMTestExpectedResults zlibCompileFlags() will return a uLong and all the comparisons + will return true. +@SYMDEF REQ7362 +*/ + +TVerdict CTestZlib::TestZlibCompileFlagsL() + { + // Get the compilerFlags + uLong compileFlags = zlibCompileFlags(); + int compileFlagsUInt = compileFlags & 0x3; + int compileFlagsULong = (compileFlags >> 2) & 0x3; + int compileFlagsGZip = (compileFlags >> 15) & 0x3; + int machineUInt; + int machineULong; + + // Get the size of uInt + switch(sizeof(uInt)) + { + case 2: machineUInt = 0; + break; + case 4: machineUInt = 1; + break; + case 8: machineUInt = 2; + break; + default: machineUInt = 3; + } + + // Check the compiler flag for uInt is correct + CHECK_CONDITION0L(machineUInt != compileFlagsUInt, KErrGeneral, "zlibCompileFlags reports an incorrect size for uInt."); + + // Get the size of uLong + switch(sizeof(uLong)) + { + case 2: machineULong = 0; + break; + case 4: machineULong = 1; + break; + case 8: machineULong = 2; + break; + default: machineULong = 3; + } + + // Check the compiler flag for uLong is correct + CHECK_CONDITION0L(machineULong != compileFlagsULong, KErrGeneral, "zlibCompileFlags reports an incorrect size for uLong."); + + // Check the compiler flags for GZip compression are correct + CHECK_CONDITION0L(compileFlagsGZip != 0, KErrGeneral, "zlibCompileFlags reports GZip functionality is disabled."); + + return EPass; + }