// Copyright (c) 2005-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 <zipfile.h>

LOCAL_D RTest				test(_L("ezdefect.exe"));
LOCAL_D RFs					TheFs;
LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;

#if !defined(__WINS__)
_LIT(KPath, "Z:\\test\\zip\\");
#else
_LIT(KPath, "C:\\test\\zip\\");
#endif



void ExtractFileL(const CZipFileMember* aMember, CZipFile* aZip)
	{
	HBufC* name = aMember->Name()->AllocLC();
	for (TInt i = 0; i<name->Length(); i++)
		{
		if ((*name)[i] == '/')
			{
			name->Des()[i] = '\\';
			}
		}
	
	RZipFileMemberReaderStream* fileStream;
	User::LeaveIfError(aZip->GetInputStreamL(aMember, fileStream));
	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));	
	CleanupStack::PopAndDestroy(3,name); // bytes, fileStream and name
	}
		
// Extract all members from the zip.
// These files are non compressed, i.e. EStored.
void ExtractMembersL(CZipFile* aZip)
	{
	test.Next(_L("DEF057916: Getting Corrupt file error when reading wav-file from Zip - PART 2"));

	CZipFileMemberIterator*	members = aZip->GetMembersL();
	CleanupStack::PushL(members);
	
	CZipFileMember* member = members->NextL();
	while (member)
		{
		CleanupStack::PushL(member);
		ExtractFileL(member, aZip);
		CleanupStack::PopAndDestroy(member); 
		member = members->NextL();
		}

	CleanupStack::PopAndDestroy(members); 
	}

// Extract the specified files from the zip.
// These files are non compressed, i.e. EStored.
void DEF057916L()
    {
	test.Next(_L("DEF057916: Getting Corrupt file error when reading wav-file from Zip - PART 1"));

	User::LeaveIfError(TheFs.Connect()); //Connect to file session
	User::LeaveIfError(TheFs.SetSessionPath(KPath)); //Set Session Path to direcrt containing test zip files
	CleanupClosePushL(TheFs);

	const TUint KDataChunk = 2048;
	_LIT(tmpFileName, "\\Test\\Zip\\compression_estored.zip");
	_LIT(testFile1, "zip\\test.wav");
	_LIT(testFile2, "zip\\rfc2459.zip");
	_LIT(testFile3, "zip\\META-INF\\MANIFEST.MF");
	
	CZipFile* iZipFile = CZipFile::NewL(TheFs, tmpFileName);
	CleanupStack::PushL(iZipFile);

	TInt err = KErrNone;

	CZipFileMember* zipMember1 = iZipFile->CaseSensitiveOrCaseInsensitiveMemberL(testFile1);
	if(zipMember1)
		{
		CleanupStack::PushL(zipMember1);

		RZipFileMemberReaderStream* iZipStream;
		iZipFile->GetInputStreamL(zipMember1, iZipStream);
		CleanupStack::PushL(iZipStream);

		HBufC8* data = HBufC8::NewLC(KDataChunk);
		TPtr8 ptr = data->Des();
		err = KErrNone;
		
		err = iZipStream->Read(ptr,KDataChunk);
		test (err == KErrNone);
		
		err = iZipStream->Read(ptr,KDataChunk);
		test (err == KErrEof);
		
		CleanupStack::PopAndDestroy(data);
		CleanupStack::PopAndDestroy(iZipStream);
		CleanupStack::PopAndDestroy(zipMember1);  
		}  
		
		
	CZipFileMember* zipMember2 = iZipFile->CaseSensitiveOrCaseInsensitiveMemberL(testFile2);
	if(zipMember2)
		{
		CleanupStack::PushL(zipMember2);

		RZipFileMemberReaderStream* iZipStream;
		iZipFile->GetInputStreamL(zipMember2, iZipStream);
		CleanupStack::PushL(iZipStream);

		HBufC8* data = HBufC8::NewLC(KDataChunk*65);
		TPtr8 ptr = data->Des();
		err = KErrNone;
		
		err = iZipStream->Read(ptr,KDataChunk*65);
		test (err == KErrNone); // file is very very large
		
		err = iZipStream->Read(ptr,KDataChunk);
		test (err == KErrEof);

		CleanupStack::PopAndDestroy(data);
		CleanupStack::PopAndDestroy(iZipStream);
		CleanupStack::PopAndDestroy(zipMember2);  
		}  
		
	
	CZipFileMember* zipMember3 = iZipFile->CaseSensitiveOrCaseInsensitiveMemberL(testFile3);
	if(zipMember3)
		{
		CleanupStack::PushL(zipMember3);

		RZipFileMemberReaderStream* iZipStream;
		iZipFile->GetInputStreamL(zipMember3, iZipStream);
		CleanupStack::PushL(iZipStream);

		HBufC8* data = HBufC8::NewLC(KDataChunk);
		TPtr8 ptr = data->Des();
		err = KErrNone;
		
		err = iZipStream->Read(ptr,KDataChunk);
		test (err == KErrNone);
		
		err = iZipStream->Read(ptr,KDataChunk);
		test (err == KErrEof);

		CleanupStack::PopAndDestroy(data);
		CleanupStack::PopAndDestroy(iZipStream);
		CleanupStack::PopAndDestroy(zipMember3);  
		}  		
		
	ExtractMembersL (iZipFile);
	
	CleanupStack::PopAndDestroy(iZipFile);
	CleanupStack::PopAndDestroy(&TheFs);
	}

