// Copyright (c) 2006-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:

 // Tests RResourceFile/CResourceFile classes - panic/leave tests

 // 

 //

 #include <e32test.h>

 #include <bautils.h>

 #include <barsc.h>

 #include <barsc2.h>

 #include <barsread2.h>

 LOCAL_D RTest test(_L("T_RSCPANIC"));

 LOCAL_D RFs TheFs;

 _LIT8(KRscFileHeaderData, "0123456789ABCDEF");

 _LIT(KPanicThread,"panicThread");

 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

 	{

 	// make sure the file is read/write

 	TInt err = TheFs.SetAtt(aFullName, 0, KEntryAttReadOnly);

 	if(err != KErrNone)

 		{

 		RDebug::Print(_L("error changing attributes file = %d"),err);

 		}

 	// delete the file

 	err = BaflUtils::DeleteFile(TheFs, aFullName);

 	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;

 	}

 LOCAL_C void CreateFileFromL(const TDesC& aDestFileName, const TDesC& aSrcFileName)

 	{

 	RFile destFile;

 	RFile srcFile;

 	CleanupClosePushL(destFile);

 	CleanupClosePushL(srcFile);

 	BaflUtils::DeleteFile(TheFs, aDestFileName);

 	User::LeaveIfError(destFile.Create(TheFs, aDestFileName, EFileRead | EFileWrite));

 	User::LeaveIfError(srcFile.Open(TheFs, aSrcFileName, EFileRead));

 	TInt size = 0;

 	User::LeaveIfError(srcFile.Size(size));

 	HBufC8* buf = HBufC8::NewMaxLC(size);

 	TPtr8 ptr = buf->Des();

 	srcFile.Read(ptr);

 	destFile.Write(KRscFileHeaderData);

 	destFile.Write(ptr);

 	CleanupStack::PopAndDestroy(buf);

 	CleanupStack::PopAndDestroy(&srcFile);

 	CleanupStack::PopAndDestroy(&destFile);

 	}

 class TestRsc

 	{

 public:

 	void TestOpenReadL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize);

 //private:

 	void TestReadL(CResourceFile* aRscFile);

     };

 void TestRsc::TestOpenReadL(const TDesC &aTitle, const TDesC &aFileName, TUint aFileOffset, TUint aFileSize)

 	{

 	test.Next(aTitle);

 	CResourceFile* rsc = CResourceFile::NewL(TheFs, aFileName, aFileOffset, aFileSize);

 	CleanupStack::PushL(rsc);

 	TestReadL(rsc);

 	CleanupStack::PopAndDestroy(rsc);

 	}

 void TestRsc::TestReadL(CResourceFile* aRscFile)

 	{

 	RResourceReader resourceReader;

 	const TInt rsc_index[] = {2, 3, 4, 5, 6, 7, 8, 9};

 	for(TInt i=0;i<TInt(sizeof(rsc_index)/sizeof(rsc_index[0]));i++)

 		{

 		const TInt max_size = 10;

 		for(TInt j=0;j<max_size;j++)

 			{

 			resourceReader.OpenLC(aRscFile, rsc_index[i]);

 			TUint8 temp[max_size + 1];

 			resourceReader.ReadL(temp, j);

 			CleanupStack::PopAndDestroy(1, &resourceReader);

 			}

 		}

     }

 /**

 @SYMTestCaseID          SYSLIB-BAFL-CT-0482

 @SYMTestCaseDesc        RResourceReader class test

 @SYMTestPriority        High

 @SYMTestActions         Tests for the opening of a file,should panic on invalid file

 @SYMTestExpectedResults Tests must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C TInt DoTestL(const TDesC& aFileName, TUint aFileOffset = 0, TUint aFileSize = 0)

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0482 "));

 	TestRsc t2;

 	TBuf<128> buf;

 	buf.Format(_L("Testing with invalid file,C class,file=%S"), &aFileName);

 	TRAPD(err, t2.TestOpenReadL(buf, aFileName, aFileOffset, aFileSize));

 	return err;

 	}

 TInt ThreadFunc(TAny*)

   	{

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TestRsc panicObj;

   	CResourceFile* rsc=NULL;

   	TRAPD(err,panicObj.TestReadL(rsc))//calls RResourceReader::OpenLC, with NULL as argument, hence panics

   	delete cleanup;

   	return err;

   	}

 /**

 @SYMTestCaseID          SYSLIB-BAFL-UT-1790

 @SYMTestCaseDesc        Testing panics on RResourceReader class(JustInTimeDebug is disabled)

 @SYMTestPriority        Low

 @SYMTestActions         Test that panics, when the condition inside __ASSERT is made false,by passing a NULL value to RResourceReader::OpenLC()

 @SYMTestExpectedResults Tests must panic

 @SYMREQ                 REQ0000

 */

 void PanicTest()

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-UT-1790 "));

  	TRequestStatus threadStatus;

   	RThread thread;

   	TInt rc;

   	TBool jit;

   	jit = User::JustInTime();

   	User::SetJustInTime(EFalse);

   	rc = thread.Create(KPanicThread, ThreadFunc,

   		KDefaultStackSize, KMinHeapSize, KMinHeapSize*4,NULL);

   	test(KErrNone == rc);

   	thread.Logon(threadStatus);

   	thread.Resume();

   	User::WaitForRequest(threadStatus);

   	User::SetJustInTime(jit);

   	test(thread.ExitType() == EExitPanic);

   	thread.Close();

   	}

 /**

 @SYMTestCaseID          SYSLIB-BAFL-CT-0483

 @SYMTestCaseDesc        Tests for the functionality of RResourceFile/CResourceFile

 @SYMTestPriority        High

 @SYMTestActions         Tests for creation,deleting,opening of a resource file,

                         should panic on invalid file.

 @SYMTestExpectedResults Tests must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void DoTestsL()

     {

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0483 "));

 	CleanupClosePushL(TheFs);

 	User::LeaveIfError(TheFs.Connect());

 	const TPtrC inv_rsc_files[] =

 		{

 		  _L("TRsc_Inv1.rsc")			//Zero sized file

 		, _L("TRsc_Inv2.rsc")

 		, _L("TRsc_Inv3.rsc")

 		, _L("TRsc_Inv4.rsc")

 		, _L("TRsc_Inv5.rsc")

 		, _L("TRsc_Inv6.rsc")

 		, _L("TRsc_Inv7.rsc")

 		, _L("TRsc_Inv8.rsc")

 		, _L("TRsc_Inv9.rsc")

 		, _L("TRscCalypso_Inv10.RSC")

 		, _L("TRscCalypso_Inv11.RSC")

 		, _L("TRscCalypso_Inv12.RSC")

 		, _L("TRscComprU_Inv13.RSC")

 		, _L("TRscComprU_Inv14.RSC")

 		, _L("TRscComprU_Inv15.RSC")

 		, _L("TRscCalypso_Inv16.RSC")

 		, _L("TRscCalypso_Inv17.RSC")

 		, _L("TRscNotExist.RSC")		//This file doesn't exist

 		};

 	TInt i;

 	TInt array_size = TInt(sizeof(inv_rsc_files)/sizeof(inv_rsc_files[0]));

 	//Z drive

 	_LIT(KZDir, "z:\\system\\data\\");

 	for(i=0;i<array_size;i++)

 		{

 		TBuf<64> path;

 		path += KZDir;

 		path += inv_rsc_files[i];

 		TInt err = DoTestL(path);

 		test(err != KErrNone);

 		}

 	//C drive

 	_LIT(KCDir, "c:\\");

 	for(i=0;i<array_size;i++)

 		{

 		TBuf<64> src_path;

 		src_path += KZDir;

 		src_path += inv_rsc_files[i];

 		TBuf<64> dest_path;

 		dest_path += KCDir;

 		dest_path += inv_rsc_files[i];

 		//Copy the file to C drive except the last which doesn't exist.

 		//Zero sized file doesn't exist on the assabet/lubbock platforms.

 		TInt err = KErrNone;

 		if(i > 0 && i < (array_size - 1))

 			{

 			err = BaflUtils::CopyFile(TheFs, src_path, dest_path);

 			test(err == KErrNone || err == KErrAlreadyExists);

 			}

 		err = DoTestL(dest_path);

 		DeleteDataFile(dest_path);

 		test(err != KErrNone);

 		}

 	//C drive - new rsc file format

 	for(i=1;i<(array_size-1);i++)

 		{

 		TBuf<64> dest_path;

 		TBuf<64> src_path;

 		dest_path += KCDir;

 		dest_path += _L("N_");

 		dest_path += inv_rsc_files[i];

 		src_path += KZDir;

 		src_path += inv_rsc_files[i];

 		CreateFileFromL(dest_path, src_path);

 		TInt err = DoTestL(dest_path, KRscFileHeaderData().Length(), FileSizeL(src_path));

 		DeleteDataFile(dest_path);

 		test(err != KErrNone);

 		}

 	//Tests that Raise panics

 	PanicTest();

 	CleanupStack::PopAndDestroy(1, &TheFs);

     }

 GLDEF_C TInt E32Main()

 	{

     __UHEAP_MARK;

     CTrapCleanup* cleanup = CTrapCleanup::New();

 	test.Title();

 	test.Start(_L("Testing RResourceFile & CResourceFile panics/leaves"));

     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;

     }