// Copyright (c) 1998-2010 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 <s32cont.h>

#include <s32file.h>

#include <s32crypt.h>

#include <e32test.h>

#include <pbe.h>

#include "UP_STD.H"

const TInt KTestCleanupStack=0x20;

// This is a path specification and should not be used as is

_LIT(KFileLocationSpec, "Z:\\STOR-TST\\T_SPAGE.DAT");

_LIT(KPageFilePath, "C:\\TestSTOR\\T_SPAGEFILE.PAG");

_LIT(KPageFilePathOnly, "C:\\TestSTOR\\");

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RTest TheTest(_L("t_storpage"));

LOCAL_D RFs TheFs;

LOCAL_D CFileStore* TheStore;

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

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

//Tests macros and functions.

//If (!aValue) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TheTest.Printf(_L("*** Boolean expression evaluated to false!\r\n"));

		TheTest(EFalse, aLine);

		}

	}

//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.

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

	{

	if(aValue != aExpected)

		{

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

		TheTest(EFalse, aLine);

		}

	}

//Use these to test conditions.

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

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

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

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1178

@SYMTestCaseDesc	    TPagedSet functionality test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for insert,delete,contains,with and without duplicates operations

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void test1L(MPagePool& aPagePool)

	{

	const TInt KEntryCount=200;

	TPagedSet<TInt32> set;

	set.Connect(&aPagePool);

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1178 Insertion & Deletion "));

	TInt32 it=0;

	set.InsertL(it);

	TEST2(set.Count(), 1);

	TRAPD(r,set.InsertL(it));

	TEST2(r, KErrAlreadyExists);

	TEST2(set.Count(), 1);

	TEST(set.ContainsL(it));

	set.DeleteL(it);

	TEST2(set.Count(), 0);

	TRAP(r,set.DeleteL(it));

	TEST2(r, KErrNotFound);

	TEST2(set.Count(), 0);

	TEST(!set.ContainsL(it));

	TheTest.Next(_L("No duplicates"));

	TInt ii;

	for (ii=0;ii<KEntryCount;++ii)

		{

		it=ii;

		set.InsertL(it);

		}

	for (ii=0;ii<KEntryCount;++ii)

		{

		it=ii;

		TEST(set.ContainsL(it));

		}

	TEST2(set.Count(), KEntryCount);

	TheTest.Next(_L("Empty the set"));

	set.ClearL();

	TEST2(set.Count(), 0);

	for (ii=0;ii<KEntryCount;++ii)

		{

		it=ii;

		TEST(!set.ContainsL(it));

		}

	TheTest.End();

	}

struct TTest

	{

	inline TTest() {Mem::FillZ(this,sizeof(*this));}

	TUint32 iVal;

	TUint32 iPadding[14];

	};

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1179

