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

#include <s32fileiter.h>

RTest TheTest(_L("t_storetoc test"));

RFs TheFs;

TBuf<KMaxFileName> TheFileName;

CPermanentFileStore* TheStore = NULL;

void DeleteTestFiles()

	{

	delete TheStore;

	TheStore = NULL;

	(void)TheFs.Delete(TheFileName);

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DeleteTestFiles();

		TheTest(EFalse, aLine);

		}

	}

void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		DeleteTestFiles();

		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

void CreateTestEnv(TInt aDriveNo)

    {

    TChar ch;

	TInt err = TheFs.DriveToChar(aDriveNo, ch);

	TEST2(err, KErrNone);

    TBuf<2> drvName;

    drvName.SetLength(2);

    drvName[0] = ch;

    drvName[1] = TChar(':');

	_LIT(KTestFile, "c:\\stor-tst\\t_storetoc.dat");

    TParse parse;

    parse.Set(drvName, &KTestFile, 0);

	const TDesC& dbFilePath = parse.FullName();

	TheFileName.Copy(dbFilePath);

	err = TheFs.MkDir(parse.DriveAndPath());

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

	}

///////////////////////////////////////////////////////////////////////////////////////

//////////////////////              TTocTestBase        ///////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Base TOC test class.

//It offers the folowing functions: Prepare(), Test() and Verify().

//The test algorithm is:

//  =================================

//  void TestFunc(TTocTestBase& aTestObj)

//  {

//	  aTestObj.Prepare();

//    [simulate file system error];

//	  TInt err = aTestObj.Test();

//    [clear file system error];

//	  aTestObj.Verify(err);

//  }

//  =================================

//The class has two private pure virtual methods, which have to be overriden in derived classes:

//  DoPrepareL() - instance specific test preparation;

//  DoVerify()   - instance specific test verification;

class TTocTestBase

	{

public:

	TTocTestBase()

		{

		TheStore = NULL;

		}

	void Prepare()

		{

		TEST(TheStore == NULL);

		TRAPD(err, DoPrepareL());

		TEST2(err, KErrNone);

		}

	TInt Test()

		{

		TEST(TheStore != NULL);

		TRAPD(err, {TheStore->CompactL(); TheStore->CommitL();});

		delete TheStore;

		TheStore = NULL;

		return err;

		}

	void Verify(TInt aTestErr)

		{

		TEST(TheStore == NULL);

		TRAPD(err, DoVerifyL(aTestErr));

		TEST2(err, KErrNone);

		}

protected:

	TStreamId WriteNewStreamL(const TDesC8& aStreamData)

		{

		TEST(TheStore != NULL);

		RStoreWriteStream stream;

		TStreamId streamId = stream.CreateLC(*TheStore);

		stream.WriteL(aStreamData);

		stream.CommitL();

		TheStore->CommitL();

		CleanupStack::PopAndDestroy(&stream);

		return streamId;

		}

private:

	virtual void DoPrepareL() = 0;

	virtual void DoVerifyL(TInt aTestErr) = 0;

	};

///////////////////////////////////////////////////////////////////////////////////////

//////////////////////                TBaseTocEntryTest        ////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Do not change/shift the next lines, because "new line/space" characters will be inserted in the string!

_LIT8(KStreamData1, "-01-ABCD-02-ABCD-03-ABCD-04-ABCD-05-ABCD-06-ABCD-07-ABCD-08-ABCD");

