// 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 the License "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:

// e32test\system\t_regram.cpp

// 

//

#include <e32test.h>

#include <e32svr.h>

//

// This test takes forever to run and destroys the internal Ram drive.

//

LOCAL_D RTest test(_L("T_REGRAM"));

void deleteReg()

//

// Delete everything from the registry

//

	{

	TUid uid;

	TRegistryIter riter;

	riter.Reset();

	while (riter.Next(uid)==KErrNone)

		{

		TRegistryCategory cat(uid);

		cat.DeleteAllItems();

		}

	}

TInt fillReg(const TDesC8 &aDes, TInt aEntries)

//

// Fill the registry with big nasty monsters

// returns the number of entries made.

//

	{

	TBuf8<0x100> buf=_L8("");

	TInt i;

	for (i=0; i<8; i++)

		buf.Append(_L8("Big_ nasty_ monster_ chasing_ me"));

	TUid uid;

	uid=TUid::Uid(0x12345678);

	TRegistryCategory cat(uid);

	i=0;

	TBuf8<0x20> item;

	while (i<aEntries)

		{

		item.Format(_L8("%S %08x"),&aDes,i);

		TInt r=cat.SetItem(item, buf);

		if (r!=KErrNone)

			break;

		i++;

		}

	return i;

	}

TInt shrinkReg(const TDesC8 &aDes, TInt aEntries)

//

// Delete aEntries entries from the registry

// returns number of entries deleted.

//

	{

	TUid uid;

	uid=TUid::Uid(0x12345678);

	TRegistryCategory cat(uid);

	TBuf8<0x20> item;

	TInt i=aEntries-1;

	while (i>=0)

		{

		item.Format(_L8("%S %08x"),&aDes,i);

		TInt r=cat.DeleteItem(item);

		if (r!=KErrNone)

			break;

		i--;

		}

	return aEntries-i-1;

	}

TInt testReg(const TDesC8 &aDes, TInt aEntries)

//

// Test the first aEntries entries are set correctly

//

	{

	TBuf8<0x100> buf=_L8("");

	TInt i;

	for (i=0; i<8; i++)

		buf.Append(_L8("Big_ nasty_ monster_ chasing_ me"));

	TUid uid;

	uid=TUid::Uid(0x12345678);

	TRegistryCategory cat(uid);

	TBuf8<0x20> item;

	TBuf8<0x100> res;

	i=0;

	while (i<aEntries)

		{

		item.Format(_L8("%S %08x"),&aDes,i);

		if ((i&0x1f)==0)

			test.Printf(_L("."));

		res=cat.Item(item, _L8("Gone gone gone"));

		test(buf==res);

		i++;

		}

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

	return i;

	}

void test1()

//

// Test growing and shrinking the registry

//

	{

	test.Start(_L("Cleanout the registry"));

	deleteReg();

	test.Next(_L("Grow the registry a bit"));

	TInt n=fillReg(_L8("Run Away"),40);

	test.Printf(_L("Made %d entries\n"), n);

	test.Next(_L("Test the content of the registry"));

	TInt m=testReg(_L8("Run Away"),n);

	test(n==m);

	test.Next(_L("Shrink it a bit"));

	m=shrinkReg(_L8("Run Away"),n);

	test.Printf(_L("Deleted %d entries\n"), m);

	test(n==m);

	test.Next(_L("Fill the registry with guff"));

	test.Printf(_L("\tTHIS TEST TAKES AGES\n"));

	n=fillReg(_L8("Run Away"),0x7fffffff);

	test.Printf(_L("Made %d entries\n"), n);

	test.Next(_L("Test the content of the registry"));

	m=testReg(_L8("Run Away"),n);

	test.Next(_L("Shrink the registry"));

	m=shrinkReg(_L8("Run Away"),n);

	test.Printf(_L("Deleted %d entries\n"), m);

	test(n==m);

	test.Next(_L("Grow a bigish registry"));

	n=fillReg(_L8("Lunge"),40);

	test.Next(_L("Save the registry"));

    TUint8* bigPtr=new TUint8[0x8000];

	TPtr8 big(bigPtr, 0x8000);

	TInt bigsize;

	TInt r=User::MachineConfiguration(big,bigsize);

	test(r==KErrNone);

	test.Next(_L("Clear it"));

	deleteReg();

	test.Next(_L("Grow a little registry"));

	m=fillReg(_L8("Groat"), 10);

	test.Next(_L("Save it"));

    TUint8* littlePtr=new TUint8[0x8000];

	TPtr8 little(littlePtr, 0x8000);

	TInt littlesize;

	r=User::MachineConfiguration(little,littlesize);

	test(r==KErrNone);

	test.Next(_L("Set to big registry"));

	r=User::SetMachineConfiguration(big);

	test(r==KErrNone);

	test.Next(_L("Test it"));

	TInt i=testReg(_L8("Lunge"), n);

	test(n==i);

	test.Next(_L("Set to little registry"));

	r=User::SetMachineConfiguration(little);

	test(r==KErrNone);

	test.Next(_L("Test it"));

	i=testReg(_L8("Groat"), m);

	test(i==m);

	test.Next(_L("Set to big registry again"));

	deleteReg();

	r=User::SetMachineConfiguration(big);

	test(r==KErrNone);

	test.Next(_L("Test it"));

	i=testReg(_L8("Lunge"), n);

	test(n==i);

	delete bigPtr;

	delete littlePtr;

	test.End();

	}