@SYMTestCaseDesc	    Tests for large set of TUint32

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for inserting,contains,iteration,deletion operations

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void test2L(MPagePool& aPagePool)

	{

	const TInt KEntryCount=500;

	TPagedSet<TTest> set;

	set.Connect(&aPagePool);

	TTest item;

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1179 Add items "));

	TUint32 jj=0;

	TInt32 ii;

	for (ii=KEntryCount;ii>0;--ii)

		{

		jj=(jj+17)%KEntryCount;

		item.iVal=jj;

		set.InsertL(item);

		}

	TEST2(set.Count(), KEntryCount);

	TheTest.Next(_L("Check contents"));

	for (ii=0;ii<KEntryCount;++ii)

		{

		item.iVal=ii;

		TEST(set.ContainsL(item));

		}

	TheTest.Next(_L("Iterate over items"));

	TUint8 *checkMap=(TUint8*)User::AllocLC(KEntryCount);

	Mem::FillZ(checkMap,KEntryCount);

	TPagedSetIter<TTest> iter(set);

	if (iter.ResetL())

		do	++checkMap[iter.AtL().iVal]; while (iter.NextL());

	for (ii=0;ii<KEntryCount;++ii)

		TEST2(checkMap[ii], 1);

	CleanupStack::PopAndDestroy();

	TheTest.Next(_L("Delete items"));

	jj=0;

	for (ii=KEntryCount;ii>KEntryCount/2;--ii)

		{

		jj=(jj+17)%KEntryCount;

		item.iVal=jj;

		set.DeleteL(item);

		}

	TEST2(set.Count(), KEntryCount/2);

	TheTest.Next(_L("Check contents"));

	for (;ii>0;--ii)

		{

		jj=(jj+17)%KEntryCount;

		item.iVal=jj;

		TEST(set.ContainsL(item));

		}

	jj=0;

	for (ii=KEntryCount;ii>KEntryCount/2;--ii)

		{

		jj=(jj+17)%KEntryCount;

		item.iVal=jj;

		TEST(!set.ContainsL(item));

		}

	TheTest.Next(_L("Delete items"));

	for (;ii>1;--ii)

		{

		jj=(jj+17)%KEntryCount;

		item.iVal=jj;

		set.DeleteL(item);

		}

	TEST2(set.Count(), 1);

	TheTest.Next(_L("Check contents"));

	jj=(jj+17)%KEntryCount;

	TPagedSetBiIter<TTest> biter(set);

	TEST(biter.FirstL());

	TEST2(biter.AtL().iVal, jj);

	TEST(!biter.NextL());

	TEST(biter.LastL());

	TEST2(biter.AtL().iVal ,jj);

	TEST(!biter.PreviousL());

	TPagedSetRIter<TTest> riter(set);

	TEST(riter.ResetL());

	TEST2(riter.AtL().iVal, jj);

	TEST(!riter.NextL());

	item.iVal=jj;

	set.DeleteL(item);

	TEST(!iter.ResetL());

	TEST2(set.Count(), 0);

	TheTest.End();

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1180

@SYMTestCaseDesc	    Streaming tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for read and write operations on the streams

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void test3L(RStorePagePool& aPool)

	{

	const TInt KEntryCount=1000;

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1180 Build set and stream out "));

	aPool.Create(*TheStore);

	TBool rc = aPool.HasAvailable();

	TEST(!rc);

	rc = aPool.IsEmpty();

	TEST(rc);

	TStorePagePoolToken token2(TStorePagePoolToken::EEmpty);

	token2 = aPool.Token();

	rc = token2.IsEmpty();

	TEST(rc);

	rc = token2.HasAvailable();

	TEST(!rc);

	TPagedSet<TInt32> set1;

	set1.Connect(&aPool);

	TInt ii;

	for (ii=0;ii<KEntryCount;ii++)

		{

		TInt32 it=ii;

		set1.InsertL(it);

		}

	aPool.FlushL();

	RStoreWriteStream out;

	TStreamId id=out.CreateLC(*TheStore);

	out<<aPool.Token();

	out<<set1.Token();

	out.CommitL();

	CleanupStack::PopAndDestroy();	// out

	aPool.Close();

//

	TheTest.Next(_L("Stream in and test set"));

	RStoreReadStream in;

	in.OpenLC(*TheStore,id);

	TStorePagePoolToken ptoken;

	in>>ptoken;

	aPool.Open(*TheStore,ptoken);

	TEST(!aPool.IsDirty());

	TPagedSetToken token;

	in>>token;

	TPagedSet<TInt32> set2(token);

	set2.Connect(&aPool);

	TEST(set2.IsIntact());

	CleanupStack::PopAndDestroy();	// in

	TEST2(set2.Count(), KEntryCount);

	for (ii=0;ii<KEntryCount;ii++)

		{

		TInt32 it=ii;

		set2.DeleteL(it);

		}

	TEST2(set2.Count(), 0);

	aPool.FlushL();

	aPool.Discard();

	aPool.ReclaimAllL();

	aPool.Close();

	TheTest.End();

	}

/**

@SYMTestCaseID          PDS-STORE-CT-4009

@SYMTestCaseDesc	    RFilePagePool tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for creating and opening RFilePagePool

@SYMTestExpectedResults RFilePagePool needs to be correctly created, replaced and opened.

@SYMDEF                 DEF135804

*/

LOCAL_C void test4L()

	{

	RFilePagePool testPage;

	TFileName tempPageFileName;

	RFs fs;

	TInt err;

	fs.Connect();

	err = fs.MkDirAll(KPageFilePathOnly);

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

	err = fs.Delete(KPageFilePath);

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

	CPageCache* pcache = CPageCache::NewLC(2);

	//creating file

	TheTest.Printf(_L("Creating file for the page pool"));

	err = testPage.Create(fs, KPageFilePath, EFileWrite);

	TEST2(err, KErrNone);

	testPage.Set(*pcache);

	TheTest.Printf(_L("-> File created -> Closing "));

	testPage.Close();

	TheTest.Printf(_L("-> Closed "));

	//opening file, file should be present after successful creation

	TheTest.Printf(_L("Opening file for the page pool"));

	err = testPage.Open(fs,KPageFilePath, EFileWrite);

	TEST2(err, KErrNone);

	testPage.Set(*pcache);

	TheTest.Printf(_L("-> File opened -> Closing "));

	testPage.Close();

	TheTest.Printf(_L("-> Closed "));

	//try to replace already existing file

	//file should exist after successful creation

	TheTest.Printf(_L("Replacing file for the page pool"));

	err = testPage.Replace(fs, KPageFilePath, EFileWrite);

	TEST2(err, KErrNone);

	testPage.Set(*pcache);

	TheTest.Printf(_L("-> File replaced -> Closing "));

	testPage.Close();

	TheTest.Printf(_L("-> Closed "));

	//try to create temp file with unique name

	TheTest.Printf(_L("Creating temp unique file "));

	err = testPage.Temp(fs, KPageFilePathOnly, tempPageFileName, EFileWrite);

	TEST2(err, KErrNone);

	testPage.Set(*pcache);

	TheTest.Printf(_L("-> File created -> Closing "));

	testPage.Close();

	TheTest.Printf(_L("-> Closed "));

	//if file was propertly created we should be able to open it

	TheTest.Printf(_L("Opening temp unique file "));

	err = testPage.Open(fs, tempPageFileName, EFileWrite);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("-> File opened -> Releasing "));

	testPage.Release();

	TheTest.Printf(_L("-> Released "));

	//open and flush temp file

	RFilePagePool testPage2(*pcache);

	err = testPage2.Open(fs, tempPageFileName, EFileWrite);

	TEST2(err, KErrNone);

	err = testPage2.Flush();

	TEST2(err, KErrNone);

	TRAP(err, testPage2.FlushL());

	TEST2(err, KErrNone);

	RFile& file = const_cast<RFile&>(testPage2.File());

	TFileName testIsSameFile;

	file.FullName(testIsSameFile);

	TEST2( testIsSameFile.Compare(tempPageFileName), 0);

	testPage2.Detach();

	file.Close();

	//attach and detach file

	file.Open(fs, testIsSameFile, EFileWrite|EFileShareReadersOrWriters);

	testPage2.Attach(file);

	testPage2.Detach();

	file.Close();

	testPage2.Close();

	CleanupStack::PopAndDestroy(pcache);

	fs.Close();

	}