_LIT8(KStreamData1_2, "ABCDEFGH-41-ABCD-42-ABCD-43-A\

-33-ABCD-34-ABCD-35-ABCD-36-ABCD-37-ABCD-38-ABCD-39-ABCD-40-ABCD\

-25-ABCD-26-ABCD-27-ABCD-28-ABCD-29-ABCD-30-ABCD-31-ABCD-32-ABCD\

-17-ABCD-18-ABCD-19-ABCD-20-ABCD-21-ABCD-22-ABCD-23-ABCD-24-ABCD\

-09-ABCD-10-ABCD-11-ABCD-12-ABCD-13-ABCD-14-ABCD-15-ABCD-16-ABCD");

_LIT8(KStreamData1_3, "0123456789");

//"Base TOC entry" test.

//When a stream is relocated, its base TOC entry needs 2 "file write" (for "atomic block write" media) operations, because

//the TOC entry is split over a block boundary.

//This test class uses a set of test data, which puts the TOC entry of the relocated stream at position

//510 in the file (TOC entry length - 5 bytes).

class TBaseTocEntryTest : public TTocTestBase

	{

public:

	TBaseTocEntryTest() :

		iStreamId1(KNullStreamIdValue),

		iStreamId2(KNullStreamIdValue),

		iStreamId3(KNullStreamIdValue)

		{

		}

private:

	void DoPrepareL()

		{

		TheStore = CPermanentFileStore::ReplaceLC(TheFs, TheFileName, EFileWrite);

		TheStore->SetTypeL(TheStore->Layout());

		TheStore->CommitL();

		iStreamId1 = WriteNewStreamL(KStreamData1);

		TheStore->SetRootL(iStreamId1);

		TheStore->CommitL();

		iStreamId2 = WriteNewStreamL(KStreamData1_2);

		iStreamId3 = WriteNewStreamL(KStreamData1_3);

		TheStore->DeleteL(iStreamId2);

		TheStore->CommitL();

		CleanupStack::Pop(TheStore);

		}

	virtual void DoVerifyL(TInt)

		{

		TEST(TheStore == NULL);

		TheStore = CPermanentFileStore::OpenLC(TheFs, TheFileName, EFileWrite);

		RPermanentFileStoreIter iter;

		iter.ResetLC(*TheStore);

		//Stream 1

		TStreamId streamId = iter.NextL();

		TEST(streamId == iStreamId1);

		RStoreReadStream strm;

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData1().Length());

		TBuf8<sizeof(KStreamData1)> buf;

		strm.ReadL(buf, KStreamData1().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData1().Ptr(), KStreamData1().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 2

		streamId = iter.NextL();

		TEST(streamId == iStreamId3);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData1_3().Length());

		strm.ReadL(buf, KStreamData1_3().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData1_3().Ptr(), KStreamData1_3().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//No more streams

		streamId = iter.NextL();

		TEST(streamId == KNullStreamIdValue);

		//Cleanup

		CleanupStack::PopAndDestroy(&iter);

		CleanupStack::PopAndDestroy(TheStore);

		TheStore = NULL;

		}

private:

	TStreamId iStreamId1;

	TStreamId iStreamId2;

	TStreamId iStreamId3;

	};

///////////////////////////////////////////////////////////////////////////////////////

//////////////////////              TDeltaTocEntryTest        /////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Do not change/shift the next lines, because "new line/space" characters will be inserted in the string!

_LIT8(KStreamData2, "\

-01-ABCD-02-ABCD-03-ABCD-04-ABCD-05-ABCD-06-ABCD-07-ABCD-08-ABCD\

-09-ABCD-10-ABCD-11-ABCD-12");

_LIT8(KStreamData2_2, "ABC");

_LIT8(KStreamData2_3, "012345678");

//"Delta TOC entry" test

//When a stream is relocated, its delta TOC entry needs 2 "file write" (for "atomic block write" media) operations, because

//the TOC entry is split over a block boundary.

//This test class uses a set of test data, which puts the TOC entry of the relocated stream at position

//507 in the file (TOC entry length - 8 bytes), so the last 4 bytes (stream offset) are split.

class TDeltaTocEntryTest : public TTocTestBase

	{

public:

	TDeltaTocEntryTest() :

		iStreamId1(KNullStreamIdValue),

		iStreamId2(KNullStreamIdValue),

		iStreamId3(KNullStreamIdValue),

		iStreamId4(KNullStreamIdValue),

		iStreamId5(KNullStreamIdValue)

		{

		}

protected:

	virtual void DoPrepareL()

		{

		TheStore = CPermanentFileStore::ReplaceLC(TheFs, TheFileName, EFileWrite);

		TheStore->SetTypeL(TheStore->Layout());

		TheStore->CommitL();

		iStreamId1 = WriteNewStreamL(KStreamData2);

		TheStore->SetRootL(iStreamId1);

		TheStore->CommitL();

		iStreamId2 = WriteNewStreamL(KStreamData2);

		iStreamId3 = WriteNewStreamL(KStreamData2().Left(KStreamData2().Length() - 1));

		iStreamId4 = WriteNewStreamL(KStreamData2_2);

		iStreamId5 = WriteNewStreamL(KStreamData2_3);

		TheStore->DeleteL(iStreamId4);

		TheStore->CommitL();

		CleanupStack::Pop(TheStore);

		}

	virtual void DoVerifyL(TInt)

		{

		TEST(TheStore == NULL);

		TheStore = CPermanentFileStore::OpenLC(TheFs, TheFileName, EFileWrite);

		RPermanentFileStoreIter iter;

		iter.ResetLC(*TheStore);

		//Stream 1

		TStreamId streamId = iter.NextL();

		TEST(streamId == iStreamId1);

		RStoreReadStream strm;

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData2().Length());

		TBuf8<sizeof(KStreamData2)> buf;

		strm.ReadL(buf, KStreamData2().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData2().Ptr(), KStreamData2().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 2

		streamId = iter.NextL();

		TEST(streamId == iStreamId2);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData2().Length());

		strm.ReadL(buf, KStreamData2().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData2().Ptr(), KStreamData2().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 3

		streamId = iter.NextL();

		TEST(streamId == iStreamId3);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData2().Length() - 1);

		strm.ReadL(buf, KStreamData2().Length() - 1);

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData2().Ptr(), KStreamData2().Length() - 1), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 4

		streamId = iter.NextL();

		TEST(streamId == iStreamId5);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData2_3().Length());

		strm.ReadL(buf, KStreamData2_3().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData2_3().Ptr(), KStreamData2_3().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//No more streams

		streamId = iter.NextL();

		TEST(streamId == KNullStreamIdValue);

		//Cleanup

		CleanupStack::PopAndDestroy(&iter);

		CleanupStack::PopAndDestroy(TheStore);

		TheStore = NULL;

		}

private:

	TStreamId iStreamId1;

	TStreamId iStreamId2;

	TStreamId iStreamId3;

	TStreamId iStreamId4;

	TStreamId iStreamId5;

	};

