// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\misc\t_bytepair.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32math.h>

#include <e32rom.h>

#include <e32svr.h>

#include "decompress.h"

#define BYTE_PAIR_COMPRESS_INCLUDE_IMPLEMENTATION

#include <byte_pair_compress.h>

const TInt KMaxSize = 0x1000;

const TInt KPageSize = 0x1000;

RTest test(_L("T_BYTEPAIR"));

TUint8 InputBuffer[KMaxSize];

TUint8 CompressedBuffer[4*KMaxSize];

TUint8 OutputBuffer[KMaxSize+1];

TRomHeader* RomHeader = NULL;

TInt RomOffset = 0;

TInt FailCount = 0;

TUint32 RandomState;

void PrintHex(TUint8* aBuffer, TInt aSize)

	{

	const TInt KBytesPerLine = 38;

	TBuf<KBytesPerLine * 2 + 3> buf;

	for (TInt i = 0 ; i < aSize ; )

		{

		buf.Zero();

		buf.Append(_L("  "));

		TInt nextChunk = Min(aSize - i, KBytesPerLine);

		for (TInt j = 0 ; j < nextChunk ; ++j, ++i)

			buf.AppendFormat(_L("%02x"), aBuffer[i]);

		buf.Append(_L("\n"));

		RDebug::RawPrint(buf);

		}

	}

TUint32 Random()

	{

	RandomState = RandomState * 69069 + 1;

	return RandomState;

	}

typedef void (*TGenerator)(TUint8* aDest, TInt aSize);

void GenerateUniform(TUint8* aDest, TInt aSize)

	{

	TInt value = aSize & 255;

	Mem::Fill(aDest, aSize, value);

	}

void GenerateUniformRandom(TUint8* aDest, TInt aSize)

	{

	for (TInt i = 0 ; i < aSize ; ++i)

		aDest[i] = TUint8(Random());

	}

void GenerateZipfRandom(TUint8* aDest, TInt aSize)

	{

	// Some details from http://www.cs.hut.fi/Opinnot/T-106.4000/K2007/Ohjeet/Zipf.html

	const TInt max = 255;

	TReal c;

	test_KErrNone(Math::Log(c, max + 1.0));

	for (TInt i = 0 ; i < aSize ; ++i)

		{

		int r;

		do

			{

			TReal x = Random() / TReal(KMaxTUint32);

			test_KErrNone(Math::Exp(x, x * c));

			r = (int)x - 1;

			}

		while (r > max);

		aDest[i] = TUint8(r);

		}

	}

void GenerateRomPage(TUint8* aDest, TInt aSize)

	{

	if (TUint(RomOffset + aSize) > RomHeader->iUncompressedSize)

		RomOffset = 0;

	Mem::Copy(aDest, ((TUint8*)RomHeader) + RomOffset, aSize);

	RomOffset += KPageSize;

	}

enum TTestMode

	{

	ENormal,

	EOutputBufferTooLong,

	EOutputBufferTooShort,

	ETruncatedCompressedData,

	ECorruptCompressedData,

	ERandomCompressedData

	};

