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

#include <bautils.h>

#include <barsread2.h>

#include <barsc2.h>

#include <baspi.h>

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);

    }