/**

 * Struct needed in test5()

 */

struct SCachePage

	{

	TCachePage iPage[1];

	TUint8 iData[KPoolPageSize];

	};

/**

 * Class specially created to test protected API from RFilePagePool

 */

class RFilePagePoolTestClass: public RFilePagePool

	{

public:

	void CallProtectedWriteL(SCachePage& page)

		{

		TPageChange change=page.iPage[0].iChange;

		WriteL(page.iPage[0].iRef,&page.iPage[1],change);

		}

	void CallProtectedReadL(SCachePage& page)

		{

		ReadL(page.iPage[0].iRef,&page.iPage[1]);

		}

	TPageRef CallProtectedExtendL(SCachePage& page)

		{

		ExtendL(&page.iPage[1],EPageReclaimable);

		return page.iPage[0].iRef;

		}

	};

/**

@SYMTestCaseID          PDS-STORE-CT-4010

@SYMTestCaseDesc	    RFilePagePool protected API tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for read and write and extend operations

@SYMTestExpectedResults Cache pages should be properly written and properly read from RFilePagePoolTestClass

@SYMDEF                 DEF135804

*/

LOCAL_C void test5L()

	{

	SCachePage page;

	page.iPage[0].iRef = 1;

	page.iPage[0].iChange=EPageNoChange;

	RFilePagePoolTestClass fpp;

	RFs fs;

	fs.Connect();

	fs.MkDirAll(KPageFilePathOnly);

	fs.Delete(KPageFilePath);

	CPageCache* pcache = CPageCache::NewLC(2);

	//creating file

	TheTest.Printf(_L("Creating file "));

	TInt err = fpp.Create(fs, KPageFilePath, EFileWrite);

	TEST2(err, KErrNone);

	fpp.Set(*pcache);

	TheTest.Printf(_L("-> File created -> Testing protected API "));

	TRAP(err, fpp.CallProtectedWriteL(page));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("-> CallProtectedWriteL() done "));

	TRAP(err, fpp.CallProtectedReadL(page));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("-> CallProtectedReadL() done "));

	TRAP(err, fpp.CallProtectedExtendL(page));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("-> CallProtectedExtendL() done -> Closing"));

	fpp.Close();

	TheTest.Printf(_L("-> Closed "));

	CleanupStack::PopAndDestroy(pcache);

	fs.Close();

	}