/**
@SYMTestCaseID       	SYSLIB-EZLIB-CT-3464
@SYMTestCaseDesc     	RZipFileMemberReaderStream::Read returns incorrect error code under OOM
@SYMTestPriority     	High
@SYMTestActions      	Tries to read zipfile stream with heap allocation set to fail on all following 
						allocations.  Check result returned from Read(TDes16&, TInt) and Read(TDes8&, TInt) 
						is KErrNoMemory.  Note that zip file contents must be compressed, otherwise no 
						allocations are performed and Read() function returns KErrNone.
@SYMTestExpectedResults Read() function should return KErrNoMemory
@SYMDEF                 DEF103961
*/
void DEF103961L()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-3464 DEF103961: RZipFileMemberReaderStream::Read returns incorrect error code under OOM "));

	User::LeaveIfError(TheFs.Connect()); //Connect to file session
	User::LeaveIfError(TheFs.SetSessionPath(KPath)); //Set Session Path to directory containing test zip files
	CleanupClosePushL(TheFs);

	const TUint KDataChunk = 512;
	_LIT(testFile1, "zip_archive2_with_comments.zip");
	_LIT(internalFile, "doorslam.wav");
	
	// open zip file
	CZipFile* zipFile = CZipFile::NewL(TheFs, testFile1);
	CleanupStack::PushL(zipFile);

	// get input stream for a file contained in the zip archive
	CZipFileMember* zipMember = zipFile->CaseSensitiveOrCaseInsensitiveMemberL(internalFile);
	test(zipMember!=NULL);
	CleanupStack::PushL(zipMember);
	RZipFileMemberReaderStream* zipStream;
	zipFile->GetInputStreamL(zipMember, zipStream);
	CleanupStack::PushL(zipStream);
	
	// some descriptors to hold stream data...
	HBufC8* data8 = HBufC8::NewLC(KDataChunk);
	TPtr8 ptr8 = data8->Des();
	HBufC16* data16 = HBufC16::NewLC(KDataChunk);
	TPtr16 ptr16 = data16->Des();

	// do memory tests for RZipFileMemberReaderStream::Read() and its overloaded brother
	__UHEAP_SETFAIL(RHeap::EDeterministic,1);
	TInt error = zipStream->Read(ptr8, KDataChunk);
	test (error == KErrNoMemory);
	error = zipStream->Read(ptr16, KDataChunk);
	test (error == KErrNoMemory);
	__UHEAP_SETFAIL(RHeap::ENone,0);
	
	CleanupStack::PopAndDestroy(data16);
	CleanupStack::PopAndDestroy(data8);
	CleanupStack::PopAndDestroy(zipStream);
	CleanupStack::PopAndDestroy(zipMember);
	CleanupStack::PopAndDestroy(zipFile);
	CleanupStack::PopAndDestroy(&TheFs);
	}	

/**
@SYMTestCaseID		SYSLIB-EZLIB-CT-3475
@SYMTestCaseDesc 	RZipFileMemberReaderStream constructor ignores errors under OOM
@SYMTestPriority    High
@SYMTestActions     Construct RZipFileMemberReaderStream under OOM conditions.  Check the Leave code.
@SYMTestExpectedResults	Should Leave with KErrNoMemory
@SYMDEF              	DEF105995
*/
void DEF105995L()
	{
	test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-3475 DEF105995: RZipFileMemberReaderStream constructor not checking OOM conditions "));
	
	User::LeaveIfError(TheFs.Connect()); //Connect to file session
	User::LeaveIfError(TheFs.SetSessionPath(KPath)); //Set Session Path to directory containing test zip files
	CleanupClosePushL(TheFs);

	_LIT(testFile1, "zip_archive2_with_comments.zip");
	_LIT(internalFile, "doorslam.wav");
	
	// open zip file
	CZipFile* zipFile = CZipFile::NewL(TheFs, testFile1);
	CleanupStack::PushL(zipFile);

	// get input stream for a file contained in the zip archive
	CZipFileMember* zipMember = zipFile->CaseSensitiveOrCaseInsensitiveMemberL(internalFile);
	test(zipMember!=NULL);
	CleanupStack::PushL(zipMember);
	
	__UHEAP_SETFAIL(RHeap::EDeterministic,2); // so memory allocation in inflateInit2() fails

	RZipFileMemberReaderStream* zipStream;
	TRAPD(err, zipFile->GetInputStreamL(zipMember, zipStream));
	test(err == KErrNoMemory);	

	__UHEAP_SETFAIL(RHeap::ENone,0);
	
	CleanupStack::PopAndDestroy(zipMember);
	CleanupStack::PopAndDestroy(zipFile);
	CleanupStack::PopAndDestroy(&TheFs);
	}
				
void RunTestL()
	{
	DEF057916L(); // Getting Corrupt file error when reading wav-file from Zip
	#if defined(_DEBUG)	// OOM tests are only run on Debug builds
	DEF103961L(); // RZipFileMemberReaderStream::Read returns incorrect error code under OOM
	DEF105995L(); // inflateInit2 is not checked for errors in RZipFileMemberReaderStream constructor
	#endif
	}	

GLDEF_C TInt E32Main()
	{
	__UHEAP_MARK;

	test.Printf(_L("\n"));
	test.Title();
	test.Start( _L("EZlib defect Tests.") );

	TheTrapCleanup=CTrapCleanup::New();

	TRAPD(err,RunTestL());
	test (err==KErrNone);

	test.End();
	test.Close();
	delete TheTrapCleanup;

	__UHEAP_MARKEND;
	return KErrNone;
	}