diff -r 000000000000 -r bde4ae8d615e os/ossrv/compressionlibs/ziplib/test/rtest/ezdefect/ezdefect.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/compressionlibs/ziplib/test/rtest/ezdefect/ezdefect.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,303 @@ +// 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 +#include + +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; iLength(); 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; + }