///////////////////////////////////////////////////////////////////////////////////////

//////////////////////              TBaseTocReferenceTest        //////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Do not change/shift the next lines, because "new line/space" characters will be inserted in the string!

_LIT8(KStreamData3, "\

-01-ABCD-02-ABCD-03-ABCD-04-ABCD-05-ABCD-06-ABCD-07-ABCD-08-ABCD\

-09-ABCD-10-ABCD-11-ABCD-12-ABCD");

_LIT8(KStreamData3_2, "ABCDEFGH");

_LIT8(KStreamData3_3, "0123456789");

//"Base TOC reference" test.

//When the base TOC is relocated, the delta TOC reference to the base TOC has to be updated with

// 2 "file write" operations (for "atomic block write" media), because the reference is split over a block boundary.

//This test class uses a set of test data, which puts the delta TOC reference to the base TOC

//at position 511 in the file (reference length - 4 bytes)

class TBaseTocReferenceTest : public TTocTestBase

	{

public:

	TBaseTocReferenceTest() :

		iStreamId1(KNullStreamIdValue),

		iStreamId2(KNullStreamIdValue),

		iStreamId3(KNullStreamIdValue),

		iStreamId4(KNullStreamIdValue),

		iStreamId5(KNullStreamIdValue)

		{

		}

protected:

	virtual void DoPrepareL()

		{

		TheStore = CPermanentFileStore::ReplaceLC(TheFs, TheFileName, EFileWrite);

		TheStore->SetTypeL(TheStore->Layout());

		TheStore->CommitL();

		iStreamId1 = WriteNewStreamL(KStreamData3);

		TheStore->SetRootL(iStreamId1);

		TheStore->CommitL();

		iStreamId2 = WriteNewStreamL(KStreamData3);

		iStreamId3 = WriteNewStreamL(KStreamData3().Left(KStreamData3().Length() - 3));

		iStreamId4 = WriteNewStreamL(KStreamData3_2);

		iStreamId5 = WriteNewStreamL(KStreamData3_3);

		TheStore->DeleteL(iStreamId4);

		TheStore->CommitL();

		CleanupStack::Pop(TheStore);

		}

	virtual void DoVerifyL(TInt)

		{

		TEST(TheStore == NULL);

		TheStore = CPermanentFileStore::OpenLC(TheFs, TheFileName, EFileWrite);

		RPermanentFileStoreIter iter;

		iter.ResetLC(*TheStore);

		//Stream 1

		TStreamId streamId = iter.NextL();

		TEST(streamId == iStreamId1);

		RStoreReadStream strm;

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData3().Length());

		TBuf8<sizeof(KStreamData3)> buf;

		strm.ReadL(buf, KStreamData3().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData3().Ptr(), KStreamData3().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 2

		streamId = iter.NextL();

		TEST(streamId == iStreamId2);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData3().Length());

		strm.ReadL(buf, KStreamData3().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData3().Ptr(), KStreamData3().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 3

		streamId = iter.NextL();

		TEST(streamId == iStreamId3);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData3().Length() - 3);

		strm.ReadL(buf, KStreamData3().Length() - 3);

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData3().Ptr(), KStreamData3().Length() - 3), 0);

		CleanupStack::PopAndDestroy(&strm);

		//Stream 4

		streamId = iter.NextL();

		TEST(streamId == iStreamId5);

		strm.OpenLC(*TheStore, streamId);

		TEST2(strm.Source()->SizeL(), KStreamData3_3().Length());

		strm.ReadL(buf, KStreamData3_3().Length());

		TEST2(Mem::Compare(buf.Ptr(), buf.Length(), KStreamData3_3().Ptr(), KStreamData3_3().Length()), 0);

		CleanupStack::PopAndDestroy(&strm);

		//No more streams

		streamId = iter.NextL();

		TEST(streamId == KNullStreamIdValue);

		//Cleanup

		CleanupStack::PopAndDestroy(&iter);

		CleanupStack::PopAndDestroy(TheStore);

		TheStore = NULL;

		}

