// 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:

// t_msv_cache_indextableentry_step.cpp

//

#include "t_msv_cache_indextableentry_step.h"

#include <msvids.h>

#include <flogger.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#endif

#define MY_ASSERT_TRUE(a)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_TRUE(a);

#define MY_ASSERT_FALSE(a)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_FALSE(a);

#define MY_ASSERT_EQUALS(a,b)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_EQUALS(a,b);

_LIT(KSTDMSGINI, "C:\\private\\1000484b\\msgcache.ini");

_LIT(KMSGINI_2, "C:\\private\\1000484b\\msgcache2.ini");

CTestIndexTableEntry::CTestIndexTableEntry()

	{

	}

CTestIndexTableEntry::~CTestIndexTableEntry()

	{

	}

void CTestIndexTableEntry::SetupL()

	{

	_LIT(KFunction, "SetupL");

	INFO_PRINTF1(KFunction);

	//__UHEAP_MARK;

	TInt err =	iFileHandle.Connect();

	MY_ASSERT_EQUALS(err, KErrNone);

	//err = iFileHandle.Replace(KMSGINI_2, KSTDMSGINI);

	CFileMan* file = CFileMan::NewL(iFileHandle);

	err = file->Copy(KMSGINI_2, KSTDMSGINI);

	MY_ASSERT_EQUALS(err, KErrNone);

	delete file;

	//Create entry free pool.

	TDblQue<CMsvCacheVisibleFolder> iEntryCache;

	iMsvEntryFreePool = CMsvEntryFreePool::CreateL(&iEntryCache);

	//create index table entry

	iIndexTableEntry = CMsvCacheIndexTableEntry::NewL();

	iEntryPointer = new(ELeave) RPointerArray<CMsvCacheEntry>;

	}

void CTestIndexTableEntry::TearDownL()

	{

	_LIT(KFunction, "TearDownL");

	INFO_PRINTF1(KFunction);

	//destroy the index table entry

	delete iIndexTableEntry;

	if(iEntryPointer)

		{

		iEntryPointer->Close();

		delete iEntryPointer;

		iEntryPointer = NULL;

		}

	//iFileHandle.Replace(KSTDMSGINI, KMSGINI_2);

	iFileHandle.Close();

	// Delete entry free pool.

#ifdef _DEBUG

	CMsvEntryFreePool::Destroy(iMsvEntryFreePool);

	iMsvEntryFreePool = NULL;

#else

	delete iMsvEntryFreePool;

	iMsvEntryFreePool = NULL;

#endif

	//__UHEAP_MARKEND;

	}

