// 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 <e32test.h>

 #include <bautils.h>

 #include <barsc.h>

 #include <barsc2.h>

 #include <trsc.rsg>

 #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 T> class TestRsc

 	{

 protected:

 	void TestReadL(T* aRscFile);

     };

 class TestRRsc : public TestRsc<RResourceFile>

 	{

 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<CResourceFile>

 	{

 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 <class T> void TestRsc<T>::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);

     }