private:

	TStreamId iStreamId1;

	TStreamId iStreamId2;

	TStreamId iStreamId3;

	TStreamId iStreamId4;

	TStreamId iStreamId5;

	};

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

void TocTest(TTocTestBase& aTestObj)

	{

	TInt err = KErrGeneral;

	for(TInt cnt=1;err!=KErrNone;++cnt)

		{

		TheTest.Printf(_L("%d\r"), cnt);

		aTestObj.Prepare();

		(void)TheFs.SetErrorCondition(KErrGeneral, cnt);

		err = aTestObj.Test();

		(void)TheFs.SetErrorCondition(KErrNone);

		aTestObj.Verify(err);

		}

	TheTest.Printf(_L("\n"));

	TEST2(err, KErrNone);

	aTestObj.Verify(err);

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-3481

@SYMTestCaseDesc        The test is performed on media, where atomic "block write" operations are guaranteed.

						In a "file I/O error" simulation loop:

						 - Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						   such that a base TOC entry is split over the block boundary;

						 - Compacts the store;

						 - Commits;

@SYMTestPriority        High

@SYMTestActions         Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						such that a base TOC entry is split over the block boundary. When the store is compacted

						and the used media supports atomic "block write" operations, the STORE will update

						the base TOC entry, which requires a "file write" operation crossing the block boundary.

@SYMTestExpectedResults The test should not fail or panic.

@SYMREQ                 REQ0000

*/

void BaseTocEntryTest()

	{

	TBaseTocEntryTest baseTocEntryTestObj;

	TocTest(baseTocEntryTestObj);

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-3482

@SYMTestCaseDesc        The test is performed on media, where atomic "block write" operations are guaranteed.

						In a "file I/O error" simulation loop:

						 - Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						   such that a delta TOC entry is split over the block boundary;

						 - Compacts the store;

						 - Commits;

@SYMTestPriority        High

@SYMTestActions         Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						such that a delta TOC entry is split over the block boundary. When the store is compacted

						and the used media supports atomic "block write" operations, the STORE will update

						the delta TOC entry, which requires a "file write" operation crossing the block boundary.

@SYMTestExpectedResults The test should not fail or panic.

@SYMREQ                 REQ0000

*/

void DeltaTocEntryTest()

	{

	TDeltaTocEntryTest deltaTocEntryTestObj;

	TocTest(deltaTocEntryTestObj);

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-3483

@SYMTestCaseDesc        The test is performed on media, where atomic "block write" operations are guaranteed.

						In a "file I/O error" simulation loop:

						 - Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						   such that a base TOC reference is split over the block boundary;

						 - Compacts the store;

						 - Commits;

@SYMTestPriority        High

@SYMTestActions         Creates a CPermanentStoreFile object, stores there carefully selected set of test data,

						such that a base TOC reference is split over the block boundary. When the store is compacted

						and the used media supports atomic "block write" operations, the STORE will update

						the base TOC reference, which requires a "file write" operation crossing the block boundary.

@SYMTestExpectedResults The test should not fail or panic.

@SYMREQ                 REQ0000

*/

void BaseTocReferenceTest()

	{