void CTestIndexTableEntry::TestConstructorL()

	{

	_LIT(KFunction, "TestConstructorL");

	INFO_PRINTF1(KFunction);

	//Test whether a Index table entry is created correctly.

	CMsvCacheIndexTableEntry* tempTableEntry = NULL;

	TRAPD(err, tempTableEntry = new(ELeave) CMsvCacheIndexTableEntry);

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() == NULL);

	MY_ASSERT_TRUE(tempTableEntry->GetMaxMsvIdRange() == 0);

	MY_ASSERT_TRUE(tempTableEntry->GetMinMsvIdRange() == 0);

	MY_ASSERT_FALSE(tempTableEntry->IsGrandChildPresent());

	MY_ASSERT_FALSE(tempTableEntry->IsDirty());

	delete tempTableEntry;

	//Test the same using NewL

	TRAP(err, tempTableEntry = CMsvCacheIndexTableEntry::NewL());

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() == NULL);

	MY_ASSERT_TRUE(tempTableEntry->GetMaxMsvIdRange() == 0);

	MY_ASSERT_TRUE(tempTableEntry->GetMinMsvIdRange() == 0);

	MY_ASSERT_FALSE(tempTableEntry->IsGrandChildPresent());

	MY_ASSERT_FALSE(tempTableEntry->IsDirty());

	delete tempTableEntry;

	//Test creation with addition of one cache entry

	CMsvCacheEntry* entry = NULL;

	TRAP(err, entry = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entry->Entry().SetId((TMsvId)50);

	entry->Entry().SetParent((TMsvId)25);

	TRAP(err, tempTableEntry = CMsvCacheIndexTableEntry::NewL(entry));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() != NULL);

	MY_ASSERT_TRUE(tempTableEntry->GetMaxMsvIdRange() == 50);

	MY_ASSERT_TRUE(tempTableEntry->GetMinMsvIdRange() == 50);

	MY_ASSERT_FALSE(tempTableEntry->IsGrandChildPresent());

	MY_ASSERT_FALSE(tempTableEntry->IsDirty());

	MY_ASSERT_TRUE(tempTableEntry->GetEntry((TMsvId)50, entry));

	delete tempTableEntry;

	//Test the same using NewLC

	TRAP(err, entry = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entry->Entry().SetId((TMsvId)50);

	entry->Entry().SetParent((TMsvId)25);

	tempTableEntry = CMsvCacheIndexTableEntry::NewLC(entry);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() != NULL);

	MY_ASSERT_TRUE(tempTableEntry->GetMaxMsvIdRange() == 50);

	MY_ASSERT_TRUE(tempTableEntry->GetMinMsvIdRange() == 50);

	MY_ASSERT_FALSE(tempTableEntry->IsGrandChildPresent());

	MY_ASSERT_FALSE(tempTableEntry->IsDirty());

	MY_ASSERT_TRUE(tempTableEntry->GetEntry((TMsvId)50, entry));

	CleanupStack::Pop(); //tempTableEntry

	delete tempTableEntry;

	//Test creation with addition of list of entries

	RPointerArray<CMsvCacheEntry> addList;

	for(TInt index = 0; index < 10; ++index)

		{

		TRAP(err, entry = CMsvEntryFreePool::Instance()->EntryL());

		MY_ASSERT_EQUALS(KErrNone, err);

		entry->Entry().SetId((TMsvId)50+index);

		entry->Entry().SetParent((TMsvId)25);

		TRAP(err, addList.AppendL(entry));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	TRAP(err, tempTableEntry = CMsvCacheIndexTableEntry::NewL(addList));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() != NULL);

	MY_ASSERT_TRUE(tempTableEntry->Size() == 10);

	delete tempTableEntry;

	//Test the same using NewLC

	addList.Reset();

	for(TInt index = 0; index < 10; ++index)

		{

		TRAP(err, entry = CMsvEntryFreePool::Instance()->EntryL());

		MY_ASSERT_EQUALS(KErrNone, err);

		entry->Entry().SetId((TMsvId)50+index);

		entry->Entry().SetParent((TMsvId)25);

		TRAP(err, addList.AppendL(entry));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	tempTableEntry = CMsvCacheIndexTableEntry::NewLC(addList);

	MY_ASSERT_TRUE(tempTableEntry->BlockPtr() != NULL);

	MY_ASSERT_TRUE(tempTableEntry->Size() == 10);

	CleanupStack::Pop(); //tempTableEntry

	delete tempTableEntry;

	addList.Close();

	}

