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

#include <f32file.h>

#include <e32test.h>

#include <ezgzip.h>

#include <ezfilebuffer.h>

#include <ezdecompressor.h>

_LIT(KTestTitle, "Decompress Test. ");

_LIT(KFileOutputPath, "c:\\test\\decompresstest\\");

_LIT(KFileInputPath, "c:\\test\\decompresstest\\testfiles\\");

RTest test(_L("decompresstest.exe"));

/* Test macro and function */

void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

    if (aValue != aExpected)

    	{

        test.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

        test.operator()(EFalse, aLine);

        }

    }

#define test2(a, b) Check(a, b, __LINE__)

void DecompressZipL(RFile &aInputFile, RFile &aOutputFile)

	{

	CEZFileBufferManager *bufferManager = CEZFileBufferManager::NewLC(aInputFile, aOutputFile);	

	CEZDecompressor *decompressor = CEZDecompressor::NewLC(*bufferManager, MAX_WBITS);

	while(decompressor->InflateL())

		{

		// Do nothing here

		}

	CleanupStack::PopAndDestroy(3);

	}

void DecompressGZipL(RFs &aFs, RFile &aOutputFile, const TFileName &aFileInputPath, const TFileName &aFileName)

	{

	aFs.SetSessionPath(aFileInputPath);

	CEZGZipToFile *decompressor = CEZGZipToFile::NewLC(aFs, aFileName, aOutputFile);

	while(decompressor->InflateL())

		{

		// Do nothing here

		}

	CleanupStack::PopAndDestroy(1);

	}

void TestDecompressL(RFs &aFs, const TFileName &aFileInputPath, const TFileName &aFileName)

	{

	test.Printf(_L("\nUsing file %S. "), &aFileName);

	// Create temporary output file and open it for writing

	TFileName outputFileName;

	RFile outputFile;

	aFs.MkDir(KFileOutputPath);

	outputFile.Temp(aFs, KFileOutputPath, outputFileName, EFileWrite);

	CleanupClosePushL(outputFile);

	// Decompress file based on whether its a gzip file or zip archive

	aFs.SetSessionPath(aFileInputPath);

	EZGZipFile gzipFile;	

	if(gzipFile.IsGzipFileL(aFs, aFileName))

		{

		// Check for memory leaks

		__UHEAP_MARK;

		TRAPD(err, DecompressGZipL(aFs, outputFile, aFileInputPath, aFileName));

		__UHEAP_MARKEND;

		switch(err)

			{

			case KEZlibErrStream:

			case KEZlibErrData:

			case KEZlibErrBuf:

			case KEZlibErrVersion:

			case KEZlibErrUnexpected:

			case KEZlibErrDeflateTerminated:

			case KEZlibErrInflateTerminated:

			case KEZlibErrInflateDictionary:

			case KEZlibErrNotGZipFile:

			case KEZlibErrInvalidCompression:

			case KEZlibErrBadGZipHeader:

			case KEZlibErrBadGZipTrailer:

			case KEZlibErrBadGZipCrc: 

				break;

			default: 

				if(err > KErrNone || err < KErrNoSecureTime)

					{

					test.Printf(_L("FAILED! error = %d"), err);

					test2(err, KErrNone);	

					}

			}

		}

	else

		{

		// Open the input file for reading

        RFile inputFile;

        aFs.SetSessionPath(aFileInputPath);

        User::LeaveIfError(inputFile.Open(aFs, aFileName, EFileRead));

        CleanupClosePushL(inputFile);

		__UHEAP_MARK;

		TRAPD(err, DecompressZipL(inputFile, outputFile));

		__UHEAP_MARKEND;

		switch(err)

			{

			case KEZlibErrStream:

			case KEZlibErrData:

			case KEZlibErrBuf:

			case KEZlibErrVersion:

			case KEZlibErrUnexpected:

			case KEZlibErrDeflateTerminated:

			case KEZlibErrInflateTerminated:

			case KEZlibErrInflateDictionary: 

				break;

			default: 

				if(err > KErrNone || err < KErrNoSecureTime)

					{

					test.Printf(_L("FAILED! error = %d"), err);

					test2(err, KErrNone);

					}

			}

			CleanupStack::PopAndDestroy(1);

		}

	CleanupStack::PopAndDestroy(1);

	// Delete temporary output file

	aFs.SetSessionPath(KFileOutputPath);

	aFs.Delete(outputFileName);

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-CT-4315

@SYMTestCaseDesc	    To test for invalid return codes, panics and memory leaks when 

                        decompressing invalid Zip archive and GZip files.

@SYMTestPriority 	    Medium

@SYMTestActions  	    1.	Create an instance of CDir and get the number of files and 

                            directories in the test file directory.

                        2.	Loop through the list of files and directories, held by CDir. 

                            a.	If the current entry is a directory navigate to it and go 

                                back to step 1.

                            b.	If the current entry is a file, open a temporary output 

                                file for writing. Then check if we have a GZip or Zip archive.

                            c.	If we have a GZip file:

                                i.	Call __UHEAP_MARK

                                ii.	Create a CEZGZipToFile passing it the open output file 

                                    and the name of the input file.

                                iii.Call InflateL as many times as needed to decompress 

                                    the input file.

                                iv.	Call __UHEAP_MARKEND

                                v.	Check any leave errors against a list of expected 

                                    errors. If an unexpected leave value is returned, panic.

                            d.	If we have a Zip archive

                                i.	Open the input file for reading.

                                ii.	Call __UHEAP_MARK.

                                iii.Create a CEZFileBufferManager passing it the open 

                                    input and output files.

                                iv.	Create a CEZDecompressor passing it the 

                                    CEZFileBufferManager and windowBits of 15.

                                v.	Call InflateL as many times as needed to decompress 

                                    the input file.

                                vi.	Call __UHEAP_MARKEND

                                vii.Check any leave errors against a list of expected 

                                    errors. If an unexpected leave value is returned, panic.

                            e.	Delete the temporary output file.

@SYMTestExpectedResults There will be no memory leaks or panics and all return codes will 

                        be the expected ones.

@SYMDEF                 REQ8024

*/

void TestL(RFs &aFs, TFileName aFileInputPath)

	{

	test.Printf(_L("\nIn directory %S. "), &aFileInputPath);

	test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB2-CT-4315 "));

	CDir *inputFiles;

	aFs.GetDir(aFileInputPath, KEntryAttNormal|KEntryAttDir, ESortByName | EDirsFirst, inputFiles);

	CleanupStack::PushL(inputFiles);

	TInt numInputFiles = inputFiles->Count();

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

		{

		TEntry entry = (*inputFiles)[i];

		// If we have a directory we need to try decompressing the files contained in it

		if(entry.IsDir())

			{

			TFileName currentDir = aFileInputPath;

			currentDir.Append(entry.iName);

			currentDir.Append(_L("\\"));

			TestL(aFs, currentDir);

			}

		else

			{

			TRAPD(err, TestDecompressL(aFs, aFileInputPath, entry.iName));

			test2(err, KErrNone);

			}

		}

	CleanupStack::PopAndDestroy(1);

	}

void RunTestL()

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TFileName filePath(KFileInputPath);

	TestL(fs, filePath);

	CleanupStack::PopAndDestroy(1);

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	test.Printf(_L("\n"));

	test.Title();

	test.Start(KTestTitle);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAPD(err, RunTestL());

	test2(err, KErrNone);

	test.End();

	test.Close();

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

	}