diff -r 000000000000 -r e4d67989cc36 compressionlibs/ziplib/test/rtest/ziptest/ziptestmanual.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/compressionlibs/ziplib/test/rtest/ziptest/ziptestmanual.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,355 @@ +// 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: +// ZIPTEST.CPP +// +// + +#include "zipfile.h" + +#include +#include +#include +#include +#include + +/* + class CZipTest - defines text UI +*/ +LOCAL_D RTest test(_L("ZIPTEST")); + +class CZipTest : public CBase + { +public: + // execute UI until exit command processed + void ExecuteL(); +private: + // destructor + ~CZipTest(); + void DoTestL(); + void ExtractFileL(RFs&, const CZipFileMember*, CZipFile*, const TFileName*, RFileWriteStream&); + void TheZipTestL(RFs&, TFileName*, RFileWriteStream&); + +private: + CConsoleBase* iConsole; + RFile iZipOut; + TBool NoFiles; + }; + +_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::DoTestL() + { + + TFileName* FileName; + RFs Fs; + + NoFiles=ETrue; + + User::LeaveIfError(Fs.Connect()); //Connect to file session + User::LeaveIfError(Fs.SetSessionPath(KPath)); //Set Session Path to direcrt containing test zip files + CleanupClosePushL(Fs); + + Fs.MkDirAll(KOutputFileName); + iZipOut.Replace(Fs, KOutputFileName, EFileShareAny|EFileWrite); + RFileWriteStream stream(iZipOut); + CDir* fileList; + + Fs.GetDir(KPath, KEntryAttNormal, ESortByName, fileList); + CleanupStack::PushL(fileList); + TInt count = fileList->Count(); + for (TInt y=0; y dirFileName((*fileList)[y].iName); + + FileName= &dirFileName; + stream.WriteL(KLineSpace); + stream.WriteL(KOpeningFile); + stream.WriteL(*FileName); + stream.WriteL(KDots); + TheZipTestL(Fs, FileName, stream); + } + if (NoFiles) + { + iConsole->Printf(KNoFilesFound); + stream.WriteL(KNoFilesFound); + } + stream.Close(); + CleanupStack::PopAndDestroy(2); + } + +#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( + KUnzipResults[i].iZipFileName)); + if(aFileName==filename && aIndex==KUnzipResults[i].iZipFileMemberIndex) + { + TPtrC entryname(reinterpret_cast( + 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); + + NoFiles=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 (loopLength()) + { + 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(); + } + +LOCAL_C void executeUiL() + { + CZipTest* ziptest=new (ELeave) CZipTest; + CleanupStack::PushL(ziptest); + ziptest->ExecuteL(); + CleanupStack::PopAndDestroy(); + } + +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.End(); + delete cleanup; // destroy clean-up stack + __UHEAP_MARKEND; // check no memory leak + test.Close(); + return 0; // and return + } +