void CTestIndexTableEntry::TestAddEntry()

	{

	_LIT(KFunction, "TestAddEntry");

	INFO_PRINTF1(KFunction);

	TInt err;

	TInt bulkCount = 100;

	TMsvId msvId = KFirstFreeEntryId;

	RArray<CMsvCacheEntry*> entries;

	RArray<TMsvEntry> tmsvEntries;

	// t1. add single entry to empty block

	MY_ASSERT_TRUE(iIndexTableEntry->BlockPtr() == NULL);

	TRAP(err, entryA = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entryA->Entry().SetId(++msvId);

	++msvId;

	TTime timeBefore = iIndexTableEntry->AccessTime();

	TRAP(err, iIndexTableEntry->AddEntryL(entryA));

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entryA->GetId()));

	User::After(1000);

	TTime timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_EQUALS(iIndexTableEntry->GetMinMsvIdRange(), entryA->GetId());

	MY_ASSERT_EQUALS(iIndexTableEntry->GetMaxMsvIdRange(), entryA->GetId());

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	// t2. add entry to non-empty block

	TRAP(err, entryB = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entryB->Entry().SetId(++msvId);

	++msvId;

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(entryB));

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entryB->GetId()));

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	MY_ASSERT_EQUALS(iIndexTableEntry->GetMaxMsvIdRange(), entryB->GetId());

	// t3. add duplicate entry

	//---3.1 older entry has details to be preserved

	TInt sizeBefore = iIndexTableEntry->Size();

	CMsvCacheEntry *dupB = NULL;

	TRAP(err, dupB = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	dupB->Entry().SetId(entryB->GetId());

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(dupB)); //replace older entry = EFalse (default)

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entryB->GetId()));

	RPointerArray<CMsvCacheEntry>* blockPtr = iIndexTableEntry->BlockPtr();

	for(TInt index = 0; index < sizeBefore; ++index) //entries have different address

		{

		if( (*blockPtr)[index]->GetId() == entryB->GetId() )

			{

			MY_ASSERT_TRUE( &(*blockPtr)[index] != &dupB );

			}

		}

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore == timeAfter);

	TInt sizeAfter = iIndexTableEntry->Size();

	MY_ASSERT_EQUALS(sizeBefore, sizeAfter);

	//---3.2 newer entry has more recent details

	TRAP(err, entryD = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entryD->Entry().SetId(++msvId);

	++msvId;

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(entryD));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter); 

	CMsvCacheEntry *dupD = NULL;

	TRAP(err, dupD = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	dupD->Entry().SetId(entryD->GetId());

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(dupD, ETrue)); //replace older entry = ETrue

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(dupD->GetId()));

	for(TInt index = 0; index < sizeBefore; ++index) //entries have different address

		{

		if( (*blockPtr)[index]->GetId() == dupD->GetId() )

			{

			MY_ASSERT_TRUE( (*blockPtr)[index] != entryD );

			}

		}

	MY_ASSERT_FALSE(iIndexTableEntry->EntryExists(entryD->GetId()));

	timeAfter = iIndexTableEntry->AccessTime();

	//MY_ASSERT_TRUE(timeBefore != timeAfter);

	// t4. add entry with TMsvId < iMinMsvId

	TMsvId minId = iIndexTableEntry->GetMinMsvIdRange();

	TRAP(err, entryC = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entryC->Entry().SetId(minId - 1);

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(entryC));

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_EQUALS(iIndexTableEntry->GetMinMsvIdRange(), entryC->GetId());

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	// t5. add entry with TMsvId > iMaxMsvId

	TMsvId maxId = iIndexTableEntry->GetMaxMsvIdRange();

	TRAP(err, entryD = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	entryD->Entry().SetId(maxId + 1);

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntryL(entryD));

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_EQUALS(iIndexTableEntry->GetMaxMsvIdRange(), entryD->GetId());

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	// t6. add large amount of entries

	TMsvId id = msvId + 10;

	for(TInt index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		timeBefore = iIndexTableEntry->AccessTime();

		User::After(1000);

		TRAP(err, iIndexTableEntry->AddEntryL((entries[index])));

		ASSERT_EQUALS(err, KErrNone);

		timeAfter = iIndexTableEntry->AccessTime();

		ASSERT_TRUE(timeBefore != timeAfter);

		}

	for(TInt index = 0; index < bulkCount; ++index)

		{

		ASSERT_TRUE(iIndexTableEntry->EntryExists(tmsvEntries[index].Id()));

		}

	tmsvEntries.Close();

	entries.Close();

	}