void fillRamDrive(TBusLocalDrive &aRamDrive)

//

// Fill the ram drive with data

//

	{

	TLocalDriveCapsV2 info;

	TPckg<TLocalDriveCapsV2> infoPckg(info);

	test(aRamDrive.Caps(infoPckg)==KErrNone);

	TInt size=info.iSize.Low();

	TInt i;

	TPckgBuf<TInt> dataBuf;

	TInt &data=dataBuf();

	for (i=0; i<size; i+=4)

		{

		data=i;

		aRamDrive.Write(i, dataBuf);

		}

	}

void testRamDrive(TBusLocalDrive &aRamDrive)

//

// Test the data is still OK

//

	{

	TLocalDriveCapsV2 info;

	TPckg<TLocalDriveCapsV2> infoPckg(info);

	test(aRamDrive.Caps(infoPckg)==KErrNone);

	TInt size=info.iSize.Low();

	TInt i;

	TPckgBuf<TInt> dataBuf;

	TInt &data=dataBuf();

	for (i=0; i<size; i+=4)

		{

		aRamDrive.Read(i, sizeof(TInt), dataBuf);

		if (i&0x3ff==0)

			test.Printf(_L("."));

	//	test.Printf(_L("%08x "), data);

		test(data==i);

		}

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

	}

void testGrow()

	{

	test.Start(_L("Grow the registry a bit"));

	TInt n=fillReg(_L8("Run Away"),20);

	test(n==20);

	test.Next(_L("Test the content of the registry"));

	testReg(_L8("Run Away"),n);

	test(n==20);

	test.End();

	}

void setRamDriveSize(TBusLocalDrive aRamDrive, TInt aSize)

	{

	TLocalDriveCapsV2 info;

	TPckg<TLocalDriveCapsV2> infoPckg(info);

	test(aRamDrive.Caps(infoPckg)==KErrNone);

	TInt oldsize=info.iSize.Low();

	if (aSize>oldsize)

		test(aRamDrive.Enlarge(aSize-oldsize)==KErrNone);

	else

		test(aRamDrive.ReduceSize(0,oldsize-aSize)==KErrNone);

	}

GLDEF_C TInt E32Main(void)

//

// Test the Ram Drive and the Registry

//

	{

	test.Title();

	test.Start(_L("Connect to the Local Drive"));

	TBool changedFlag;

	TBusLocalDrive ramDrive;

	TInt r=ramDrive.Connect(0,changedFlag);

	test(r==KErrNone);

	test.Next(_L("Test testing the ram drive"));

	fillRamDrive(ramDrive);

	testRamDrive(ramDrive);

	test.Next(_L("Simple grow test"));

	fillRamDrive(ramDrive);

	testGrow();

	testRamDrive(ramDrive);	

	test.Next(_L("Shrink"));

	deleteReg();

	testRamDrive(ramDrive);

	{

	deleteReg();

	test.Next(_L("Grow the registry a bit"));

	TInt n=fillReg(_L8("Run Away"),40);

	test.Next(_L("Test the content of the registry"));

	TInt m=testReg(_L8("Run Away"),n);

	test(n==m);

	test.Next(_L("Shrink it a bit"));

	m=shrinkReg(_L8("Run Away"),n);

	test(n==m);

	test.Next(_L("test ram drive"));

	testRamDrive(ramDrive);

	}

/*	test.Next(_L("Run the tests with the current ram drive size"));

	fillRamDrive(ramDrive);

	test1();

	testRamDrive(ramDrive);*/

	test.Next(_L("Run the tests with no Ram Drive"));

	setRamDriveSize(ramDrive, 0);

	test1();

	test.Next(_L("Run the tests with small ram drive"));

	setRamDriveSize(ramDrive, 0x3000);

	fillRamDrive(ramDrive);

	test1();

	testRamDrive(ramDrive);

	test.Next(_L("Clear the registry"));

	deleteReg();

/*	test.Next(_L("Run the tests with a big ram drive"));

	r=KErrGeneral;

	while (r==KErrNone)

		r=ramDrive.Enlarge(0x1000);

	test.Printf(_L("%d"), r);

//	test(r==KErrDiskFull);

	r=ramDrive.ReduceSize(0, 0x2000);

	test(r==KErrNone);

	fillRamDrive(ramDrive);

	test1();

	testRamDrive(ramDrive);*/

	ramDrive.Disconnect();

	test.End();

	return(KErrNone);

	}