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

			{