// 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 <ezgzip.h>

#if !defined(__WINS__)

_LIT(KPath, "Z:\\test\\gzip\\");

#else

_LIT(KPath, "C:\\test\\gzip\\");

#endif

_LIT(KOutputFilePath, "C:\\test\\gzip\\");

_LIT(KInputFile, "Hello.txt");

_LIT(KCompressFile,"Hello.gz");

_LIT(KDecompressFile,"Hello_Decompress.txt");

static RTest				test(_L("gziptest.exe"));

static RFs					TheFs;

static CTrapCleanup* 		TheTrapCleanup 		= NULL;

static TInt 				TheBufferSize		= 500;

static TFileName 			TheInputFile(KInputFile);

static TFileName 			TheCompressFile(KCompressFile);

static TFileName 			TheDecompressFile(KDecompressFile);

static void CompressFileL(TFileName& aInputFile, TFileName& aCompressFile, TInt aBufferSize = TheBufferSize);

static void DecompressFileL(TFileName& aInputFile, TFileName& aDecompressFile, TInt aBufferSize = TheBufferSize);

static void CompareFileDataL(TFileName& aSourceFile, TFileName& aDestFile, TInt& aCompare);

static void ThreadForPanicTest(TThreadFunction aPanicThreadFunc);

inline void DeleteFile(TFileName& aFileName, TBool aPathSpecified = EFalse)

	{

	TFileName deleteFilePath;

	if(!aPathSpecified)

		{

		deleteFilePath.Append(KOutputFilePath);

		}

	deleteFilePath.Append(aFileName);

	TRAPD(error, TheFs.Delete(deleteFilePath));

	if(error != KErrNone)

		test.Printf(_L("File not deleted: %S"), &deleteFilePath);

	}

