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