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

 	}