void CTestIndexTableEntry::TestAddEntrySet()

	{

	_LIT(KFunction, "TestAddEntrySet");

	INFO_PRINTF1(KFunction);

	TInt err, index;

	TInt bulkCount = 5; //100;

	TTime timeBefore, timeAfter;

	TMsvId msvId = KFirstFreeEntryId;

	TMsvId id = msvId + 500;

	RPointerArray<CMsvCacheEntry> oEntries;

	// T1:	block is NULL. add only non-immediate children.

	MY_ASSERT_TRUE(iIndexTableEntry->BlockPtr() == NULL);

	RArray<CMsvCacheEntry*> entries;

	RArray<TMsvEntry> tmsvEntries;

	for(index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		TRAP(err, iEntryPointer->AppendL(entries[index]));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TRAP(err, iIndexTableEntry->AddEntrySetL(*iEntryPointer, 0, iEntryPointer->Count()));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	for(index = 0; index < bulkCount; ++index)

		{

		MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entries[index]->GetId()));

		}

	//---add entries less than those in aEntries

	iIndexTableEntry->ReleaseBlock(ETrue);

	iEntryPointer->Reset();

	entries.Reset();

	tmsvEntries.Reset();

	for(index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		TRAP(err, iEntryPointer->AppendL(entries[index]));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TInt aCount = 3;

	TRAP(err, iIndexTableEntry->AddEntrySetL(*iEntryPointer, 0, aCount));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	for(index = 0; index < aCount; ++index)

		{

		MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entries[index]->GetId()));

		}

	MY_ASSERT_EQUALS(iIndexTableEntry->Size(), aCount);

	for(index = aCount; index < bulkCount; ++index) //manually release remaining entries

		{

		}

	//---aCount > aEntries.Count()

	iIndexTableEntry->ReleaseBlock(ETrue);

	iEntryPointer->Reset();

	entries.Reset();

	tmsvEntries.Reset();

	for(index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		TRAP_IGNORE(iEntryPointer->AppendL(entries[index]));

		}

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	 aCount = bulkCount + 10;

	TRAP(err, iIndexTableEntry->AddEntrySetL(*iEntryPointer, 0, aCount));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	for(index = 0; index < bulkCount; ++index)

		{

		MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entries[index]->GetId()));

		}

	MY_ASSERT_EQUALS(iIndexTableEntry->Size(), bulkCount);

	//---[aInitIndex..aCount] < [0..bulkCount]

	iIndexTableEntry->ReleaseBlock(ETrue);

	iEntryPointer->Reset();

	entries.Reset();

	tmsvEntries.Reset();

	for(index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		TRAP(err, iEntryPointer->AppendL(entries[index]));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	TInt aInitIndex = 1;

	aCount = 3;

	//entries added are entries[1] to entries[3]. 0 and 4 are left out.

	TRAP(err, iIndexTableEntry->AddEntrySetL(*iEntryPointer, aInitIndex, aCount));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore != timeAfter);

	for(index = aInitIndex; index < aCount+aInitIndex; ++index)

		{

		MY_ASSERT_TRUE(iIndexTableEntry->EntryExists(entries[index]->GetId()));

		}

	MY_ASSERT_EQUALS(iIndexTableEntry->Size(), aCount);

	//---out of bounds index

	iIndexTableEntry->ReleaseBlock(ETrue);

	iEntryPointer->Reset();

	entries.Reset();

	tmsvEntries.Reset();

	for(index = 0 ; index < bulkCount; ++index, ++id)

		{

		tmsvEntries.Append(TMsvEntry());

		tmsvEntries[index].SetId(id);

		TRAP(err, entries.Append(CMsvEntryFreePool::Instance()->EntryL()));

		MY_ASSERT_EQUALS(KErrNone, err);

		entries[index]->Entry().SetId(tmsvEntries[index].Id());

		TRAP(err, iEntryPointer->AppendL(entries[index]));

		MY_ASSERT_EQUALS(KErrNone, err);

		}

	timeBefore = iIndexTableEntry->AccessTime();

	User::After(1000);

	aInitIndex = -1;

	aCount = 3;

	TRAP(err, iIndexTableEntry->AddEntrySetL(*iEntryPointer, aInitIndex, aCount));

	MY_ASSERT_EQUALS(err, KErrNone);

	timeAfter = iIndexTableEntry->AccessTime();

	MY_ASSERT_TRUE(timeBefore == timeAfter);

	for(index = 0; index < bulkCount; ++index)

		{

		MY_ASSERT_FALSE(iIndexTableEntry->EntryExists(entries[index]->GetId()));

		}

	MY_ASSERT_EQUALS(iIndexTableEntry->Size(), 0);

	for(index = 0; index < bulkCount; ++index)

		{

		}

	// T2:	block is NULL. add only immediate children.

	// start afresh.

	iIndexTableEntry->ReleaseBlock(ETrue);

	msvId = KFirstFreeEntryId;

	TRAP(err, parent = CMsvEntryFreePool::Instance()->EntryL());

	MY_ASSERT_EQUALS(KErrNone, err);

	parent->Entry().SetId(++msvId);

	++msvId;

	TRAP(err, entryA = CMsvEntryFreePool::Instance()->EntryL());