// 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 "zipfile.h"

#include <e32cons.h>

#include <s32file.h>

#include <s32strm.h> 

#include <utf.h>

#include <e32test.h>

/*

	class CZipTest - defines text UI

*/

static RTest test(_L("ZIPTEST"));

class CZipTest : public CBase

	{

public:

	// execute UI until exit command processed

	void ExecuteL();

private:

	// destructor

	~CZipTest();

	// other functions

	void TrapDoTest();

	void DoTestL();

	void ExtractFileL(RFs&,  const CZipFileMember*, CZipFile*, const TFileName*, RFileWriteStream&);

	void ExpandMember();

	void TheZipTestL(RFs&, TFileName*, RFileWriteStream&);

private:

	CConsoleBase*	iConsole;

	RFile			iZipOut;

	TBool			iNoFiles;

	};

_LIT(KNoFilesFound,"No appropriate files located in this folder.\r\n");

_LIT(KOpeningFile,"Opening file ");

_LIT(KDots,"...");

_LIT(KOutputFileName,"C:\\test\\zip\\extracts\\zip_out.txt");

_LIT(KErrFileNotOpened, "File could not be opened.");

_LIT(KOk, "Ok");

_LIT(KZipName,"Name:		");

_LIT(KZipCRC32,"CRC32:		");

_LIT(KZipCSize,"Compressed Size:	");

_LIT(KZipUCSize,"Uncompressed Size:	");

_LIT(KOpenedSuccessfully, "%S opened sucessfully.\n");

_LIT(KLineSpace, "\r\n");

_LIT(KExtractZipPath, "C:\\test\\zip\\extracts\\");

#if !defined(__WINS__)

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

#else

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

#endif

void CZipTest::ExecuteL()

	{

	//text constant declarations

	_LIT(KTxtZipTest,"Zip Test");

	iConsole=Console::NewL(KTxtZipTest,

		TSize(KConsFullScreen,KConsFullScreen));

	DoTestL();

	}

CZipTest::~CZipTest()

	{

	delete iConsole;

	}

void CZipTest::TrapDoTest()

	{

	TInt q=10;

	while(q<2000)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic, q);

		__UHEAP_MARK;

		TRAPD(err, DoTestL());

		test(err==KErrNone);

		__UHEAP_MARKEND;

		q++;

		}

	}

void CZipTest::DoTestL()

	{

	TFileName*				FileName;

	RFs						Fs;

	iNoFiles=ETrue;

	User::LeaveIfError(Fs.Connect()); //Connect to file session

	CleanupClosePushL(Fs);

	User::LeaveIfError(Fs.SetSessionPath(KPath)); //Set Session Path to direcrt containing test zip files

	Fs.MkDirAll(KOutputFileName);

	iZipOut.Replace(Fs, KOutputFileName, EFileShareAny|EFileWrite);

	RFileWriteStream stream(iZipOut);

	CleanupClosePushL(stream);

	CDir* fileList;

	Fs.GetDir(KPath, KEntryAttNormal, ESortByName, fileList);

	CleanupStack::PushL(fileList);

	TInt count = fileList->Count(); 

	for (TInt y=0; y<count; y++)

		{

		iNoFiles=EFalse;

		TBuf<256> dirFileName((*fileList)[y].iName);

		FileName= &dirFileName;

		stream.WriteL(KLineSpace);

		stream.WriteL(KOpeningFile);

		stream.WriteL(*FileName);

		stream.WriteL(KDots);

		TheZipTestL(Fs, FileName, stream);

	/*	for(TInt t=1;t<50;t++)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic, t);

		__UHEAP_MARK;

		TRAPD(err,TheZipTestL(Fs, FileName, stream));

		if (err!=KErrNoMemory) break;

		__UHEAP_MARKEND;

		}

*/

	}

	if (iNoFiles) 

		{

		iConsole->Printf(KNoFilesFound);

		stream.WriteL(KNoFilesFound);

		}

	CleanupStack::PopAndDestroy(3);

/*	CleanupStack::Pop();

	Fs.Close();

*/	}

#if defined(__GCC32__)

typedef wchar_t __TText;

#elif defined(__VC32__)

typedef TUint16 __TText;

#elif defined(__CW32__)

typedef TUint16 __TText;

#elif !defined(__TText_defined)

#error  no typedef for __TText

#endif

const __TText* KShortData1252  = L"\x20AC\u00FC\u00E9";

const __TText* KShortData850   = L"\u00C7\u00FC\u00E9";

const __TText* KLongData1252   = L"\u00E7\u00F8d\u00EB\u00DE\u00E3g\u00EA1252";

const __TText* KLongData850    = L"\u00E7\u00F6d\u00EBp\u00E4g\u00EA850";

const __TText* KShortWin2K1252 = L"CP1252Win2kShort.zip"; // created on win2k with winzip

const __TText* KShortWinXP1252 = L"CP1252WinXPShort.zip"; // created on XP with winzip

const __TText* KShortWin2K850  = L"CP850Win2kShort.zip";

const __TText* KShortWinXPMS850= L"CP850WinXPMSShort.zip";// created on XP with Compressed Folders

