--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/compressionlibs/ziplib/test/rtest/ezlibtest/ezlibtest.cpp Tue Feb 02 02:01:42 2010 +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 <e32test.h>
+#include <bacline.h>
+
+#include <ezcompressor.h>
+#include <ezdecompressor.h>
+#include <ezfilebuffer.h>
+#include <ezlib.h>
+#include <hal.h>
+
+
+_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<KNumberOfTests; testNum++)
+ {
+ __UHEAP_MARK;
+ _LIT(KTestNum,"\n\nRunning Test %d\n\n");
+ TBuf<80> 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;
+ }