void TestCompressDecompress(TGenerator aGenFunc, TInt aSize, TTestMode aMode = ENormal)

	{

	ASSERT(aSize <= KMaxSize);

	TInt compressedSize;

	if (aMode != ERandomCompressedData)

		{

		// Prepare intput data

		aGenFunc(InputBuffer, aSize);

		// Compress input data

		compressedSize = BytePairCompress(CompressedBuffer, InputBuffer, aSize);

		ASSERT(compressedSize <= KMaxSize+1);

		}

	else

		{

		// Generate random compressed data

		compressedSize = aSize;

		GenerateUniformRandom(CompressedBuffer, compressedSize);

		}

	if (aMode == ETruncatedCompressedData)

		{

		// Truncate compressed data by up to half its length

		compressedSize -= Math::Random() % (compressedSize / 2);

		}

	else if (aMode == ECorruptCompressedData)

		{

		// Corrupt a random byte of the compressed data

		TInt pos = Random() % compressedSize;

		CompressedBuffer[pos] = TUint8(Random());

		}

	// Decomress compressed data

	Mem::Fill(OutputBuffer, KMaxSize+1, 0);

	TUint8* srcNext = NULL;

	TInt outputBufferSize = aSize;

	if (aMode == EOutputBufferTooLong || aMode == ERandomCompressedData)

		outputBufferSize = KMaxSize+1;

	else if (aMode == EOutputBufferTooShort)

		outputBufferSize = aSize / 2 + 1;

	TInt decompressedSize = BytePairDecompress(OutputBuffer, outputBufferSize, CompressedBuffer, compressedSize, srcNext);

	TInt srcUsed = srcNext ? srcNext - CompressedBuffer : 0;

	// Print stats

	RDebug::Printf("%d -> %d -> %d, %d, %d", aSize, compressedSize, outputBufferSize, srcUsed, decompressedSize);

	TBool ok = ETrue;

	// Check decompressed data not larger than output buffer

	if (decompressedSize > outputBufferSize)

		ok = EFalse;

	// Check output buffer not written beyond what was reported

	if (decompressedSize >= 0 && OutputBuffer[decompressedSize] != 0)

		ok = EFalse;

	if (aMode == ETruncatedCompressedData || aMode == ECorruptCompressedData || aMode == ERandomCompressedData)

		{

		// Input corrupt, expect error or partial sucess

		// If there was an error, check it was KErrCorrupt and srcNext was set to NULL

		if (decompressedSize < 0 && (decompressedSize != KErrCorrupt || srcNext != NULL))

			ok = EFalse;	

		}

	else if (aMode == EOutputBufferTooShort)

		{

		// Input consistent, output buffer too short

		// Expect error, or initial part correctly decompressed

		if (decompressedSize < 0)

			{

			if (decompressedSize != KErrCorrupt || srcNext != NULL)

				ok = EFalse;

			}

		else

			{

			if (decompressedSize > aSize  ||

				srcUsed > compressedSize ||

				Mem::Compare(InputBuffer, decompressedSize, OutputBuffer, decompressedSize) != 0)

				ok = EFalse;

			}

		}

	else

		{

		// Input consistent, expect success

		// Check no error, correct size, all compressed input used, and output same as orignal data

		if (decompressedSize < 0 ||

			aSize != decompressedSize ||

			srcUsed != compressedSize ||

			Mem::Compare(InputBuffer, decompressedSize, OutputBuffer, decompressedSize) != 0)

			ok = EFalse;		

		}

	if (!ok)

		{

		RDebug::Printf("Failure:");

		RDebug::Printf("Input");

		PrintHex(InputBuffer, aSize);

		RDebug::Printf("Compressed");

		PrintHex(CompressedBuffer, compressedSize);

		RDebug::Printf("Output");

		PrintHex(OutputBuffer, decompressedSize);

		++FailCount;

		}

	}

TInt E32Main()

//

// Benchmark for Mem functions

//

    {

	TInt i;

    test.Title();

    test.Start(_L("T_BYTEPAIR"));

	RandomState = User::FastCounter();

	RDebug::Printf("RandomState == %08x", RandomState);

	test_Equal(0, FailCount);

	const TInt KStartSize = KMaxSize / 2;

	// Test correct operation

	test.Next(_L("Test compressing uniform data"));	

	for (i = KStartSize ; i < KMaxSize ; i += 19)

		TestCompressDecompress(GenerateUniform, i);

	test.Next(_L("Test compressing uniformly distributed random data"));				

	for (i = KStartSize + 2 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(GenerateUniformRandom, i);

	test.Next(_L("Test compressing zipf-distributed random data"));				

	for (i = KStartSize + 3 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(GenerateZipfRandom, i);

#ifdef __EPOC32__

	RomHeader = (TRomHeader*)UserSvr::RomHeaderAddress();

	TGenerator pageGen = GenerateRomPage;

#else

	TGenerator pageGen = GenerateZipfRandom;

#endif

	test.Next(_L("Test compressing pages"));				

	for (i = 0 ; i < 100 ; ++i)

		TestCompressDecompress(pageGen, KPageSize);

	// Test failure modes

	test.Next(_L("Test output buffer too short"));				

	for (i = KStartSize ; i < KMaxSize ; i += 19)

		TestCompressDecompress(pageGen, i, EOutputBufferTooShort);

	test.Next(_L("Test output buffer too long"));				

	for (i = KStartSize + 1 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(pageGen, i, EOutputBufferTooLong);

	test.Next(_L("Test truncated compressed data"));				

	for (i = KStartSize + 2 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(pageGen, i, ETruncatedCompressedData);

	test.Next(_L("Test corrupt compressed data "));				

	for (i = KStartSize + 3 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(pageGen, i, ECorruptCompressedData);

	test.Next(_L("Test random compressed data"));				

	for (i = KStartSize + 4 ; i < KMaxSize ; i += 19)

		TestCompressDecompress(GenerateUniformRandom, i, ERandomCompressedData);

	test_Equal(0, FailCount);

    test.End();

	return(KErrNone);

    }