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