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