const __TText* KShortWinXP850  = L"CP850WinXPShort.zip";

const __TText* KLongWin2K      = L"CPMixWin2kLong.zip";

const __TText* KLongWinXP      = L"CPMixWinXPLong.zip";

const __TText* KLongWinXPMS    = L"CPMixWinXPMSLong.zip";

struct TUnzipResultsArray

	{

	const __TText*  iZipFileName;

	TInt iZipFileMemberIndex;

	const __TText*  iZipFileMemberExpectedName;

	};

const TUnzipResultsArray KUnzipResults[] =

	{

	{KShortWin2K1252, 1, KShortData1252},

	{KShortWinXP1252, 1, KShortData1252},

	{KShortWin2K850,  1, KShortData850},

	{KShortWinXPMS850,1, KShortData850},

	{KShortWinXP850,  1, KShortData850},

	{KLongWin2K,      1, KLongData1252},

	{KLongWin2K,      2, KLongData850},

	{KLongWinXP,      1, KLongData850},

	{KLongWinXP,      2, KLongData1252},

	{KLongWinXPMS,    1, KLongData850},

	{KLongWinXPMS,    2, KLongData1252}

	};

void TestEntry(const TDesC16& aFileName, TInt aIndex, const TDesC16& aEntryName)

// Test for correct decoding of filenames containing extended characters (DEF083102)	

// Cycle through data defined above looking for matching filenames and data

	{	

 	for (TInt i = 0; i != sizeof(KUnzipResults)/sizeof(KUnzipResults[0]); ++i)

 		{

 		TPtrC filename(reinterpret_cast<const TText16*>(KUnzipResults[i].iZipFileName));

 		if(aFileName==filename && aIndex==KUnzipResults[i].iZipFileMemberIndex)

 			{

	 		TPtrC entryname(reinterpret_cast<const TText16*>(KUnzipResults[i].iZipFileMemberExpectedName));

 			test.Next(_L("DEF083102"));

 			test(aEntryName==entryname);

 			}

 		}

	}

void CZipTest::TheZipTestL(RFs& aFs, 

						  TFileName* aFileName, 

						  RFileWriteStream& aStream)

	{

	CZipFile*				ZipFile=0;

	CZipFileMember*			Member=0;

	CZipFileMemberIterator*	FileMembers;

	iConsole->Printf(_L("Test file: %S\r\n"), aFileName);

	TRAPD(err, ZipFile = CZipFile::NewL(aFs,*aFileName));

	if(err==KErrNoMemory) 

		User::Leave(err); // leave here if error is no memory

	if (err!=KErrNone)

		{

		aStream.WriteL(KErrFileNotOpened);

		aStream.WriteL(KLineSpace);

		if (err == CZipArchive::KZipArchiveError)

			aStream.WriteL(_L("Error: Zip Archive Error.\r\n"));

		else if (err == CZipArchive::KCentralDirectoryTrailerNotFound)

			aStream.WriteL(_L("Error: Central Directory Trailer Not Found.\r\n"));

		else if (err == CZipArchive::KCentralDirectoryTrailerInvalid)

			aStream.WriteL(_L("Error: KCentral Directory Trailer Invalid.\r\n"));

		else if (err == CZipArchive::KCompressionMethodNotSupported)

			aStream.WriteL(_L("Error: Compression Method Not Supported.\r\n"));

		else if (err == CZipArchive::KMultiDiskArchivesNotSupported)

			aStream.WriteL(_L("Error: Multi Disk Archives Not Supported.\r\n"));

		else if (err == CZipArchive::KMemberNotFound)

			aStream.WriteL(_L("Error: Member Not Found.\r\n"));

		else if (err == CZipArchive::KZipArchiveMinError)

			aStream.WriteL(_L("Error: Zip Archive Min Error.\r\n"));

		User::Leave(err);

		}

	else

		{

		CleanupStack::PushL(ZipFile);

		aStream.WriteL(KOk);

		aStream.WriteL(KLineSpace);

			aStream.WriteL(KLineSpace);

		iConsole->Printf(KOpenedSuccessfully, aFileName);

		iNoFiles=EFalse;

		FileMembers = ZipFile->GetMembersL();

		CleanupStack::PushL(FileMembers);

		Member = FileMembers->NextL();

		TInt index=1;// have to provide this - the one in the iterator is private

		while (Member != NULL)

			{

			CleanupStack::PushL(Member);

			TBuf<16> CRC32;

			CRC32.NumUC((TUint)Member->CRC32(), EHex);

			TBuf<16> UnComp;

			UnComp.NumUC((TUint)Member->UncompressedSize());

			TBuf<16> Comp;

			Comp.NumUC((TUint)Member->CompressedSize());

			aStream.WriteL(KZipName);

			aStream.WriteL(*Member->Name());

			aStream.WriteL(KLineSpace);

			aStream.WriteL(KZipCRC32);

			aStream.WriteL(CRC32);

			aStream.WriteL(KLineSpace);

			aStream.WriteL(KZipCSize);

			aStream.WriteL(Comp);

			aStream.WriteL(KLineSpace);

			aStream.WriteL(KZipUCSize);

			aStream.WriteL(UnComp);

			aStream.WriteL(KLineSpace);

			aStream.CommitL();

			ExtractFileL(aFs, Member, ZipFile, aFileName, aStream);

			TestEntry(*aFileName,index++,*Member->Name());

			aFs.SetSessionPath(KPath);

			CleanupStack::PopAndDestroy(Member); 

			Member = FileMembers->NextL();

			}

		CleanupStack::PopAndDestroy(FileMembers); 

		CleanupStack::PopAndDestroy(ZipFile);

		}

}

