diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/apputils/tsrc/T_RSC.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/apputils/tsrc/T_RSC.CPP Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,396 @@ +// Copyright (c) 1997-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: +// Started by MJB, May 1995 +// Updated Nov 1996 by PNJ for Unicode. +// Tests RResourceFile class +// +// + +#include +#include +#include +#include +#include + +#include "T_RSC.H" + +LOCAL_D RTest test(_L("T_RSC")); +LOCAL_D RFs TheFs; + +_LIT(KRamResourceFile, "c:\\T_RSC.RSC"); +_LIT(KRamResourceFile2, "c:\\NewRscFormat.RSC"); +_LIT(KFailResourceFile,"z:\\system\\data\\nonexist.rsc"); + +LOCAL_C TInt compare( const TDesC8 &aresbuf, const TDesC &abuf, TBool aUnicode ) +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +// Compare a buffer taken from a resource file with one that was defined in +// source code. All resources read at this level are read as pure data. +// However, the resource file entries for this test code are defined as +// generic text, which may be 8 or 16 bit codes, depending on how the +// resource was compiled. The third parameter indicates which is expected. +// +// +// Return a true value if the text matches, else false. +// +// ---------------------------------------------------------------------------- + { + + TInt count = abuf.Length(); + + // exit immediately of the strings are of different length. + if ( abuf.Size() != aresbuf.Size() ) return FALSE; + + // loop through character by character and exit if any comparison fails. + + if ( aUnicode ) + { + while ( count > 0 ) + { + TInt uch; + TInt bi; // byte index + count -=1; + bi = count*2; + uch = (aresbuf[bi+1]<<8) | aresbuf[bi]; + if ( uch != abuf[count] ) return FALSE; + } + } + else + { + while ( count > 0 ) + { + count -=1; + if ( aresbuf[count] != abuf[count] ) return FALSE; + } + } + + return TRUE; + + } // end of compare function. + + +LOCAL_C void CopyFileL(const TDesC& aFrom,const TDesC& aTo) +// +// helper function +// + { + TheFs.Delete(aTo); + CFileMan* man=CFileMan::NewL(TheFs); + TInt r=man->Copy(aFrom,aTo); + delete man; + User::LeaveIfError(r); + User::LeaveIfError(TheFs.SetAtt(aTo,0,KEntryAttReadOnly)); // clear RO + } + +LOCAL_C void DeleteFile(const TDesC& aFileName) +// +// helper function +// + { + // make sure the file is read/write + TInt err = TheFs.SetAtt(aFileName, 0, KEntryAttReadOnly); + if(err != KErrNone) + { + RDebug::Print(_L("error changing attributes file = %d"),err); + } + // delete the file + err = BaflUtils::DeleteFile(TheFs, aFileName); + if(err != KErrNone) + { + RDebug::Print(_L("error deleting file = %d"),err); + } + } + +LOCAL_C TInt FileSizeL(const TDesC& aFileName) + { + RFile file; + User::LeaveIfError(file.Open(TheFs, aFileName, EFileRead)); + CleanupClosePushL(file); + TInt size = 0; + User::LeaveIfError(file.Size(size)); + CleanupStack::PopAndDestroy(&file); + return size; + } + +template class TestRsc + { +protected: + void TestReadL(T* aRscFile); + }; + +class TestRRsc : public TestRsc + { +public: + void TestReadROldL(const TDesC &aTitle, const TDesC &aFileName); + void TestReadRNewL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize); + void TestOpenR(); + }; + +class TestCRsc : public TestRsc + { +public: + void TestReadCNewL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize); + void TestOpenC(); + }; + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0427 +@SYMTestCaseDesc RResourceFile class functionality test +@SYMTestPriority Medium +@SYMTestActions Attempts to read from an 8 and 16 bit resource file +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +void TestRRsc::TestReadROldL(const TDesC &aTitle, const TDesC &aFileName) + { + test.Start(aTitle); + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0427 ")); + RResourceFile rsc; + CleanupClosePushL(rsc); + rsc.OpenL(TheFs, aFileName); + TestReadL(&rsc); + CleanupStack::PopAndDestroy(); + test.End(); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0428 +@SYMTestCaseDesc Tests for RResourceFile::OpenL(,,,) function +@SYMTestPriority Medium +@SYMTestActions Attempt to read from a resource file +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +void TestRRsc::TestReadRNewL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize) + { + test.Start(aTitle); + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0428 ")); + RResourceFile rsc; + CleanupClosePushL(rsc); + rsc.OpenL(TheFs, aFileName, aFileOffset, aFileSize); + TestReadL(&rsc); + CleanupStack::PopAndDestroy(); + test.End(); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0429 +@SYMTestCaseDesc Testing error recovery - R file +@SYMTestPriority Medium +@SYMTestActions Attempt to read a resouce file,should recover on error. +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +void TestRRsc::TestOpenR() + { + test.Start(_L("Testing error recovery - R file")); + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0429 ")); + RResourceFile rsc_file; + TRAPD(err, rsc_file.OpenL(TheFs, KFailResourceFile)); + test(err != KErrNone); + test.End(); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0430 +@SYMTestCaseDesc Tests for RResourceFile::NewL() function +@SYMTestPriority Medium +@SYMTestActions Tests for reading the new resource file +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +void TestCRsc::TestReadCNewL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize) + { + test.Start(aTitle); + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0430 ")); + CResourceFile* rsc = CResourceFile::NewL(TheFs, aFileName, aFileOffset, aFileSize); + CleanupStack::PushL(rsc); + TestReadL(rsc); + CleanupStack::PopAndDestroy(rsc); + test.End(); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0431 +@SYMTestCaseDesc Testing error recovery - C file +@SYMTestPriority Medium +@SYMTestActions Tests for new open resource file,should recover on error +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +void TestCRsc::TestOpenC() + { + test.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0431 Testing error recovery - C file ")); + CResourceFile* rsc_file = NULL; + TRAPD(err, rsc_file = CResourceFile::NewL(TheFs, KFailResourceFile, 0, 0)); + test(err != KErrNone); + delete rsc_file; + test.End(); + } + +template void TestRsc::TestReadL(T* aRscFile) + { + TInt ii; + // + // First test to see if we have an 8 or 16-bit text resource file. + // This is done by looking at a signature resource that is defined + // as an LTEXT item and seeing how its length computes. + // + + test.Next(_L("Testing 8 or 16-bit signature")); + + + TBool isUnicode = EFalse; + + HBufC8 *ps = aRscFile->AllocReadL(R_TEXT_SIGNATURE); + TPtr8 sig = ps->Des(); + + TInt l = sig.Length(); // length of the raw resource data + TInt sig_count = sig[0]; // count byte at the start of the LTEXT + + if ( l == (1 + sig_count) ) // count + TText8 data + { + test.Printf(_L("8-bit resource text\n")); + } + else + if ( l == (1+1+(sig_count*2)) ) // count + padding + TText16 data + { + isUnicode = ETrue; + test.Printf(_L("Unicode resource text...\n")); + test(sig[1]==0xAB); // check for the defined padding byte + } + else + test.Printf(_L("Invalid signature found\n")); + + User::Free(ps); + + for (ii=SYS_SPECIAL_CHARACTERS;ii<=SYS_PAGE_IS;ii++) + { + TPtrC des=TPtrC(S_Resource[ii]); + TBuf<256> testbuf; + testbuf.Format(_L("Testing ReadL for resource: \"%S\""),&des); + test.Next(testbuf); + TBuf8<256> buf; + aRscFile->ReadL(buf,ii); + test(compare(buf,des,isUnicode)); + } + + for (ii=SYS_SPECIAL_CHARACTERS;ii<=SYS_PAGE_IS;ii++) + { + TPtrC des=TPtrC(S_Resource[ii]); + TBuf<256> testbuf; + testbuf.Format(_L("Testing AllocReadL for resource: \"%S\""),&des); + test.Next(testbuf); + HBufC8 *p=aRscFile->AllocReadL(ii); + TPtr8 wp=p->Des(); + test(compare(wp,des,isUnicode)); + User::Free(p); + } + + for (ii=SYS_SPECIAL_CHARACTERS;ii<=SYS_PAGE_IS;ii++) + { + TPtrC des=TPtrC(S_Resource[ii]); + TBuf<256> testbuf; + testbuf.Format(_L("Testing AllocReadLC for resource: \"%S\""),&des); + test.Next(testbuf); + HBufC8 *p=aRscFile->AllocReadLC(ii); + TPtr8 wp=p->Des(); + test(compare(wp,des,isUnicode)); + CleanupStack::PopAndDestroy(); + } + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0432 +@SYMTestCaseDesc Testing RResourceFile & CResourceFile classes +@SYMTestPriority High +@SYMTestActions Wrapper function, calls up test execute functions +@SYMTestExpectedResults Tests must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void DoTestsL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0432 ")); + CleanupClosePushL(TheFs); + User::LeaveIfError(TheFs.Connect()); + + test.Printf(_L("Copying resource files to RAM\r\n")); + CopyFileL(KRomResourceFile,KRamResourceFile); + CopyFileL(KRomResourceFile2,KRamResourceFile2); + + //The new resource format rsc file is compiled from RscHeader.bin, TRsc.rsc and 16RAMC.mbm. + //So I want to know the offset and size of TRsc.rsc. + TInt header_size = ::FileSizeL(KRomResourceFileHeader); + TInt rsc_size1 = ::FileSizeL(KRomResourceFile); + TInt rsc_size2 = ::FileSizeL(KRamResourceFile); + + TestRRsc t1; + + t1.TestReadROldL(_L("Testing ROM Resource file T_RSC.RSC"),KRomResourceFile); + + t1.TestReadRNewL(_L("Testing ROM Resource file NewRscFormat.RSC"), + KRomResourceFile2, + header_size, + rsc_size1); + + t1.TestReadROldL(_L("Testing RAM Resource file T_RSC.RSC"),KRamResourceFile); + + t1.TestReadRNewL(_L("Testing RAM Resource file NewRscFormat.RSC"), + KRamResourceFile2, + header_size, + rsc_size2); + + t1.TestOpenR(); + + TestCRsc t2; + + t2.TestReadCNewL(_L("Testing ROM Resource file T_RSC.RSC"),KRomResourceFile, 0, 0); + + t2.TestReadCNewL(_L("Testing ROM Resource file NewRscFormat.RSC"), + KRomResourceFile2, + header_size, + rsc_size1); + + t2.TestReadCNewL(_L("Testing RAM Resource file T_RSC.RSC"),KRamResourceFile, 0, 0); + + t2.TestReadCNewL(_L("Testing RAM Resource file NewRscFormat.RSC"), + KRamResourceFile2, + header_size, + rsc_size2); + + t2.TestOpenC(); + + // tidy up + DeleteFile(KRamResourceFile); + DeleteFile(KRamResourceFile2); + + CleanupStack::PopAndDestroy(1, &TheFs); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup *cleanup=CTrapCleanup::New(); + test.Title(); + test.Start(_L("Testing RResourceFile & CResourceFile")); + TRAPD(err,DoTestsL()); + test.Printf(_L("Error code is %d\n"),err); + test(err==KErrNone); + test.Next(_L("/n")); + test.End(); + test.Close(); + delete cleanup; + __UHEAP_MARKEND; + return(0); + }