const TInt KCachePages=16;

LOCAL_C void testallL(RStorePagePool& aPool)

	{

	TheTest.Start(_L("Connecting page pool"));

	aPool.Set(*CPageCache::NewLC(KCachePages));

	aPool.Create(*TheStore);

	TheTest.Next(_L("Basic operations"));

	test1L(aPool);

	TheTest.Next(_L("Large set TUint32"));

	test2L(aPool);

	aPool.Discard();

	aPool.ReclaimAllL();

	aPool.Close();

	TheTest.Next(_L("Tokens and streaming"));

	test3L(aPool);

	CleanupStack::PopAndDestroy();	//cache

	TheTest.Next(_L("PDS-STORE-CT-4009: RFilePagePool tests"));

	test4L();

	TheTest.Next(_L("PDS-STORE-CT-4010: RFilePagePool protected API tests"));

	test5L();

	TheTest.End();

	}

/**

@SYMTestCaseID          PDS-STORE-CT-4021

@SYMTestCaseDesc	    RStorePagePool protected API tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for different constructors

@SYMTestExpectedResults Objects must be created successfully

@SYMDEF                 DEF135804

*/

LOCAL_C void testconstructionL(CPBEncryptSet* aKey)

	{

	TheTest.Next(_L("PDS-STORE-CT-4021: RStorePagePool protected API tests"));

	CPageCache* pcache = CPageCache::NewLC(KCachePages);

	TStorePagePoolToken token;

	RStorePagePool poolcached(*pcache);

	poolcached.Create(*TheStore);

	test1L(poolcached);

	poolcached.Discard();

	poolcached.ReclaimAllL();

	poolcached.Close();	

	RStorePagePool poolstream(*TheStore);

	poolstream.Set(*pcache);

	test1L(poolstream);

	poolstream.Discard();

	poolstream.ReclaimAllL();

	poolstream.Close();

	RStorePagePool poolstreamtoken(*TheStore, token);

	poolstreamtoken.Set(*pcache);

	test1L(poolstreamtoken);	

	poolstreamtoken.Close();

	RSecureStorePagePool securepoolcached( *pcache, *aKey );

	securepoolcached.Create(*TheStore);

	test1L(securepoolcached);

	securepoolcached.Discard();

	securepoolcached.ReclaimAllL();

	securepoolcached.Close();

	CleanupStack::PopAndDestroy();

	}

