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