void CZipTest::ExtractFileL(RFs& aFs, 

							const CZipFileMember* aMember, 

							CZipFile* aZipFile, 

							const TFileName* aFileName,

							RFileWriteStream& aStream)

	{

	TInt loop=0;

	HBufC* name = aMember->Name()->AllocLC();

	while (loop<name->Length())

		{

		if ((*name)[loop] == '/')

			{

			name->Des()[loop] = '\\';

			}

		loop++;

		}

	TFileName fn;

	fn.Append(KExtractZipPath);

	fn.Append(*aFileName);

	fn.Append('\\');

	fn.Append(*name);

//	

	RFile expandedMember;

	CleanupClosePushL(expandedMember);

//

	aFs.SetSessionPath(KExtractZipPath);

	aFs.MkDirAll(fn);

	TInt retVal = expandedMember.Replace(aFs,fn, EFileShareAny|EFileWrite);

	if(retVal != KErrNone)

	{

	//Could be a directory name which we are planning to write to.

	CleanupStack::PopAndDestroy(2,name); //expanded member, name

	expandedMember.Close();

	return;

	}

//

	RZipFileMemberReaderStream* fileStream;

	TInt error = aZipFile->GetInputStreamL(aMember, fileStream);

	if (error != KErrNone)

		{

		_LIT(KCompressionNotSupported, "Error: Compression Method Not Supported");

		aStream.WriteL(KCompressionNotSupported);

		aStream.WriteL(KLineSpace);

		CleanupStack::PopAndDestroy(2,name); //expanded member and name

		aFs.Delete(fn);

		return;

		}

	CleanupStack::PushL(fileStream);

//

	TUint32 size = aMember->UncompressedSize();

	HBufC8* bytes = HBufC8::New(size);

	CleanupStack::PushL(bytes);

	TPtr8 ptr = bytes->Des();

	User::LeaveIfError(fileStream->Read(ptr,size));

	User::LeaveIfError(expandedMember.Write(ptr));

	CleanupStack::PopAndDestroy(4,name); // bytes, fileStream, expanded member and name

	expandedMember.Close();	

	}

static void executeUiL()

	{

	CZipTest* ziptest=new (ELeave) CZipTest;

	CleanupStack::PushL(ziptest);

	ziptest->ExecuteL();

	CleanupStack::PopAndDestroy();

	}

/**

@SYMTestCaseID          SYSLIB-EZLIB2-UT-4299

@SYMTestCaseDesc	    Test CZipFile functionality like open, close, size of the file.

@SYMTestPriority 	    High

@SYMTestActions  	    Creates a new CZipFile object using the supplied file server session and a valid file handle using CZipFile::NewL() 

						Open zip file using CZipFile::OpenL()

						Check the size of the zip file using CZipFile::Size()

						Close zip file using CZipFile::Close()

@SYMTestExpectedResults The test succeeds with no errors i.e. KErrNone 

@SYMDEF                 REQ8024

*/

static void TestCZipFileMethodsL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB2-UT-4299 "));

	RFs	rFs;

	User::LeaveIfError(rFs.Connect()); //Connect to file session

	CleanupClosePushL(rFs);

	User::LeaveIfError(rFs.SetSessionPath(KPath)); //Set Session Path to direcrt containing test zip files

	TFileName fileName(_L("rfc2459.zip"));

	test.Printf(_L("Test file: %S\r\n"), &fileName);

	CZipFile* ZipFile = 0;

	TRAPD(err, ZipFile = CZipFile::NewL(rFs, fileName));

	CleanupStack::PushL(ZipFile);

	TRAP(err, ZipFile->OpenL());

	test(err == KErrNone);

	TInt fileSize;

	TRAP(err, ZipFile->Size(fileSize));

	test(err == KErrNone && fileSize > 0);

	TRAP(err, ZipFile->Close());

	test(err == KErrNone);

	CleanupStack::PopAndDestroy(2);// rFs, ZipFile

	}

GLDEF_C TInt E32Main() // main function called by E32

    {

	test.Title();

	__UHEAP_MARK; // mark heap state

	test.Start(_L("Test ZIP"));

	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack

	TRAPD(error, executeUiL()); // do most stuff under cleanup stack

	test(error==KErrNone);

	test.Next(_L("Test CZipFile functionality like open, close, size of the file"));

	TRAP(error, TestCZipFileMethodsL());

	test.End();

	delete cleanup; // destroy clean-up stack

	__UHEAP_MARKEND; // check no memory leak

	test.Close();

	return 0; // and return

    }