LOCAL_C void doMainL()

	{

	TheTest.Start(_L("Store PagePool"));

	TParsePtrC parse(KFileLocationSpec);

	TheStore=CPermanentFileStore::ReplaceLC(TheFs,parse.NameAndExt(),EFileRead|EFileWrite);

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

	RStorePagePool pool1;

	testallL(pool1);

	TheTest.Next(_L("Secure PagePool"));

	CPBEncryptSet* key = CPBEncryptSet::NewLC(_L("the password"));

	RSecureStorePagePool pool2(*key);

	testallL(pool2);

	testconstructionL(key);

	CleanupStack::PopAndDestroy(key);

	TheStore->CommitL();

	CleanupStack::PopAndDestroy();	// store

	}

//

// Prepare the test directory.

//

LOCAL_C void setupTestDirectory()

    {

	TInt r=TheFs.Connect();

	TEST2(r, KErrNone);

//

	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	

	TParse parse;

	parse.Set(drive.Name(), &KFileLocationSpec, NULL);

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

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

	r=TheFs.SetSessionPath(parse.DriveAndPath());

	TEST2(r, KErrNone);

	}

//

// Initialise the cleanup stack.

//

LOCAL_C void setupCleanup()

    {

	TheTrapCleanup=CTrapCleanup::New();

	TEST(TheTrapCleanup!=NULL);

	TRAPD(r,\

		{\

		for (TInt i=KTestCleanupStack;i>0;i--)\

			CleanupStack::PushL((TAny*)1);\

		TEST2(r, KErrNone);\

		CleanupStack::Pop(KTestCleanupStack);\

		});

	TEST2(r, KErrNone);

	}

LOCAL_C void DeleteTestFiles()

	{

	RFs fs;

	TInt err = fs.Connect();

	if(err == KErrNone)

		{

		CDir* dir;

		fs.GetDir(KPageFilePathOnly, KEntryAttNormal , ESortNone, dir);

		for(TInt i=0; i< dir->Count();i++)

			{

			CDir& rdir = *dir;

			TFileName tf (KPageFilePathOnly);

			tf.Append(rdir[i].iName);

			err = fs.Delete( tf );

			if (err != KErrNone)

				{

				RDebug::Print(_L("Error %d deleting file \"%S\".\n"), err, &(rdir[i].iName));

				}

			else

				RDebug::Print(_L("File \"%S\" removed.\n"), &(rdir[i].iName));

			}

		delete dir;

		err = fs.RmDir(KPageFilePathOnly);

		if (err != KErrNone)

			{

			RDebug::Print(_L("Error %d deleting folder \"%S\".\n"), err, &KPageFilePathOnly);

			}

		fs.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session.\n"), err);

		}

	}

LOCAL_C void DeleteDataFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	}

GLDEF_C TInt E32Main()

	{

	TheTest.Title();

	setupTestDirectory();

	setupCleanup();

	__UHEAP_MARK;

//

	TRAPD(r,doMainL());

	TEST2(r, KErrNone);

	//deletion of data files must be before call to .End() - DEF047652

	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	

		TParse parse;

		parse.Set(drive.Name(), &KFileLocationSpec, NULL);

		::DeleteDataFile(parse.FullName());

		::DeleteTestFiles();

	TheTest.End();

//

	__UHEAP_MARKEND;

	delete TheTrapCleanup;

	TheFs.Close();

	TheTest.Close();

	return 0;

	}