static void CompressFileL(TFileName& aInputFile, TFileName& aCompressFile, TInt aBufferSize)

	{

	TFileName inputFilePath(KPath);

	inputFilePath.Append(aInputFile);

	TFileName compressFilePath(KOutputFilePath);

	compressFilePath.Append(aCompressFile);

	RFile input;

	User::LeaveIfError(input.Open(TheFs,inputFilePath, EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(input);

	CEZFileToGZip *fileToGzip = NULL;

	TRAPD(error, fileToGzip = CEZFileToGZip::NewL(TheFs, compressFilePath, input, aBufferSize));

	test(error == KErrNone);

	CleanupStack::PushL(fileToGzip);

	while(fileToGzip->DeflateL()){/*do nothing*/}

	CleanupStack::PopAndDestroy(2);

	}

static void DecompressFileL(TFileName& aCompressFile, TFileName& aDecompressFile, TInt aBufferSize)

	{

	TFileName compressFilePath(KPath);

	compressFilePath.Append(aCompressFile);

	TFileName decompressFilePath(KOutputFilePath);

	decompressFilePath.Append(aDecompressFile);

	RFile output;

	User::LeaveIfError(output.Replace(TheFs, decompressFilePath, EFileStream | EFileWrite | EFileShareExclusive));

	CleanupClosePushL(output);

	CEZGZipToFile *gzipToFile = NULL;

	TRAPD(error, gzipToFile = CEZGZipToFile::NewL(TheFs, compressFilePath, output, aBufferSize));

	test(error == KErrNone);

	CleanupStack::PushL(gzipToFile);

	while (gzipToFile->InflateL()){/*do nothing*/}

	CleanupStack::PopAndDestroy(2);

	}

static void CompareFileDataL(TFileName& aSourceFile, TFileName& aDestFile, TInt& aCompare)

	{

	TFileName sourceFilePath(KPath);

	sourceFilePath.Append(aSourceFile);

	TFileName destFilePath(KOutputFilePath);

	destFilePath.Append(aDestFile);

	RFile source;

	User::LeaveIfError(source.Open(TheFs,sourceFilePath, EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(source);

	TInt sourceSize;

	source.Size(sourceSize);

	test(sourceSize > 0);

	HBufC8* sourceData = NULL;

	TRAPD(error, sourceData = HBufC8::NewMaxL(sourceSize));

	test(error == KErrNone);

	CleanupStack::PushL(sourceData);

	TPtr8 tSourceBufPtr = sourceData->Des();

	User::LeaveIfError(source.Read(0, tSourceBufPtr, sourceSize));

	RFile dest;

	User::LeaveIfError(dest.Open(TheFs,destFilePath, EFileStream | EFileWrite | EFileShareExclusive));

	CleanupClosePushL(dest);

	TInt destSize;

	dest.Size(destSize);

	test(destSize > 0);

	HBufC8* destData = NULL;

	TRAP(error, destData = HBufC8::NewMaxL(destSize));

	test(error == KErrNone);

	CleanupStack::PushL(destData);

	TPtr8 tDestBufPtr = destData->Des();

	User::LeaveIfError(dest.Read(0, tDestBufPtr, destSize));

	aCompare = sourceData->Compare(*destData);

	CleanupStack::PopAndDestroy(4);

	}

static void ThreadForPanicTest(TThreadFunction aPanicThreadFunc)

	{

   	TRequestStatus threadStatus(KRequestPending);

   	TRequestStatus threadStatus1(KRequestPending); 

   	RThread thread;

	TBool justInTime = User::JustInTime();

	User::SetJustInTime(EFalse);

	test.Printf(_L("Starting thread for invalid panic test...\n"));

	TInt err=thread.Create(	_L("Panic thread"),aPanicThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL,EOwnerThread );

	test.Printf(_L("Thread Creation returned following error code: %d \n"), err);

	test(err == KErrNone);

	thread.Logon(threadStatus);

	thread.Resume();

	User::WaitForRequest(threadStatus);

#ifdef _DEBUG

	__ASSERT_ALWAYS(thread.ExitType() == EExitPanic,User::Panic(_L("Thread panic mismatch."),KErrGeneral));

	test.Printf(_L("Invalid Panic test completed successfully for udeb build.\n"));

#else

	test.Printf(_L("Invalid Panic test completed successfully for urel build.\n"));

#endif

	thread.Logon(threadStatus1);

	thread.Kill(KErrNone);

	User::WaitForRequest(threadStatus1);

	test(threadStatus1 == KErrNone);

    CLOSE_AND_WAIT(thread);

	User::SetJustInTime(justInTime);

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4286

@SYMTestCaseDesc	    To ensure a file can be compressed to a gzip file and then correctly 

						decompressed back to its original state using classes from gzip.cpp.  

						Overwrite output file to verify existing file can be re-used.

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Open existing test file and pass it to CEZFileToGZip::NewL() & 

							compress using CEZFileToGZip::DeflateL() function

						2.	Create or open output decompressed file and pass compressed file to

							CEZGZipToFile::NewL() & decompress using CEZGZipToFile::InflateL() function

						3.	Compare original and new file, they should be identical

						4.	Repeat Steps 1 - 3 overwriting existing compressed output file

@SYMTestExpectedResults Original test file should be the same as the file generated 

						after decompressing it & the test must not fail

@SYMDEF                 REQ8024

*/

void TestCompressDecompressGzip()

	{

	TRAPD(error, CompressFileL(TheInputFile, TheCompressFile));

	test(error == KErrNone);

	TRAP(error, DecompressFileL(TheCompressFile, TheDecompressFile));

	test(error == KErrNone);

	TInt compare;

	//compare the files

	TRAP(error, CompareFileDataL(TheInputFile, TheDecompressFile, compare));

	test(error == KErrNone);

	if(compare == 0)

		RDebug::Printf("Input file data is same as the Decompressed file data");

	else

		RDebug::Printf("Input file data differs from Decompressed file data");

#if !defined(__WINS__)

	DeleteFile(TheCompressFile);

	DeleteFile(TheDecompressFile);

#endif

	//Compress & decompress the same file again to overwrite the existing file & 

	//..to verify that the existing files can be re-used

	TRAP(error, CompressFileL(TheInputFile, TheCompressFile));

	test(error == KErrNone);

	TRAP(error, DecompressFileL(TheCompressFile, TheDecompressFile));

	test(error == KErrNone);

#if !defined(__WINS__)

	DeleteFile(TheCompressFile);

	DeleteFile(TheDecompressFile);

#endif

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4287

@SYMTestCaseDesc	    To ensure a file can be compressed to a gzip file and then correctly 

						decompressed back using buffer size as small & big.

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Open existing test file and pass it to CEZFileToGZip::NewL() & 

							compress using CEZFileToGZip::DeflateL() with buffer size as "11"

						2.	Create or open output decompressed file and pass compressed file 

							to CEZGZipToFile::NewL() & decompress using CEZGZipToFile::InflateL() 

							with buffer size as "10"

						3.	Repeat Steps 1 & 2 using buffer size as 10 times the file size

@SYMTestExpectedResults Files should be compressed with no errors i.e. KErrNone & the test must not fail 

@SYMDEF                 REQ8024

*/

void TestOutputBuffSize()

	{	

	TRAPD(error, CompressFileL(TheInputFile, TheCompressFile, 10));

	test(error == KErrNone);

	TRAP(error, DecompressFileL(TheCompressFile, TheDecompressFile, 10));

	test(error == KErrNone);

	TInt bufferSize = 10 * TheBufferSize;

#if !defined(__WINS__)

	DeleteFile(TheCompressFile);

	DeleteFile(TheDecompressFile);

#endif

	//Compress & decompress the same file again to overwrite the existing file & 

	//..to verify that the existing files can be re-used & with buffer size as big

	TRAP(error, CompressFileL(TheInputFile, TheCompressFile, bufferSize));

	test(error == KErrNone);

	TRAP(error, DecompressFileL(TheCompressFile, TheDecompressFile, bufferSize));

	test(error == KErrNone);

#if !defined(__WINS__)

	DeleteFile(TheCompressFile);

	DeleteFile(TheDecompressFile);

#endif

	}

TInt RfileInitForCEZFileToGZip(TAny*)

	{

	RFile rfile;

	TFileName compressFilePath(KOutputFilePath);

	compressFilePath.Append(TheCompressFile);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAPD(error, CEZFileToGZip::NewL(TheFs, compressFilePath, rfile, TheBufferSize));

	delete cleanup;

	return error;

	}

TInt RfileInitForCEZGZipToFile(TAny*)

	{

	RFile rfile;

	TFileName compressFilePath(KOutputFilePath);

	compressFilePath.Append(TheCompressFile);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAPD(error, CEZGZipToFile::NewL(TheFs, compressFilePath, rfile, TheBufferSize));

	delete cleanup;

	return error;

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4288

@SYMTestCaseDesc	    CEZFileToGZip & CEZGZipToFile class initialisation fails when 

						invalid input RFile object supplied

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Pass NULL RFile input parameter to CEZFileToGZip::NewL()

						2.	Pass NULL RFile input parameter to CEZGZipToFile::NewL()

@SYMTestExpectedResults NewL() method should panic & the test must not fail 

@SYMDEF                 REQ8024

*/

void TestRFileInitialisation()

	{

	test.Printf(_L("Panic Thread: CEZFileToGzip Class initialisation fails when invalid input rfile supplied"));	

	ThreadForPanicTest(RfileInitForCEZFileToGZip);

	test.Printf(_L("Panic Thread: CEZGZipToFile Class initialisation fails when invalid input rfile supplied"));

	ThreadForPanicTest(RfileInitForCEZGZipToFile);

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4289

@SYMTestCaseDesc	    CEZFileToGZip, CEZGZipToFile class initialisation fails 

						when invalid output filename supplied

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Pass invalid filename output parameter to CEZFileToGZip::NewL()

						2.	Pass invalid filename output parameter to CEZGZipToFile::NewL() 

						Note: Filename contains invalid characters

@SYMTestExpectedResults NewL() method should leave with error message & the test must not fail 

@SYMDEF                 REQ8024

*/	

void TestInvalidFilenameL()

	{

	_LIT(KInvalidGzip, "*******.gz");

	TFileName invalidGzip(KOutputFilePath);

	invalidGzip.Append(KInvalidGzip);

	_LIT(KInvalidFile, "*******.txt");

	TFileName invalidFile(KOutputFilePath);

	invalidFile.Append(KInvalidFile);

	TFileName inputFilePath(KPath);

	inputFilePath.Append(TheInputFile);

	RFile input;

	User::LeaveIfError(input.Open(TheFs,inputFilePath,EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(input);

	TRAPD(error, CEZFileToGZip::NewL(TheFs, invalidGzip, input, TheBufferSize));

	test(error != KErrNone);

	CleanupStack::PopAndDestroy(1);

	RFile output;

	TInt err = output.Create(TheFs, invalidFile,EFileStream | EFileWrite | EFileShareExclusive);

	test(error != KErrNone);

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4290

@SYMTestCaseDesc	    Ensure if output file exists and is read only then it cannot be 

						overwritten with CEZFileToGZip & CEZGZipToFile class

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Pass existing read only output filename parameter to CEZFileToGZip::NewL()

						2.	Pass existing read only output filename parameter to CEZGZipToFile::NewL() 

						& decompress using CEZGZipToFile::InflateL()

@SYMTestExpectedResults CEZFileToGZip::NewL() method should leave with error message, CEZGZipToFile::Inflate()

						should leave with error message & the test must not fail 

@SYMDEF                 REQ8024

*/	

void TestOverwriteOutputFileL()

	{

	_LIT(KReadOnlyGzip, "Hello_Read_Only.gz");	

	TFileName readOnlyNewGZip(KOutputFilePath);

	readOnlyNewGZip.Append(KReadOnlyGzip);

	_LIT(KReadOnlyFile, "Hello_Read_Only.txt");

	TFileName readOnlyNewFile(KOutputFilePath);

	readOnlyNewFile.Append(KReadOnlyFile);

	CFileMan* fMan=CFileMan::NewL(TheFs);

	test(fMan!=NULL);

	CleanupStack::PushL(fMan);

#if !defined(__WINS__)

	TFileName readOnlyOldGZip(KPath);

	readOnlyOldGZip.Append(KReadOnlyGzip);

	TFileName readOnlyOldFile(KPath);

	readOnlyOldFile.Append(KReadOnlyFile);

	RFile source;

	User::LeaveIfError(source.Open(TheFs,readOnlyOldGZip, EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(source);

	TRAPD(error, fMan->Copy(source, readOnlyNewGZip));

	test(error == KErrNone);

	RFile source1;

	User::LeaveIfError(source1.Open(TheFs,readOnlyOldFile, EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(source1);

	TRAP(error, fMan->Copy(source1, readOnlyNewFile));

	test(error == KErrNone);

	CleanupStack::PopAndDestroy(2);

#endif

	TFileName inputFilePath(KPath);

	inputFilePath.Append(TheInputFile);

	RFile input;

	User::LeaveIfError(input.Open(TheFs,inputFilePath,EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(input);

	//setting attributes to read only for readOnlyGZip & readOnlyFile

   	TInt err = fMan->Attribs(readOnlyNewGZip, KEntryAttReadOnly, 0, 0);

	test(err == KErrNone);

	err = fMan->Attribs(readOnlyNewFile, KEntryAttReadOnly, 0, 0);

	test(err == KErrNone);

	TRAP(err, CEZFileToGZip::NewL(TheFs, readOnlyNewGZip, input, TheBufferSize));

	test(err != KErrNone);

	RFile output;

	User::LeaveIfError(output.Open(TheFs,readOnlyNewFile,EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(output);

	CEZGZipToFile * gzipToFile = NULL;

	TRAP(err, gzipToFile = CEZGZipToFile::NewL(TheFs, readOnlyNewGZip, output, TheBufferSize));

	test(err == KErrNone);

	CleanupStack::PushL(gzipToFile);

	while (err == KErrNone)

	{

		TRAP(err, gzipToFile->InflateL());

	}

	test(err != KErrNone); 	

	CleanupStack::PopAndDestroy(4);

	//removing the read only attrib before deleting the file

   	fMan=CFileMan::NewL(TheFs);

   	test(fMan!=NULL);

   	CleanupStack::PushL(fMan);

   	err = fMan->Attribs(readOnlyNewGZip, 0, KEntryAttReadOnly, 0);

	test(err == KErrNone);

	err = fMan->Attribs(readOnlyNewFile, 0, KEntryAttReadOnly, 0);

	test(err == KErrNone);

	CleanupStack::PopAndDestroy(1);

#if !defined(__WINS__)

	DeleteFile(readOnlyNewGZip, ETrue);

	DeleteFile(readOnlyNewFile, ETrue);

#endif

	}

TInt RFSInitForCEZFileToGZipL(TAny*)

	{

	TFileName inputFilePath(KPath);

	inputFilePath.Append(TheInputFile);

	RFile input;

	User::LeaveIfError(input.Open(TheFs,inputFilePath,EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(input);

	TFileName compressFilePath(KOutputFilePath);

	compressFilePath.Append(TheCompressFile);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	RFs rfs; 

	TRAPD(error, CEZFileToGZip::NewL(rfs, compressFilePath, input, TheBufferSize));

	delete cleanup;

	CleanupStack::PopAndDestroy(1);

	return error;

	}

TInt RFSInitForCEZGZipToFileL(TAny*)

	{

	TFileName compressFilePath(KPath);

	compressFilePath.Append(TheCompressFile);

	TFileName decompressFilePath(KOutputFilePath);

	decompressFilePath.Append(TheDecompressFile);

	RFile output;

	User::LeaveIfError(output.Replace(TheFs,decompressFilePath,EFileStream | EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(output);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	RFs rfs; 

	TRAPD(error, CEZGZipToFile::NewL(rfs, compressFilePath, output, TheBufferSize));

	delete cleanup;

	CleanupStack::PopAndDestroy(1);

	return error;

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4291

@SYMTestCaseDesc	    CEZFileToGZip & CEZGZipToFile class initialisation fails when 

						invalid RFs object is passed

@SYMTestPriority 	    High

@SYMTestActions  	    1.	Pass NULL RFs input parameter to CEZFileToGZip::NewL() 

						2.	Pass NULL RFs input parameter to CEZGZipToFile::NewL()

@SYMTestExpectedResults NewL() method should panic & the test must not fail 

@SYMDEF                 REQ8024

*/	

void TestRFSInitialisation()

	{

	test.Printf(_L("Panic Thread: CEZFileToGZip Class initialisation fails when invalid RFS object is passed"));	

	ThreadForPanicTest(RFSInitForCEZFileToGZipL);

	test.Printf(_L("Panic Thread: CEZGZipToFile Class initialisation fails when invalid RFS object is passed"));

	ThreadForPanicTest(RFSInitForCEZGZipToFileL);

	}