diff -r 000000000000 -r bde4ae8d615e os/ossrv/compressionlibs/ziplib/test/rtest/ezlibtest/ezlibtest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/compressionlibs/ziplib/test/rtest/ezlibtest/ezlibtest.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1814 @@ +// Copyright (c) 2003-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: +// + +#include +#include + +#include +#include +#include +#include +#include + + +_LIT(KSeparator,"----------------------------------------------------------------\n"); + +const TInt KNumberOfTests = 38; +_LIT(KTest1,"Multistep compression & decompression using buffers smaller than source & destination"); +_LIT(KTest2,"Multistep compression & decompression using buffers larger than source & destination"); +_LIT(KTest3,"Test Multistep compression when NeedInput provides no input"); +_LIT(KTest4,"Test Multistep compression when NeedOutput provides no output"); +_LIT(KTest5,"Perform multistep compression 2 with the same CEZCompressor, reseting it\n\ + after the first compression."); +_LIT(KTest6,"Perform multistep compression 2 with the same CEZCompressor, without reseting it\n\ + after the first compression."); +_LIT(KTest7,"Performs multistep compression & decompression using a preset dicitonary."); +_LIT(KTest8,"Performs multistep compression with compression level of 0."); +_LIT(KTest9,"Performs multistep compression with compression level of 9."); +_LIT(KTest10,"Performs multistep compression with invalid compression level."); +_LIT(KTest11,"Performs multistep compression with window bits of 8."); +_LIT(KTest12,"Performs multistep compression with an invalid value for window bits."); +_LIT(KTest13,"Performs multistep compression with memory level = 1."); +_LIT(KTest14,"Performs multistep compression with an invalid memory level."); +_LIT(KTest15,"Performs multistep compression using only Huffman encoding."); +_LIT(KTest16,"Performs multistep compression using Filtered strategy."); +_LIT(KTest17,"Performs multistep compression when Alloc fails randomly."); +_LIT(KTest18,"Test Multistep decompression when NeedInput provides no input."); +_LIT(KTest19,"Test Multistep decompression when NeedOutput provides no output."); +_LIT(KTest20,"Test Multistep decompression when compressed stream is corrupt."); +_LIT(KTest21,"Test Multistep decompressor construction when Alloc fails randomly."); +_LIT(KTest22,"Test Multistep decompression when Alloc fails randomly."); +_LIT(KTest23,"Test Multistep decompression when a dictionary is required and not provided.\n\ + This test should panic."); +_LIT(KTest24,"Test Multistep decompression when a dictionary when the wrong dictionary is provided."); +_LIT(KTest25,"Perform multistep decompression twice with the same CEZDecompressor, reseting it\n\ + after the first decompression."); +_LIT(KTest26,"Perform multistep decompression twice with the same CEZDecompressor, reseting it\n\ + after the first decompression."); +_LIT(KTest27,"Perform multistep compression and decompression on unicode data."); +_LIT(KTest28,"Perform multistep compression and decompression on unicode data using a unicode dictionary."); +_LIT(KTest29,"Perform multistep compression and decompression on unicode data using an ascii dictionary."); +_LIT(KTest30,"Test percentage of completion during multistep compression/decompression."); +_LIT(KTest31,"Test single step compression and decompression."); +_LIT(KTest32,"Test single step compression when indaquate output buffer is provided."); +_LIT(KTest33,"Test single step decompression when indaquate output buffer is provided."); +_LIT(KTest34,"Testing graceful exit for zlib 1.1.3 decompression bug. See: INC022729."); +_LIT(KTest35,"Testing EZlib decompression performance with enforced compiler optimisation"); +_LIT(KTest36,"Testing correct memory deallocation for CEZFileBufferManager. See: DEF109756."); +_LIT(KTest37,"Test CEZZStream functions through CEZCompressor class."); +_LIT(KTest38,"Test Calls to Zlibapiwrapper.cpp exported API's like inflate, deflate, compress, decompress"); + +const TPtrC KTest1Des(KTest1); +const TPtrC KTest2Des(KTest2); +const TPtrC KTest3Des(KTest3); +const TPtrC KTest4Des(KTest4); +const TPtrC KTest5Des(KTest5); +const TPtrC KTest6Des(KTest6); +const TPtrC KTest7Des(KTest7); +const TPtrC KTest8Des(KTest8); +const TPtrC KTest9Des(KTest9); +const TPtrC KTest10Des(KTest10); +const TPtrC KTest11Des(KTest11); +const TPtrC KTest12Des(KTest12); +const TPtrC KTest13Des(KTest13); +const TPtrC KTest14Des(KTest14); +const TPtrC KTest15Des(KTest15); +const TPtrC KTest16Des(KTest16); +const TPtrC KTest17Des(KTest17); +const TPtrC KTest18Des(KTest18); +const TPtrC KTest19Des(KTest19); +const TPtrC KTest20Des(KTest20); +const TPtrC KTest21Des(KTest21); +const TPtrC KTest22Des(KTest22); +const TPtrC KTest23Des(KTest23); +const TPtrC KTest24Des(KTest24); +const TPtrC KTest25Des(KTest25); +const TPtrC KTest26Des(KTest26); +const TPtrC KTest27Des(KTest27); +const TPtrC KTest28Des(KTest28); +const TPtrC KTest29Des(KTest29); +const TPtrC KTest30Des(KTest30); +const TPtrC KTest31Des(KTest31); +const TPtrC KTest32Des(KTest32); +const TPtrC KTest33Des(KTest33); +const TPtrC KTest34Des(KTest34); +const TPtrC KTest35Des(KTest35); +const TPtrC KTest36Des(KTest36); +const TPtrC KTest37Des(KTest37); +const TPtrC KTest38Des(KTest38); + +void Test1L(); +void Test2L(); +void Test3(); +void Test4(); +void Test5L(); +void Test6(); +void Test7L(); +void Test8L(); +void Test9L(); +void Test10(); +void Test11(); +void Test12(); +void Test13L(); +void Test14(); +void Test15L(); +void Test16L(); +void Test17(); +void Test18L(); +void Test19L(); +void Test20L(); +void Test21L(); +void Test22L(); +void Test23(); +void Test24L(); +void Test25L(); +void Test26L(); +void Test27L(); +void Test28L(); +void Test29L(); +void Test30L(); +void Test31L(); +void Test32(); +void Test33L(); +void Test34L(); +void Test35L(); +void Test36L(); +void TestCEZCompressorMethodsL(); +void TestZlibapiwrapperAPIL(); + +typedef void (*TestPtr)(); + +struct TTests + { + TestPtr iFn; + const TPtrC *iDescription; + }; + +const TTests testTable[] = { + {Test1L,&KTest1Des}, + {Test2L,&KTest2Des}, + {Test3,&KTest3Des}, + {Test4,&KTest4Des}, + {Test5L,&KTest5Des}, + {Test6,&KTest6Des}, + {Test7L,&KTest7Des}, + {Test8L,&KTest8Des}, + {Test9L,&KTest9Des}, + {Test10,&KTest10Des}, + {Test11,&KTest11Des}, + {Test12,&KTest12Des}, + {Test13L,&KTest13Des}, + {Test14,&KTest14Des}, + {Test15L,&KTest15Des}, + {Test16L,&KTest16Des}, + {Test17,&KTest17Des}, + {Test18L,&KTest18Des}, + {Test19L,&KTest19Des}, + {Test20L,&KTest20Des}, + {Test21L,&KTest21Des}, + {Test22L,&KTest22Des}, + {Test23,&KTest23Des}, + {Test24L,&KTest24Des}, + {Test25L,&KTest25Des}, + {Test26L,&KTest26Des}, + {Test27L,&KTest27Des}, + {Test28L,&KTest28Des}, + {Test29L,&KTest29Des}, + {Test30L,&KTest30Des}, + {Test31L,&KTest31Des}, + {Test32,&KTest32Des}, + {Test33L,&KTest33Des}, + {Test34L,&KTest34Des}, + {Test35L,&KTest35Des}, + {Test36L,&KTest36Des}, + {TestCEZCompressorMethodsL, &KTest37Des}, + {TestZlibapiwrapperAPIL, &KTest38Des} + }; + +struct TTestFlags + { + enum + { + FakeNoInput = 16, + FakeNoOutput = 32, + Dictionary = 64, + AllocFail = 128, + Corrupt = 256, + AllocFailInflate = 512, + Unicode = 1024, + Percent = 2048 + }; + + + TTestFlags() : iFlags(0), iBufferSize(0) { Defaults(); } + TTestFlags(TInt aFlags, TInt aBufferSize) : iFlags(aFlags), iBufferSize(aBufferSize) { Defaults(); } + void Defaults(); + + TInt iFlags; + TInt iBufferSize; + TPtrC8 iDictionary; + TInt iLevel; + TInt iWindowBits; + TInt iMemLevel; + CEZCompressor::TStrategy iStrategy; + }; + + +void TTestFlags::Defaults() + { + iLevel = CEZCompressor::EDefaultCompression; + iWindowBits = CEZCompressor::EMaxWBits; + iMemLevel = CEZCompressor::EDefMemLevel; + iStrategy = CEZCompressor::EDefaultStrategy; + } + +TReal FastCountToMilliseconds(TInt aFastCount) + { + TInt freqInHz; + HAL::Get(HAL::EFastCounterFrequency, freqInHz); + TReal freqInkHz = freqInHz / 1000; + return (TReal)aFastCount / freqInkHz; + } + + +static RTest Test(_L("EZLIB")); + +static TUint8 original[] = "compression is a constant source of depression and depression leads to multiple regressions in succession"; +static TUint8 dictionary[] = "constant source multiple leads compression "; +static TUint8 badDictionary[] = "I'm not the dictionary"; +static TUint8 compressed[256]; +static TInt compressedSize; // length of compressed data in compressed. +static TUint8 uncompressed[256]; +static TText output[256]; +static TText originalU[256]; +static TText dictionaryU[256]; + +static void RunTestL(); + +static void CompressBufferL(const TTestFlags &aFlags, RTest &aTest=Test); +static void DecompressBufferL(const TTestFlags &aFlags, RTest &aTest=Test); +static void DblDecompressBufferL(TInt aBufferSize, TBool aReset); +static void CompressDecompressL(const TTestFlags &aFlags); +static void DblCompressBufferL(TInt aBufferSize, TBool aReset = EFalse); + +class CBufferManager : public CBase, public MEZBufferManager + { +public: + ~CBufferManager(); + + static CBufferManager *NewLC(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength, TInt aBufferSize); + static CBufferManager *NewL(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength, TInt aBufferSize); + + void InitializeL(CEZZStream &aZStream); + void NeedInputL(CEZZStream &aZStream); + void NeedOutputL(CEZZStream &aZStream); + void FinalizeL(CEZZStream &aZStream); + + void FakeNoInput() { iFakeNoInput = ETrue; } + void FakeNoOutput() { iFakeNoOutput = ETrue; } + +private: + CBufferManager(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength); + void ConstructL(TInt aBufferSize); + +private: + TUint8 *iInput, *iOutput; + TUint8 *iInputBuffer, *iOutputBuffer; + TInt iBufferSize; + TInt iOutputLength, iInputLength; + TPtr8 iInputDescriptor; + TPtr8 iOutputDescriptor; + TBool iFakeNoInput; + TBool iFakeNoOutput; + }; + +CBufferManager::CBufferManager(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength) + : iInput(aInput), + iOutput(aOutput), + iOutputLength(aOutputLength), + iInputLength(aInputLength), + iInputDescriptor(NULL,0), + iOutputDescriptor(NULL,0), + iFakeNoInput(EFalse), + iFakeNoOutput(EFalse) + { + + } + +CBufferManager::~CBufferManager() + { + delete[] iInputBuffer; + delete[] iOutputBuffer; + } + +CBufferManager *CBufferManager::NewLC(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength, TInt aBufferSize) + { + CBufferManager *bm = new (ELeave) CBufferManager(aInput,aInputLength,aOutput,aOutputLength); + CleanupStack::PushL(bm); + bm->ConstructL(aBufferSize); + return bm; + } + +CBufferManager *CBufferManager::NewL(TUint8 *aInput, TInt aInputLength, TUint8 *aOutput, TInt aOutputLength, TInt aBufferSize) + { + CBufferManager *bm = new (ELeave) CBufferManager(aInput,aInputLength,aOutput,aOutputLength); + CleanupStack::PushL(bm); + bm->ConstructL(aBufferSize); + CleanupStack::Pop(); + return bm; + } + +void CBufferManager::ConstructL(TInt aBufferSize) + { + iBufferSize = aBufferSize; + iInputBuffer = new (ELeave) TUint8[iBufferSize]; + iOutputBuffer = new (ELeave) TUint8[iBufferSize]; + + } + +void CBufferManager::InitializeL(CEZZStream &aZStream) + { + TInt remaining = iInputLength; + if (remaining > iBufferSize) + remaining = iBufferSize; + Mem::Copy(iInputBuffer,iInput,remaining); + iInputDescriptor.Set(iInputBuffer,remaining,iBufferSize); + aZStream.SetInput(iInputDescriptor); + iOutputDescriptor.Set(iOutputBuffer,0,iBufferSize); + aZStream.SetOutput(iOutputDescriptor); + iInput += remaining; + } + +void CBufferManager::NeedInputL(CEZZStream &aZStream) + { + TInt remaining; + if (iFakeNoInput) + remaining = 0; + else + { + remaining = iInputLength - aZStream.TotalIn(); + if (remaining > iBufferSize) + remaining = iBufferSize; + Mem::Copy(iInputBuffer,iInput,remaining); + } + iInputDescriptor.Set(iInputBuffer,remaining,iBufferSize); + aZStream.SetInput(iInputDescriptor); + iInput += remaining; + } + + +void CBufferManager::NeedOutputL(CEZZStream &aZStream) + { + TInt remaining; + if (iFakeNoOutput) + { + remaining = 0; + iOutputDescriptor.Set(iOutputBuffer,remaining,remaining); + } + else + { + remaining = iOutputLength - aZStream.TotalOut(); + if (remaining > iBufferSize) + remaining = iBufferSize; + } + TPtrC8 od = aZStream.OutputDescriptor(); + Mem::Copy(iOutput,iOutputBuffer,od.Size()); + aZStream.SetOutput(iOutputDescriptor); + iOutput += iBufferSize; + } + +void CBufferManager::FinalizeL(CEZZStream &aZStream) + { + TInt copy = aZStream.OutputDescriptor().Size(); + + if (copy > 0) + Mem::Copy(iOutput,iOutputBuffer,copy); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-1328 +@SYMTestCaseDesc Decompression of stream test +@SYMTestPriority High +@SYMTestActions Compresses and decompresses a buffer and tests to see whether the orginal and decompression streams + are the same. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +static void CompressDecompressL(const TTestFlags &aFlags) + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-1328 ")); + CompressBufferL(aFlags); + DecompressBufferL(aFlags); + + if (aFlags.iFlags & TTestFlags::Unicode) + { + TPtr s1(REINTERPRET_CAST(TText *, original),sizeof(original)); + TPtr s2(REINTERPRET_CAST(TText *, uncompressed),sizeof(original)); + Test(s1.Compare(s2) == 0,__LINE__); + } + else + { + TPtrC8 s1(original); + TPtrC8 s2(uncompressed); + Test(s1.Compare(s2) == 0,__LINE__); + } + } + +// Compresses the data in original and places it into compressed. + +//Need to pass in RTest object as this function is called by a seperate thread sometimes +static void CompressBufferL(const TTestFlags &aFlags, RTest &aTest) + { + _LIT(KMsg,"\nTesting multi-step compresssion with buffer size %d\n"); + aTest.Printf(KMsg,aFlags.iBufferSize); + aTest.Printf(KSeparator); + CBufferManager *bm; + TInt sourceSize; + + if (aFlags.iFlags & TTestFlags::Unicode) + { + sourceSize = sizeof(original) * sizeof(TText); + bm = CBufferManager::NewLC(REINTERPRET_CAST(TUint8*,originalU),sourceSize,compressed,256,aFlags.iBufferSize); + } + else + { + sourceSize = sizeof(original); + bm = CBufferManager::NewLC(original,sourceSize,compressed,256,aFlags.iBufferSize); + } + + + if (aFlags.iFlags & TTestFlags::FakeNoInput) + bm->FakeNoInput(); + if (aFlags.iFlags & TTestFlags::FakeNoOutput) + bm->FakeNoOutput(); + CEZCompressor *def; + +#if defined(_DEBUG) && defined(__WINS__) + if (aFlags.iFlags & TTestFlags::AllocFail) + __UHEAP_SETFAIL(RHeap::ETrueRandom,5); +#endif + + if (aFlags.iFlags & TTestFlags::Dictionary) + def = CEZCompressor::NewLC(*bm,aFlags.iDictionary,aFlags.iLevel,aFlags.iWindowBits, + aFlags.iMemLevel,aFlags.iStrategy); + else + def= CEZCompressor::NewLC(*bm,aFlags.iLevel,aFlags.iWindowBits,aFlags.iMemLevel, + aFlags.iStrategy); + + while (def->DeflateL()) + { + if (aFlags.iFlags & TTestFlags::Percent) + { + _LIT(KPer,"%d "); + aTest.Printf(KPer,def->Progress(sourceSize)); + } + } + if (aFlags.iFlags & TTestFlags::Percent) + aTest.Printf(_L("\n")); + + compressedSize = def->TotalOut(); + _LIT(KUnMsg,"Uncompressed Size %d\n"); + _LIT(KComMsg,"Compressed Size %d\n"); + + if (aFlags.iFlags & TTestFlags::Corrupt) + compressed[compressedSize >> 1] = 1; + + aTest.Printf(KUnMsg,def->TotalIn()); + aTest.Printf(KComMsg,compressedSize); + CleanupStack::PopAndDestroy(2); + } + +// Decompresses data stored in compressed and writes it to uncompressed. + +//Need to pass in RTest object as this function is called by a seperate thread sometimes +static void DecompressBufferL(const TTestFlags &aFlags, RTest &aTest) + { + _LIT(KMsg,"\nTesting multi-step decompresssion with buffer size %d\n"); + aTest.Printf(KMsg,aFlags.iBufferSize); + aTest.Printf(KSeparator); + CBufferManager *bm = CBufferManager::NewLC(compressed,compressedSize,uncompressed,256,aFlags.iBufferSize); + + if (aFlags.iFlags & TTestFlags::FakeNoInput) + bm->FakeNoInput(); + if (aFlags.iFlags & TTestFlags::FakeNoOutput) + bm->FakeNoOutput(); + +#if defined(_DEBUG) && defined(__WINS__) + if (aFlags.iFlags & TTestFlags::AllocFail) + __UHEAP_SETFAIL(RHeap::ETrueRandom,10); +#endif + + CEZDecompressor *in; + if (aFlags.iFlags & TTestFlags::Dictionary) + in = CEZDecompressor::NewLC(*bm,aFlags.iDictionary); + else + in = CEZDecompressor::NewLC(*bm); + +#if defined(_DEBUG) && defined(__WINS__) + if (aFlags.iFlags & TTestFlags::AllocFailInflate) + __UHEAP_SETFAIL(RHeap::ETrueRandom,10); +#endif + + while (in->InflateL()) + { + if (aFlags.iFlags & TTestFlags::Percent) + { + _LIT(KPer,"%d "); + aTest.Printf(KPer,in->Progress(compressedSize)); + } + } + if (aFlags.iFlags & TTestFlags::Percent) + aTest.Printf(_L("\n")); + + + if (aFlags.iFlags & TTestFlags::Unicode) + { + TPtrC ptr(REINTERPRET_CAST(TText *,uncompressed),in->TotalOut() / sizeof(TText)); + aTest.Printf(ptr); + aTest.Printf(_L("\n")); + } + else + { + TPtrC8 ptr8(uncompressed); + TPtr ptr16(output,256); + ptr16.Copy(ptr8); + aTest.Printf(ptr16); + aTest.Printf(_L("\n")); + } + CleanupStack::PopAndDestroy(2); + } + +static void DblCompressBufferL(TInt aBufferSize, TBool aReset) + { + CEZCompressor *def = NULL; + + _LIT(KMsg,"\nTesting multi-step compresssion with buffer size %d\n"); + _LIT(KUnMsg,"Uncompressed Size %d\n"); + _LIT(KComMsg,"Compressed Size %d\n"); + + Test.Printf(KMsg,aBufferSize); + Test.Printf(KSeparator,aBufferSize); + CBufferManager *bm = CBufferManager::NewLC(original,sizeof(original),compressed,256,aBufferSize); + def = CEZCompressor::NewLC(*bm); + + while (def->DeflateL()){} + + compressedSize = def->TotalOut(); + Test.Printf(KUnMsg,sizeof(original)); + Test.Printf(KComMsg,compressedSize); + + CleanupStack::Pop(); + CleanupStack::PopAndDestroy(); + CleanupStack::PushL(def); + + if (aReset) + { + bm = CBufferManager::NewLC(original,sizeof(original),compressed,256,aBufferSize); + def->ResetL(*bm); + } + + Test.Printf(KMsg,aBufferSize); + Test.Printf(KSeparator,aBufferSize); + + while (def->DeflateL()){} + + compressedSize = def->TotalOut(); + Test.Printf(KUnMsg,sizeof(original)); + Test.Printf(KComMsg,compressedSize); + + CleanupStack::PopAndDestroy(2); + } + +static void DblDecompressBufferL(TInt aBufferSize, TBool aReset) + { + CEZDecompressor *def = NULL; + + _LIT(KMsg,"\nTesting multi-step decompresssion with buffer size %d\n"); + Test.Printf(KMsg,aBufferSize); + Test.Printf(KSeparator); + CBufferManager *bm = CBufferManager::NewLC(compressed,compressedSize,uncompressed,256,aBufferSize); + def = CEZDecompressor::NewLC(*bm); + + while (def->InflateL()){} + + CleanupStack::Pop(); + CleanupStack::PopAndDestroy(); + CleanupStack::PushL(def); + + if (aReset) + { + bm = CBufferManager::NewLC(compressed,compressedSize,uncompressed,256,aBufferSize); + def->ResetL(*bm); + } + + Test.Printf(KMsg,aBufferSize); + Test.Printf(KSeparator,aBufferSize); + + while (def->InflateL()){} + + TPtrC8 ptr8(uncompressed); + TPtr ptr16(output,256); + ptr16.Copy(ptr8); + Test.Printf(ptr16); + Test.Printf(_L("\n")); + + CleanupStack::PopAndDestroy(2); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0785 +@SYMTestCaseDesc Multistep compression & decompression test using buffers smaller than source & destination +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test1L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0785 ")); + TTestFlags flags(0,8); + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0786 +@SYMTestCaseDesc Multistep compression & decompression test using buffers larger than source & destination +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 1024 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test2L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0786 ")); + TTestFlags flags(0,1024); + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0787 +@SYMTestCaseDesc Multistep compression test +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::FakeNoInput,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test3() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0787 ")); + TTestFlags flags(TTestFlags::FakeNoInput,8); + + TRAPD(err,CompressBufferL(flags)); + Test (err==KErrNone); // This test should succeed as providing no Input is a valid thing for + // NeedInputL to do. + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0788 +@SYMTestCaseDesc Multistep compression test when NeedOutput provides no output +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::FakeNoOutput,buffersize to 8 + Check for buffer error. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test4() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0788 ")); + TTestFlags flags(TTestFlags::FakeNoOutput,8); + + TRAPD(err,CompressBufferL(flags)); + Test (err==KEZlibErrBuf); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0789 +@SYMTestCaseDesc Multistep compression test with the same CEZCompressor, + resetting it after the first compression +@SYMTestPriority High +@SYMTestActions Set the buffersize to 8,reset value to true +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test5L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0789 ")); + DblCompressBufferL(8,ETrue); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0790 +@SYMTestCaseDesc Multistep compression test with the same CEZCompressor, + without resetting it after the first compression +@SYMTestPriority High +@SYMTestActions Set the buffersize to 8,reset value to false +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test6() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0790 ")); + //Calling compress twice without reseting (ie passing in EFalse) causes leave + TRAPD(err,DblCompressBufferL(8,EFalse)); + Test (err==KEZlibErrDeflateTerminated); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0791 +@SYMTestCaseDesc Multistep compression & decompression test using a preset dictionary +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Dictionary,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test7L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0791 ")); + TTestFlags flags(TTestFlags::Dictionary,8); + flags.iDictionary.Set(dictionary,sizeof(dictionary)); + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0792 +@SYMTestCaseDesc Multistep compression with compression level of 0 test +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8,compression level to 0 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test8L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0792 ")); + TTestFlags flags(0,8); + flags.iLevel = 0; + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0793 +@SYMTestCaseDesc Multistep compression test with compression level of 9 +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8,compression level to 9 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test9L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0793 ")); + TTestFlags flags(0,8); + flags.iLevel = 9; + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0794 +@SYMTestCaseDesc Multistep compression test with invalid compression level +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8,compression level to 10. + Check for stream error when compression level is greater than 9 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test10() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0794 ")); + TTestFlags flags(0,8); + flags.iLevel = 10; + + TRAPD(err, CompressDecompressL(flags)); + //CompressL fails with KEZlibErrStream if level is greater than 9 + Test (err==KEZlibErrStream); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0795 +@SYMTestCaseDesc Multistep compression test with window bits of 7 +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 7 + Check for stream error if window bits is less than 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test11() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0795 ")); + TTestFlags flags(0,7); + flags.iWindowBits = 7; + //CompressL fails with KEZlibErrStream if window bits is less than 8 + TRAPD(err, CompressDecompressL(flags)); + Test (err==KEZlibErrStream); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0796 +@SYMTestCaseDesc Multistep compression test with window bits of 7 +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 + Check for stream error if window bits is less than 9 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test12() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0796 ")); + TTestFlags flags(0,8); + flags.iWindowBits = 7; + //CompressL fails with KEZlibErrStream if window bits is less than 9 + TRAPD(err, CompressDecompressL(flags)); + Test (err==KEZlibErrStream); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0797 +@SYMTestCaseDesc Multistep compression test with memory level = 1 +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test13L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0797 ")); + TTestFlags flags(0,8); + flags.iMemLevel = 1; + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0798 +@SYMTestCaseDesc Multistep compression test with memory level = 10 +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 + Check for stream error if memory level is greater than 8. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test14() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0798 ")); + TTestFlags flags(0,8); + flags.iMemLevel = 10; + + //CompressL fails with KEZlibErrStream if mem level greater than 8 + TRAPD(err, CompressDecompressL(flags)); + Test (err==KEZlibErrStream); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0799 +@SYMTestCaseDesc Multistep compression test using only Huffman encoding +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test15L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0799 ")); + TTestFlags flags(0,8); + flags.iStrategy = CEZCompressor::EHuffmanOnly; + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0800 +@SYMTestCaseDesc Multistep compression test using Filtered strategy +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test16L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0800 ")); + TTestFlags flags(0,8); + flags.iStrategy = CEZCompressor::EFiltered; + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0801 +@SYMTestCaseDesc Multistep compression test when Alloc fails randomly +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test17() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0801 ")); + TTestFlags flags(TTestFlags::AllocFail,8); + + TRAPD(err,CompressBufferL(flags)); + Test(err == KErrNone||err == KErrNoMemory); //alloc failure is random so no quarantees of failure + //Need to reset the heap afterwards to avoid problems for next test. + __UHEAP_RESET; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0802 +@SYMTestCaseDesc Multistep decompression test when NeedInput provides no input +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 + Check for data error,when no input is given +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test18L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0802 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + flags.iFlags |= TTestFlags::FakeNoInput; + TRAPD(err,DecompressBufferL(flags)); + // CEZDecompressor::InflateL has left with KEZlibErrBuf due to buffer error + Test (err==KEZlibErrBuf); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0803 +@SYMTestCaseDesc Multistep decompression test when NeedOutput provides no output +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8 + Check for data error,when no output is given +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test19L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0803 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + flags.iFlags |= TTestFlags::FakeNoOutput; + TRAPD(err,DecompressBufferL(flags)); + // CEZDecompressor::InflateL has left with KEZlibErrBuf due to buffer error + Test (err==KEZlibErrBuf); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0804 +@SYMTestCaseDesc Multistep decompression test when NeedOutput provides no output +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Corrupt, buffersize to 8 + Check for data error +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test20L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0804 ")); + TTestFlags flags(TTestFlags::Corrupt,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + flags.iFlags = 0; + + TRAPD(err,DecompressBufferL(flags)); + // CEZDecompressor::InflateL has left with KEZlibErrData due to buffer error + Test (err==KEZlibErrData); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0805 +@SYMTestCaseDesc Multistep decompression construction test when Alloc fails randomly +@SYMTestPriority High +@SYMTestActions Set the test flags to 0, buffersize to 8 + Check for data error +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test21L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0805 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + flags.iFlags |= TTestFlags::AllocFail; + + TRAPD(err,DecompressBufferL(flags)); + Test (err==KErrNone||err==KErrNoMemory); //Alloc failure is random so no guarantee it will always fail. + __UHEAP_RESET; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0806 +@SYMTestCaseDesc Multistep decompression test when Alloc fails randomly +@SYMTestPriority High +@SYMTestActions Set the test flags to 0, buffersize to 8 + Check for no memory errors. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ + +void Test22L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0806 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + flags.iFlags |= TTestFlags::AllocFailInflate; + + TRAPD(err,DecompressBufferL(flags)); + Test (err==KErrNone||err==KErrNoMemory); //Alloc failure is random so no guarentee it will always fail. + __UHEAP_RESET; + } + +static void ThreadL() + { + RTest test2(_L("EZLIB - second thread")); + test2.Title(); + _LIT(KStartMsg,"Starting Tests in second thread"); + test2.Start(KStartMsg); + + TTestFlags flags(TTestFlags::Dictionary,8); + flags.iDictionary.Set(dictionary,sizeof(dictionary)); + + TRAPD(err,CompressBufferL(flags, test2)); + test2 (err == KErrNone); + flags.iFlags = 0; + //This code leaves (used to panic before the fix for DEF112672) + DecompressBufferL(flags, test2); + User::Panic(_L("TestFailure failure"),0); + test2.End(); + test2.Close(); + } + +static TInt TestThread(TAny*) + { + User::SetJustInTime(EFalse); // disable debugger panic handling + CTrapCleanup* cleanup=CTrapCleanup::New(); + if (!cleanup) + return KErrNoMemory; + TRAPD(r,ThreadL()); + delete cleanup; + return r; + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0807 +@SYMTestCaseDesc Multistep decompression test when a dictionary is required and not provided. +@SYMTestPriority High +@SYMTestActions Test for panic and exit reason. +@SYMTestExpectedResults This test should pass without panic. + (Expected to panic before the fix for DEF112672) +@SYMREQ REQ0000 +*/ + +void Test23() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0807 ")); + __UHEAP_MARK; + + RThread t; + _LIT(KTestThread,"Panicing thread"); + Test.Printf(_L("launching thread")); + Test (t.Create(KTestThread,&TestThread,0x2000,0x10000,0x100000,0,EOwnerThread) == KErrNone); + TRequestStatus s; + t.Logon(s); + Test (s.Int()==KRequestPending); + t.Resume(); + Test.Printf(_L("Awaiting completion")); + User::WaitForRequest(s); + User::SetJustInTime(ETrue); // enable debugger panic handling + _LIT(KCategory,"zlib"); + Test (t.ExitType()==EExitKill); + Test (t.ExitCategory()!=KCategory); + Test (t.ExitReason()==KEZlibErrData);// SetDictionaryL() leaving error code should be KEZlibErrData + t.Close(); + + __UHEAP_MARKEND; + + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0808 +@SYMTestCaseDesc Multistep decompression test when the wrong dictionary is provided +@SYMTestPriority High +@SYMTestActions Check for an error during inflating the dictionary +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test24L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0808 ")); + TTestFlags flags(TTestFlags::Dictionary,8); + flags.iDictionary.Set(dictionary,sizeof(dictionary)); + + CompressBufferL(flags); + + flags.iDictionary.Set(badDictionary,sizeof(badDictionary)); + + TRAPD(err,DecompressBufferL(flags)); + // CEZDecompressor::SetDictionaryL() has left due to bad data + Test (err==KEZlibErrInflateDictionary); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0809 +@SYMTestCaseDesc Multistep decompression test twice with the same CEZDecompressor, + reseting it after the first decompression +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8,reset value to TRUE +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test25L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0809 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + DblDecompressBufferL(8,ETrue); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0810 +@SYMTestCaseDesc Multistep decompression test twice with the same CEZDecompressor, + resetting it after the first decompression +@SYMTestPriority High +@SYMTestActions Set the test flags to 0,buffersize to 8,reset value to FALSE + Check for deflation already occured. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test26L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0810 ")); + TTestFlags flags(0,8); + CompressBufferL(flags); // make sure we initialize compressed properly + + TRAPD(err,DblDecompressBufferL(8,EFalse)); + //Calling decompress twice without resenting causes leave + Test (err==KEZlibErrInflateTerminated); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0811 +@SYMTestCaseDesc Multistep compression and decompression test on unicode data +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Unicode,buffersize to 8 +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test27L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0811 ")); + TPtrC8 ptr8(original); + TPtr ptr16(originalU,256); + ptr16.Copy(ptr8); + + TTestFlags flags(TTestFlags::Unicode,8); + TPtrC8(REINTERPRET_CAST(TUint8 *,originalU),ptr16.Size()); + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0812 +@SYMTestCaseDesc Multistep compression and decompression test on unicode data using a unicode dictionary +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Dictionary|TTestFlags::Unicode,buffersize to 8 +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test28L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0812 ")); + TPtrC8 ptr8(original); + TPtr ptr16(originalU,256); + ptr16.Copy(ptr8); + + TPtrC8 dptr8(dictionary); + TPtr dptr16(dictionaryU,256); + dptr16.Copy(dptr8); + + + TTestFlags flags(TTestFlags::Dictionary|TTestFlags::Unicode,8); + flags.iDictionary.Set(REINTERPRET_CAST(TUint8*, dictionaryU),dptr16.Size()); + + TPtrC8(REINTERPRET_CAST(TUint8 *,originalU),ptr16.Size()); + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0813 +@SYMTestCaseDesc Multistep compression and decompression test on unicode data using an ASCII dictionary +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Dictionary|TTestFlags::Unicode,buffersize to 8 +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test29L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0813 ")); + TPtrC8 ptr8(original); + TPtr ptr16(originalU,256); + ptr16.Copy(ptr8); + + TTestFlags flags(TTestFlags::Dictionary|TTestFlags::Unicode,8); + flags.iDictionary.Set(dictionary,sizeof(dictionary)); + + TPtrC8(REINTERPRET_CAST(TUint8 *,originalU),ptr16.Size()); + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0814 +@SYMTestCaseDesc Tests the percentage of completion during multistep compression/decompression +@SYMTestPriority High +@SYMTestActions Set the test flags to TTestFlags::Percent,buffersize to 8 +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test30L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0814 ")); + TTestFlags flags(TTestFlags::Percent,8); + + CompressDecompressL(flags); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0815 +@SYMTestCaseDesc Single step compression and decompression test +@SYMTestPriority High +@SYMTestActions Calls up CEZCompressor::CompressL(),CEZCompressor::DecompressL() test +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test31L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0815 ")); + TPtrC8 originalD(original,sizeof(original)); + TPtr8 compressedD(compressed,0,256); + TPtr8 uncompressedD(uncompressed,0,256); + CEZCompressor::CompressL(compressedD,originalD); + CEZDecompressor::DecompressL(uncompressedD,compressedD); + + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + TPtr ptr16(output,256); + ptr16.Copy(uncompressedD); + Test.Printf(ptr16); + Test.Printf(_L("\n")); + Test(originalD.Compare(uncompressedD) == 0,__LINE__); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0816 +@SYMTestCaseDesc Single step compression test when inadequate output buffer is provided +@SYMTestPriority High +@SYMTestActions Check for EZlibErrBuf buffer error flag +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test32() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0816 ")); + TPtrC8 originalD(original,sizeof(original)); + TPtr8 compressedD(compressed,0,1); + + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + + TRAPD(err,CEZCompressor::CompressL(compressedD,originalD)); + // Buffer error + Test(err == KEZlibErrBuf); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0817 +@SYMTestCaseDesc Single step decompression test when inadequate output buffer is provided +@SYMTestPriority High +@SYMTestActions Check for EZlibErrBuf buffer error flag +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ + +void Test33L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0817 ")); + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + TPtrC8 originalD(original,sizeof(original)); + TPtr8 compressedD(compressed,0,256); + TPtr8 uncompressedD(uncompressed,0,1); + CEZCompressor::CompressL(compressedD,originalD); + TRAPD(err,CEZDecompressor::DecompressL(uncompressedD,compressedD)); + // Buffer error + Test(err == KEZlibErrBuf); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-0818 +@SYMTestCaseDesc Testing graceful exit for zlib 1.1.3 decompression bug +@SYMTestPriority High +@SYMTestActions Check for buffer error after inflation +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void Test34L() + { + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0818 ")); + // 00000720.png contains specially crafted data block that exposes bug in 1.1.3 + // decompression algorithm. Causes InflateL() to return Z_BUF_ERROR. + #if !defined(__WINS__) + _LIT(KInputFile, "z:\\test\\png\\00000720.png"); + #else + _LIT(KInputFile, "c:\\test\\png\\00000720.png"); + #endif + _LIT(KTempDirectory, "c:\\test\\temp\\"); + RFile input, output, tempInput; + RFs rfs; + rfs.Connect(); + rfs.MkDirAll(KTempDirectory); + + TInt res = input.Open(rfs, KInputFile, EFileStream | EFileRead | EFileShareAny); + Test(res==KErrNone); + CleanupClosePushL(input); + + TFileName filename; + TBuf8<1024> readBuf; + TInt fileLen; + input.Size(fileLen); + res = input.Read(8,readBuf,fileLen); + Test(res==KErrNone); + + res = tempInput.Temp(rfs, KTempDirectory, filename, EFileStream | EFileWrite | EFileShareExclusive); + Test(res==KErrNone); + CleanupClosePushL(tempInput); + res = tempInput.Write(readBuf, fileLen-8); // Create temporary file without the 8 byte PNG header. + Test(res==KErrNone); + + CEZFileBufferManager *fb = CEZFileBufferManager::NewLC(tempInput, output, 4096); + CEZDecompressor *inf = CEZDecompressor::NewLC(*fb); + + TRAPD(err, while (inf->InflateL()){}); + //CEZDecompressor::InflateL() leaves + Test (err==KEZlibErrBuf); + + tempInput.Close(); + User::LeaveIfError(rfs.Delete(filename)); + input.Close(); + CleanupStack::PopAndDestroy(4); + } + +#if !(defined(__WINSCW__) || defined (_DEBUG)) +void DecompressFileL(const TDesC& aFilePath, RFs& aFs, TInt aTimingLimit) +{ + _LIT(KTempDirectory, "c:\\test\\temp\\"); + aFs.MkDirAll(KTempDirectory); + + RFile inputFile, tempFile; + //open the input compressed file + TInt res = inputFile.Open(aFs, aFilePath, EFileStream | EFileRead | EFileShareExclusive); + Test(res==KErrNone); + CleanupClosePushL(inputFile); + + //create a temporary file to be used as an output of the decompressor + TFileName filename; + res = tempFile.Temp(aFs, KTempDirectory, filename, EFileStream | EFileWrite | EFileShareExclusive); + Test(res==KErrNone); + CleanupClosePushL(tempFile); + + //decompress the data from the input file several times + TInt startTime = User::FastCounter(); + for (TInt i = 0; i<10; i++) + { + TInt position = 0; + inputFile.Seek(ESeekStart,position); + CEZFileBufferManager *fb = CEZFileBufferManager::NewLC(inputFile, tempFile, 4096); + //create a decompressor object based on the file buffer manager + CEZDecompressor *decompressor = CEZDecompressor::NewLC(*fb); + TRAP(res, while (decompressor->InflateL()){}); + Test(res==KErrNone); + CleanupStack::PopAndDestroy(2); + } + TInt endTime = User::FastCounter(); + + //close input and temporary file + CleanupStack::PopAndDestroy(2); + //delete temporary file + aFs.Delete(filename); + + TReal netTime = FastCountToMilliseconds(endTime-startTime); + _LIT(KLogLine,"netTime =%f\n"); + Test.Printf(KLogLine,netTime); + + if (aTimingLimit) + { + Test(netTime <= aTimingLimit); + } + else + { + Test.Printf(_L("Timings results are only checked on the RAM configuration of H2 and H4 HRP\n")); + } +} +#endif + +/** +@SYMTestCaseID SYSLIB-EZLIB-CT-3426 +@SYMTestCaseDesc Testing EZlib decompressor performance after enforcing compiler optimisation +@SYMTestPriority Medium +@SYMTestActions This test uses several typical pieces of compressed + image data as an input and inflates them 10 times. + The total duration of this operation is measured and + compared against a benchmarking limit. Only performed + on UREL builds running on H2 and H4 hardware. +@SYMTestExpectedResults Time spent on decompression should be less than a preset limit. +@SYMREQ REQ7363 +*/ + +void Test35L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-3426 ")); +#if !(defined(__WINSCW__) || defined (_DEBUG)) + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + _LIT(KInputFile1, "z:\\test\\png\\compressed_data1");//A small-sized picture with + //transparent background which + //represents typical UI component + //icon. + + _LIT(KInputFile2, "z:\\test\\png\\compressed_data2");//Medium-sized picture with a + //single image typical for a UI + //theme background image + + _LIT(KInputFile3, "z:\\test\\png\\compressed_data3");//Medium-sized picture with + //multiple small images on it + //typical for a sheet of UI + //component skins + + _LIT(KInputFile4, "z:\\test\\png\\compressed_data4");//Large-sized photo image + + RFs rfs; + rfs.Connect(); + CleanupClosePushL(rfs); + + // determine media type of C drive + TDriveInfo driveInf; + TInt res = rfs.Drive(driveInf, EDriveC); + Test(res==KErrNone); + + TInt timingLimit1 = 0; + TInt timingLimit2 = 0; + TInt timingLimit3 = 0; + TInt timingLimit4 = 0; + // only check benchmarks if running on hardware, with UREL + RAM build (i.e. not NAND) + if (driveInf.iType == EMediaRam) + { + TInt muid = 0; + res= HAL::Get(HAL::EMachineUid, muid); + Test(res==KErrNone); + switch (muid) + { + case HAL::EMachineUid_OmapH2: + timingLimit1 = 350; + timingLimit2 = 1650; + timingLimit3 = 2900; + timingLimit4 = 2750; + break; + case HAL::EMachineUid_OmapH4: + timingLimit1 = 200; + timingLimit2 = 850; + timingLimit3 = 1400; + timingLimit4 = 1500; + break; + default: + break; + } + } + + DecompressFileL(KInputFile1, rfs, timingLimit1); + DecompressFileL(KInputFile2, rfs, timingLimit2); + DecompressFileL(KInputFile3, rfs, timingLimit3); + DecompressFileL(KInputFile4, rfs, timingLimit4); + CleanupStack::PopAndDestroy(); +#else + Test.Printf(_L("This test is only performed on hardware UREL builds\n")); +#endif + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-UT-3684 +@SYMTestCaseDesc Test the memory deallocation of the CEZFileBufferManager object to ensure that + there is no memory leak on success or failure of file compression and decompression +@SYMTestPriority High +@SYMTestActions Compressing and Decompressing a png image using CEZCompressor::InflateL() and + CEZDecompressor::DeflateL() +@SYMTestExpectedResults Test must not fail and memory must not leak afterdeallocating CEZFileBufferManager + object (fb) +@SYMDEF DEF109756 +*/ +void Test36L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-3684 ")); + Test.Printf(_L("\n")); + Test.Printf(KSeparator); + //Set the path of input file and output files + #if !defined(__WINS__) + _LIT(KInputFile, "z:\\test\\png\\00000720.png"); + #else + _LIT(KInputFile, "c:\\test\\png\\00000720.png"); + #endif + _LIT(KOutputFile, "c:\\test\\temp\\00000720.z"); + _LIT(KUncompressedFile, "c:\\test\\temp\\000007201"); + + RFs rfs; + rfs.Connect(); + CleanupClosePushL(rfs); + + TPtrC inputFile(KInputFile); + TPtrC outputFile(KOutputFile); + TPtrC uncompressedFile(KUncompressedFile); + + RFile input; + RFile output; + TInt err; + //Open the PNG file for compressing + User::LeaveIfError(input.Open(rfs, inputFile,EFileStream | EFileRead | EFileShareAny)); + CleanupClosePushL(input); + + //Create file to store output of file compressing + err = output.Create(rfs, outputFile,EFileStream | EFileWrite | EFileShareExclusive); + if (err == KErrAlreadyExists)//Just in case if the output file already exists then open it. + User::LeaveIfError(output.Open(rfs, outputFile,EFileStream | EFileWrite | EFileShareExclusive)); + else + User::LeaveIfError(err); + CleanupClosePushL(output); + +__UHEAP_MARK; + //Create and assign the CEZFileBufferManager object 'fb' as the compressor's buffer manager + CEZFileBufferManager *fb = CEZFileBufferManager::NewLC(input,output,16384); + CEZCompressor *def = CEZCompressor::NewLC(*fb); + + while (def->DeflateL()){/*do nothing*/} + + CleanupStack::PopAndDestroy(def); + CleanupStack::PopAndDestroy(fb); +__UHEAP_MARKEND; + + CleanupStack::PopAndDestroy(&output); + CleanupStack::PopAndDestroy(&input); + //Now open the compressed file for decompressing + User::LeaveIfError(input.Open(rfs, outputFile,EFileStream | EFileRead | EFileShareAny)); + CleanupClosePushL(input); + + //Create file to store output of decompressing + err = output.Create(rfs, uncompressedFile,EFileStream | EFileWrite | EFileShareExclusive); + if (err == KErrAlreadyExists)//Just in case if the output file already exists then open it. + User::LeaveIfError(output.Open(rfs, uncompressedFile,EFileStream | EFileWrite | EFileShareExclusive)); + else + User::LeaveIfError(err); + + CleanupClosePushL(output); + +__UHEAP_MARK; + //Create and assign the CEZFileBufferManager object 'fb' as the decompressor's buffer manager + fb = CEZFileBufferManager::NewLC(input,output,16384); + CEZDecompressor *inf = CEZDecompressor::NewLC(*fb); + + while (inf->InflateL()){/*do nothing*/} + + CleanupStack::PopAndDestroy(inf); + CleanupStack::PopAndDestroy(fb); +__UHEAP_MARKEND; + input.Close(); + output.Close(); + + CleanupStack::PopAndDestroy(&output); + CleanupStack::PopAndDestroy(&input); + CleanupStack::PopAndDestroy(&rfs); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4298 +@SYMTestCaseDesc Test CEZZStream functions through CEZCompressor class e.g. + Adler32(), AvailIn(), AvailOut() +@SYMTestPriority High +@SYMTestActions 1. Compress stream of data using CEZCompressor::NewLC() & CEZCompressor::DeflateL() + 2. Call CEZCompressor::Adler32() to get the checksum value of the uncompressed data + 3. Call CEZCompressor::AvailIn() to get the number of bytes available at the next input byte + 4. Call CEZCompressor::AvailOut() to get the remaining free space at next output byte target +@SYMTestExpectedResults The test succeeds with no errors i.e. KErrNone +@SYMDEF REQ8024 +*/ + +void TestCEZCompressorMethodsL() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB2-UT-4298 ")); + CBufferManager *bm; + TInt sourceSize; + + sourceSize = sizeof(original); + bm = CBufferManager::NewLC(original,sourceSize,compressed,256,8); + CEZCompressor *compressor = CEZCompressor::NewLC(*bm); + + TInt32 adler32; + TInt availIn; + TInt availOut; + + while(compressor->DeflateL()){/*do nothing*/} + + adler32 = compressor->Adler32(); + Test(adler32 > 0); + + availIn = compressor->AvailIn(); + Test(availIn == 0); + + availOut = compressor->AvailOut(); + Test(availOut > 0); + + CleanupStack::PopAndDestroy(compressor); + CleanupStack::PopAndDestroy(bm); + } + +/** +@SYMTestCaseID SYSLIB-EZLIB2-UT-4300 +@SYMTestCaseDesc TTest Zlibapiwrapper.cpp exported API's like inflate, + deflate, compress, decompress +@SYMTestPriority High +@SYMTestActions Call the exported C APIs of Zlibapiwrapper.cpp + Note: This is done to check if the C APIs of zlib.lib + are called through ezlib.lib. +@SYMTestExpectedResults All exported C API's should be called (i.e. run a basic scenario + of compressing some data) & test must not fail +@SYMDEF REQ8024 +*/ + +void TestZlibapiwrapperAPIL() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB2-UT-4300 ")); + z_stream deflateStream; + const char inputData[] = "inputData!"; // data to compress + uLong inputDataLength = (uLong)sizeof(inputData) + 1; + Byte *compressedDataBuffer; // output buffer + //The buffer size is kept as 50 but incase the input data is changed.. + //...the buffer size also has to be increased accordingly + TInt compressedDataBufferLength = 50; + + // Allocate memory for output buffer + compressedDataBuffer = (Byte*)User::AllocZ(compressedDataBufferLength); + Test(compressedDataBuffer != Z_NULL); + CleanupStack::PushL(compressedDataBuffer); + + // Initialise the stream + deflateStream.zalloc = (alloc_func)0; + deflateStream.zfree = (free_func)0; + deflateStream.opaque = (voidpf)0; + + int level = Z_DEFAULT_COMPRESSION; + int err = 0; + int flush = 0; + + err = deflateInit(&deflateStream, level); + + if(err != Z_OK) + { + deflateEnd(&deflateStream); + Test(err == Z_OK); + } + + + // Compress data in the input buffer + deflateStream.next_in = (Byte*)inputData; + deflateStream.next_out = compressedDataBuffer; + + do + { + if (deflateStream.total_in < inputDataLength) + { + deflateStream.avail_in = 1; // force small buffer + } + + flush = (deflateStream.total_in == inputDataLength) ? Z_FINISH : Z_NO_FLUSH; + + // run deflate() on input until output buffer not full, finish + // compression if all of source has been read in + do + { + if (deflateStream.total_out < compressedDataBufferLength) + { + deflateStream.avail_out = 1; // force small buffer + } + + err = deflate(&deflateStream, flush); + if(err != Z_OK && err != Z_STREAM_END) + { + deflateEnd(&deflateStream); + Test(err == Z_OK || err == Z_STREAM_END); + } + } while(deflateStream.avail_out == 0 && err == Z_OK); + } while(err != Z_STREAM_END); + + deflateEnd(&deflateStream); + CleanupStack::PopAndDestroy(compressedDataBuffer); + + } + +/** +@SYMTestCaseID SYSLIB-EZLIB-UT-4001 +@SYMTestCaseDesc Test for DEF112672 - Panic ZLIB 11 - when installing the sisx file. + The test attempts to decompress a buffer with the "Dictionary" flag set + but with NULL dictionary buffer. The test should not cause an assert in the EZLib library. +@SYMTestPriority Normal +@SYMTestActions Test for DEF112672 - Panic ZLIB 11 - when installing the sisx file. +@SYMTestExpectedResults Test must not fail +@SYMDEF DEF112672 +*/ + +void DEF112672L() + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-UT-4001 ")); + TTestFlags flags(TTestFlags::Dictionary, 8); + flags.iDictionary.Set(dictionary, sizeof(dictionary)); + CompressBufferL(flags); + flags.iDictionary.Set(0, 0); + TRAPD(err, DecompressBufferL(flags)); + Test(err == KEZlibErrData); + } + +void RunTestL() + { + for (TInt testNum=1; testNum buf; + buf.Format(KTestNum, testNum); + Test.Next(buf); + _LIT(KStrMsg,"%S"); + Test.Printf(KStrMsg, testTable[testNum].iDescription); + testTable[testNum].iFn(); + __UHEAP_MARKEND; + } + DEF112672L(); + } + +GLDEF_C TInt E32Main() + { + CTrapCleanup* cleanup=CTrapCleanup::New(); + Test.Title(); + _LIT(KStartMsg,"Starting Tests.."); + Test.Start(KStartMsg); +__UHEAP_MARK; + TRAPD(err,RunTestL()); + Test (err==KErrNone); + Test.End(); + Test.Close(); +__UHEAP_MARKEND; + delete cleanup; + return KErrNone; + }