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

 	}