diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/apputils/tsrc/T_SPI.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/apputils/tsrc/T_SPI.CPP Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,386 @@ +// Copyright (c) 2008-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 +#include +#include +#include + +LOCAL_D RTest TheTest(_L("T_SPI")); +LOCAL_D RFs TheFs; + +//Test files +_LIT(KTestDirectoryPath,"z:\\system\\data\\"); +_LIT(KRscExtension,".rsc"); +_LIT(KXipSpiFile,"z:\\system\\data\\Spi_ECom.SPI"); +_LIT(KNonXipSpiFile, "c:\\system\\data\\Spi_ECom.SPI"); +_LIT(KXipSpi_EcomRsc1,"z:\\system\\data\\Spi_EcomRsc1.rsc"); +_LIT(KXipSpi_EcomRsc2,"z:\\system\\data\\Spi_EcomRsc2.rsc"); +_LIT(KXipSpi_EcomRsc3,"z:\\system\\data\\Spi_EcomRsc3.rsc"); +_LIT(KNonXipSpi_EcomRsc1,"c:\\system\\data\\Spi_EcomRsc1.rsc"); +_LIT(KNonXipSpi_EcomRsc2,"c:\\system\\data\\Spi_EcomRsc2.rsc"); +_LIT(KNonXipSpi_EcomRsc3,"c:\\system\\data\\Spi_EcomRsc3.rsc"); + +//----------------------UTILITY FUNCTIONS---------------------------------- +LOCAL_C void CopyFileL(const TDesC& aFrom,const TDesC& aTo) + { + TheFs.Delete(aTo); + CFileMan* man=CFileMan::NewL(TheFs); + TInt r=man->Copy(aFrom,aTo, CFileMan::ERecurse); + delete man; + User::LeaveIfError(r); + User::LeaveIfError(TheFs.SetAtt(aTo,0,KEntryAttReadOnly)); // clear RO + } + +LOCAL_C void DeleteFile(const TDesC& aFileName) + { + // 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; + CleanupClosePushL(file); + User::LeaveIfError(file.Open(TheFs, aFileName, EFileRead)); + TInt size = 0; + User::LeaveIfError(file.Size(size)); + CleanupStack::PopAndDestroy(&file); + return size; + } + +LOCAL_C void DeleteTestFile() + { + DeleteFile(KNonXipSpiFile); + DeleteFile(KNonXipSpi_EcomRsc1); + DeleteFile(KNonXipSpi_EcomRsc2); + DeleteFile(KNonXipSpi_EcomRsc3); + } + +//Test macroses and functions +LOCAL_C void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + ::DeleteTestFile(); + TheTest(EFalse, aLine); + } + } + +#define TEST(arg) ::Check((arg), __LINE__) + +//---------------------TEST CASE for RResoureArchive------------------ +// Tests for RResourceArchive +/* +(1) Test Loading SPI file through RResourceArchive and retrieving the first rsc block + from XIP media(e.g NOR flash) in basic and OOM environment. +(2) Test Loading SPI file through RResourceArchive and retrieving the first rsc block + from NON-XIP media(e.g NAND flash) in basic and OOM environment. +(3) Test the Reset() functionality to ensure proper reset functionality by comparing the + content of the rsc file +(4) Test Loading some test SPI(with 2-3 random rsc file), interpret the content of rsc file + through RResourceReader and compare it with the results when opening each rsc file + separately. +(5) Test Loading some non-spi file using RResourceArchive expecting a KErrCorrupt to be + returned +*/ +class RStaticPluginInfoTest + { +public: + static void TestCase1L(); + static void TestCase2L(); + static void TestCase3L(); + static void TestCase4L(); + static void TestCase5L(); +private: + static void TestOpenNextL(const TDesC& aFileName); + static void TestComparisonL(const TDesC& aFileName); + }; + +void RStaticPluginInfoTest::TestCase1L() + { + TheTest.Next(_L("Test case 1 Loading/Reading SPI file from XIP media\n")); + TestOpenNextL(KXipSpiFile); + } + +void RStaticPluginInfoTest::TestCase2L() + { + TheTest.Next(_L("Test case 2 Loading/Reading SPI file from Non-XIP media\n")); + TestOpenNextL(KNonXipSpiFile); + } + +void RStaticPluginInfoTest::TestCase3L() + { + __UHEAP_MARK; + TheTest.Next(_L("Test case 3 Testing functionality of the Reset() function\n")); + RResourceArchive testArchiveIter; + testArchiveIter.OpenL(TheFs,KXipSpiFile); + + RResourceReader theReader1; + RResourceReader theReader3; + + HBufC* rscName1=NULL; + HBufC* rscName2=NULL; + HBufC* rscName3=NULL; + + CResourceFile* rscArchive1=testArchiveIter.NextL(rscName1); + TEST(rscArchive1!=NULL); + + CResourceFile* rscArchive2=testArchiveIter.NextL(rscName2); + TEST(rscArchive2!=NULL); + + testArchiveIter.Reset(); + + CResourceFile* rscArchive3=testArchiveIter.NextL(rscName3); + TEST(rscArchive3!=NULL); + + //Check to ensure that rscArchive3 content is the same as rscArchive1 + theReader1.OpenLC(rscArchive1,1); + theReader3.OpenLC(rscArchive3,1); + TEST(rscArchive1->UidType()==rscArchive3->UidType()); + TEST(rscName1->CompareF(rscName3->Des())==0); + TEST(theReader1.ReadInt32L()==theReader3.ReadInt32L()); + + delete rscName1; + delete rscName2; + delete rscName3; + delete rscArchive1; + delete rscArchive2; + delete rscArchive3; + + testArchiveIter.Close(); + + CleanupStack::PopAndDestroy(&theReader3); + CleanupStack::PopAndDestroy(&theReader1); + __UHEAP_MARKEND; + } + +void RStaticPluginInfoTest::TestCase4L() + { + TheTest.Next(_L("Test case 4 Testing comparison of spi and rsc read CResourceFiles\n")); + TestComparisonL(KXipSpiFile); + TestComparisonL(KNonXipSpiFile); + } + +void RStaticPluginInfoTest::TestCase5L() + { + TheTest.Next(_L("Test case 5 Testing opening a non-spi file\n")); + __UHEAP_MARK; + RResourceArchive testArchiveIter; + TRAPD(err,testArchiveIter.OpenL(TheFs,KXipSpi_EcomRsc1)); + TEST(err==KErrCorrupt); + + __UHEAP_MARKEND; + } + +void RStaticPluginInfoTest::TestComparisonL(const TDesC& aFileName) + { + __UHEAP_MARK; + RResourceArchive testArchiveIter; + testArchiveIter.OpenL(TheFs,aFileName); + TUid spiType=testArchiveIter.Type(); + TEST(spiType.iUid=0x10205C2C); + + CResourceFile* spiRscArchive=NULL; + HBufC* rscName=NULL; + spiRscArchive=testArchiveIter.NextL(rscName); + while (spiRscArchive) + { + TFileName fullRscName; + fullRscName.Append(KTestDirectoryPath); + fullRscName.Append(rscName->Des()); + fullRscName.Append(KRscExtension); + TInt rscFileSize=FileSizeL(fullRscName); + + //Creating a CResourceFile by opening the individual rsc file + CResourceFile* existingRscArchive=CResourceFile::NewL(TheFs,fullRscName,0,rscFileSize); + //Now perform general comparison + TEST(spiRscArchive->UidType()==existingRscArchive->UidType()); + TEST(spiRscArchive->Offset()==existingRscArchive->Offset()); + //Now perform interpreting and comparing the rsc content + RResourceReader rscReader; + RResourceReader spiRscReader; + spiRscReader.OpenLC(spiRscArchive,1); + rscReader.OpenLC(existingRscArchive,1); + //Now perform all the read results and comparison between the two CResourceFile + const TUid KUidEComResourceFormatV2 = {0x101FB0B9}; + TInt resourceFormatVersion=0; + resourceFormatVersion+=0; + //Comparison of Rsc uid + TUid rscUid = {rscReader.ReadInt32L()}; + TEST(rscUid.iUid==spiRscReader.ReadInt32L()); + if(rscUid==KUidEComResourceFormatV2) + { + resourceFormatVersion = 2; + TUid dllUid={rscReader.ReadInt32L()}; + TEST(dllUid.iUid==spiRscReader.ReadInt32L()); + } + //Comparison of number of interfaces + TInt numberOfInterface=rscReader.ReadInt16L(); + TEST(numberOfInterface==spiRscReader.ReadInt16L()); + //Comparison of the each interface uid and implementations under this interface + for(TInt iFace = 0; iFace < numberOfInterface; ++iFace) + { + //Comparison of each interface Uid + const TUid interfaceUid = {rscReader.ReadInt32L()}; + TEST(interfaceUid.iUid==spiRscReader.ReadInt32L()); + //Comparison of number of implementations under this interface + const TInt numImplementations = rscReader.ReadInt16L(); + TEST(numImplementations==spiRscReader.ReadInt16L()); + for(TInt impl = 0; impl < numImplementations; ++impl) + { + //Comparison of some of the implementation content + const TUid impUid = {rscReader.ReadInt32L()}; + TEST(impUid.iUid==spiRscReader.ReadInt32L()); + const TInt version = rscReader.ReadInt8L(); + TEST(version==spiRscReader.ReadInt8L()); + } + } + delete existingRscArchive; + existingRscArchive=NULL; + delete spiRscArchive; + spiRscArchive=NULL; + delete rscName; + rscName=NULL; + CleanupStack::PopAndDestroy(&rscReader); + CleanupStack::PopAndDestroy(&spiRscReader); + spiRscArchive=testArchiveIter.NextL(rscName); + } + testArchiveIter.Close(); + + __UHEAP_MARKEND; + } + +void RStaticPluginInfoTest::TestOpenNextL(const TDesC& aFileName) + { + //---------Basic testing------------------------------- + __UHEAP_MARK; + + RResourceArchive testArchiveIter; + testArchiveIter.OpenL(TheFs,aFileName); + TUid spiType=testArchiveIter.Type(); + TEST(spiType.iUid==0x10205C2C); + HBufC* rscName=NULL; + CResourceFile* rscArchive=testArchiveIter.NextL(rscName); + + delete rscArchive; + rscArchive=NULL; + delete rscName; + rscName=NULL; + testArchiveIter.Close(); + + __UHEAP_MARKEND; + + //-----------OOM testing-------------------------------- + TInt err; + TInt tryCount = 0; + tryCount=tryCount; + RResourceArchive testArchiveIter1; + testArchiveIter1.OpenL(TheFs,aFileName); + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount); + TRAP(err,rscArchive=testArchiveIter1.NextL(rscName)); + __UHEAP_SETFAIL(RHeap::ENone, 0); + + delete rscArchive; + rscArchive=NULL; + + delete rscName; + rscName=NULL; + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST(startProcessHandleCount == endProcessHandleCount); + TEST(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + testArchiveIter1.Close(); + } + +/** +@SYMTestCaseID SYSLIB-BAFL-CT-0094 +@SYMTestCaseDesc Testing for the functionality of RResourceArchive +@SYMTestPriority High +@SYMTestActions Test loading and reading Spi file through Xip and Non-Xip media + Test interpreting and comparing rsc content through read from + spi file and from individual rsc file. + Test all exported functionality of this class in general and + OOM conditions. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ 806 Eliminate scanning for plugins on startup +*/ +LOCAL_C void DoAllTestsL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0094 ")); + CleanupClosePushL(TheFs); + User::LeaveIfError(TheFs.Connect()); + + TheTest.Printf(_L("Copying SPI files to RAM\r\n")); + //Copying test spi file and individual rsc files that are included inside spi + CopyFileL(KXipSpiFile,KNonXipSpiFile); + CopyFileL(KXipSpi_EcomRsc1,KNonXipSpi_EcomRsc1); + CopyFileL(KXipSpi_EcomRsc2,KNonXipSpi_EcomRsc2); + CopyFileL(KXipSpi_EcomRsc3,KNonXipSpi_EcomRsc3); + + //Start running all the TestCase + RStaticPluginInfoTest::TestCase1L(); + RStaticPluginInfoTest::TestCase2L(); + RStaticPluginInfoTest::TestCase3L(); + RStaticPluginInfoTest::TestCase4L(); + RStaticPluginInfoTest::TestCase5L(); + + //Clearing all the test files we have copied to C + DeleteTestFile(); + + CleanupStack::PopAndDestroy(1, &TheFs); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup *cleanup=CTrapCleanup::New(); + TheTest.Title(); + TheTest.Start(_L("Testing RResourceArchive")); + TRAPD(err,DoAllTestsL()); + TheTest.Printf(_L("Error code is %d\n"),err); + TEST(err==KErrNone); + TheTest.End(); + TheTest.Close(); + delete cleanup; + __UHEAP_MARKEND; + return(0); + } +