// Copyright (c) 2006-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 <f32file.h>

#include <centralrepository.h>

#include "t_cenrep_helper.h"

#include <e32debug.h>

RTest TheTest(_L("Central Repository Settings Tests"));

RFs fs;

const TUid KUidTestRepository = { 0x00000005 };

const TInt KIntOrigValue = 1;

const TUint32 KGlobalDefaultMeta = 0;

const TUint32 KRange2DefaultMeta = 2;

const TUint32 KMetaAtKeyPos24    = 4;

const TUint32 KDefMeta0SingleMeta0Key = 0x1;

const TUint32 KDefMeta0SingleMeta1Key = 0x2;

const TUint32 KDefMeta1SingleMeta0Key = 0x10;

const TUint32 KDefMeta1SingleMeta1Key = 0x11;

const TUint32 KMissingSingleMetaKey   = 0x20;

const TUint32 KPlatsecFailureKey      = 0x21;

const TUint32 KRange2KeyWithMeta4     = 0x24;

_LIT( KSrcTxaPath, "z:\\private\\10202BE9\\00000005.txa" );

_LIT( KSrcCacheIniPath, "z:\\private\\10202BE9\\centrepcache.ini9" );

_LIT( KInstallTxtPath, "C:\\private\\10202BE9\\00000005.txt" );

_LIT( KInstallCrePath, "C:\\private\\10202BE9\\00000005.cre" );

_LIT( KPersistsCrePath, "C:\\private\\10202BE9\\persists\\00000005.cre" );

_LIT( KCacheIniPath, "C:\\private\\10202BE9\\centrep.ini" );

TPtrC metaTestFiles[] =

	{

	TPtrC(KInstallTxtPath),

	TPtrC(KInstallCrePath),

	TPtrC(KPersistsCrePath),

	// This one last because we do not always delete it.

	TPtrC(KCacheIniPath)

    };

const TInt KNumMetaTestFiles = sizeof(metaTestFiles) / sizeof(TPtrC);

_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");

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

// Test macroses and functions

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

LOCAL_C TInt DeleteFile(const TDesC& aFileName, CFileMan& aFileMan)

	{

	TInt r = aFileMan.Delete( aFileName );

	if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )

		{

		return r;

		}

	return KErrNone;

	}

LOCAL_C TInt DeleteFilesL(TPtrC aFileList[], TInt aNumFiles)

	{

	CFileMan* fm = CFileMan::NewL(fs);

	CleanupStack::PushL( fm );

	TInt ret = KErrNone;

	for (TInt i = 0; i < aNumFiles; i++)

		{

		TInt r = DeleteFile( aFileList[i], *fm );

		if (r != KErrNone)

			{

			ret = r;

			}

		}

	CleanupStack::PopAndDestroy( fm );

	return ret;

	}

LOCAL_C void TestCleanupL()

    {

    DeleteFilesL(metaTestFiles, KNumMetaTestFiles);

    KillProcess(KCentralRepositoryServerName);

    }

LOCAL_C void CheckL( TInt aValue, TInt aLine )

	{

	if ( !aValue )

		{

		TestCleanupL();

		TheTest( EFalse, aLine );

		}

	}

LOCAL_C void CheckL( TInt aValue, TInt aExpected, TInt aLine )

	{

	if ( aValue != aExpected )

		{

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

		TestCleanupL();

		TheTest( EFalse, aLine );

		}

	}

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

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

LOCAL_C void CopyFileL(const TDesC& aSrc,

					   const TDesC& aDest,

					   TBool aClearROAttrib)

	{

	CFileMan* fm = CFileMan::NewL( fs );

	CleanupStack::PushL( fm );

	TInt ret = fm->Copy(aSrc, aDest);

	if (aClearROAttrib && (ret == KErrNone))

		{

		ret = fm->Attribs( aDest, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse );

		}

	User::LeaveIfError(ret);

	CleanupStack::PopAndDestroy( fm );

	}

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

// class to encapsulate metadata test

class TMetadataTest

	{

public:

	inline TMetadataTest() {}

	~TMetadataTest();

	void InitialiseL();

	void InstallCreFileL();

	void RunTestsL();

	void RunSetTestL();

	void RunDeleteResetTestL();

	void RunDeleteCreateTestL();

	void RunDeleteCreateTest2L();

	void RunMoveTestL();

	void RunBasicGetMetaTestsL();

	TBool VerifyMetaDataUnchangedL();

	};

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

TMetadataTest::~TMetadataTest()

	{

	TRAPD(err, ::TestCleanupL());

	if (err != KErrNone)

	    {

	    RDebug::Printf("err = %d in ~TMetadataTest.", err);

	    }

	}

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

void TMetadataTest::InitialiseL()

	{

	::TestCleanupL();

	User::After(1000000); // pause after KillProcess

	::CopyFileL(KSrcTxaPath, KInstallTxtPath, ETrue);

	::CopyFileL(KSrcCacheIniPath, KCacheIniPath, ETrue);

	}

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

void TMetadataTest::InstallCreFileL()

	{

	// Ensure start with original 00000005.txa file.

	// Be careful. Do not delete centrep.ini

	::DeleteFilesL(metaTestFiles, KNumMetaTestFiles - 1);

	::CopyFileL(KSrcTxaPath, KInstallTxtPath, ETrue);

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	// Create/Delete to persist the .txt to .cre

	TInt r = rep->Create(0xA5A5, 1);

	TEST2(r, KErrNone);

	rep->Delete(0xA5A5);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	::CopyFileL(KPersistsCrePath, KInstallCrePath, EFalse);

	TPtrC onefile[1] = { TPtrC(KPersistsCrePath) };

	::DeleteFilesL(onefile, 1);

	}

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

void TMetadataTest::RunTestsL()

	{

	RunSetTestL();

	RunDeleteResetTestL();

	RunDeleteCreateTestL();

	RunDeleteCreateTest2L();

	RunMoveTestL();

	}

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

TBool TMetadataTest::VerifyMetaDataUnchangedL()

	{

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt ret = ETrue;

	TUint32 meta;

	TInt r = rep->GetMeta(KMissingSingleMetaKey, meta);

	TEST2(r, KErrNone);

	if ( meta !=  KRange2DefaultMeta)

		{

		TheTest.Printf(_L("Key: 0x%x, meta is %d"), KMissingSingleMetaKey, meta);

		ret = EFalse;

		}

	r = rep->GetMeta(KDefMeta0SingleMeta0Key, meta);

	TEST2(r, KErrNone);

	if ( meta !=  0)

		{

		TheTest.Printf(_L("Key: 0x%x, meta is %d"), KDefMeta0SingleMeta0Key, meta);

		ret = EFalse;

		}

	r = rep->GetMeta(KDefMeta0SingleMeta1Key, meta);

	TEST2(r, KErrNone);

	if ( meta !=  1)

		{

		TheTest.Printf(_L("Key: 0x%x, meta is %d"), KDefMeta0SingleMeta1Key, meta);

		ret = EFalse;

		}

	r = rep->GetMeta(KDefMeta1SingleMeta0Key, meta);

	TEST2(r, KErrNone);

	if ( meta !=  0)

		{

		TheTest.Printf(_L("Key: 0x%x, meta is %d"), KDefMeta1SingleMeta0Key, meta);

		ret = EFalse;

		}

	r = rep->GetMeta(KDefMeta1SingleMeta1Key, meta);

	TEST2(r, KErrNone);

	if ( meta !=  1)

		{

		TheTest.Printf(_L("Key: 0x%x, meta is %d"), KDefMeta1SingleMeta1Key, meta);

		ret = EFalse;

		}

	CleanupStack::PopAndDestroy(rep);

	return ret;

	}

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

void TMetadataTest::RunBasicGetMetaTestsL()

	{

	TheTest.Next(_L("Basic functional tests on the GetMeta API\r\n"));

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TUint32 meta;

	// GetMeta on non-existing key.

	const TUint32 KNonExistingKey = 0xFACE;

	TInt r = rep->GetMeta(KNonExistingKey, meta);

	TEST2(r, KErrNotFound);

	// Missing capability to read meta of following key.

	r = rep->GetMeta(KPlatsecFailureKey, meta);

	TEST2(r, KErrPermissionDenied);

	// GetMeta in transaction

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Set(KMissingSingleMetaKey, KIntOrigValue+1);

	TEST2(r, KErrNone);

	r = rep->GetMeta(KMissingSingleMetaKey, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KRange2DefaultMeta);

	CleanupStack::PopAndDestroy(); // cancel transaction

	CleanupStack::PopAndDestroy(rep);

	}

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

void TMetadataTest::RunMoveTestL()

	{

	TheTest.Next(_L("Metadata Move settings test\r\n"));

	const TUint32 KDefRangeKeyForCreate = 0x3A;

	const TUint32 KRange2KeyForCreate   = 0x2A;

	const TUint32 KDefRangeKeyForMove   = 0x3B;

	const TUint32 KRange2KeyForMove     = 0x2B;

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Create(KDefRangeKeyForCreate, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KRange2KeyForCreate, KIntOrigValue);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	TUint32 errKey;

	r = rep->CommitTransaction(errKey);

	TEST2(r, KErrNone);

	// Check that the keys are created with correct meta

	TUint32 meta;

	// This key is not covered by any rangemeta. The global

	// default meta should be used.

	r = rep->GetMeta(KDefRangeKeyForCreate, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KGlobalDefaultMeta);

	// This key is covered by a rangemeta.

	r = rep->GetMeta(KRange2KeyForCreate, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KRange2DefaultMeta);

	// move the created keys to different ranges

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	const TUint32 KMoveMask = 0x3F;

	r = rep->Move(KDefRangeKeyForCreate, KRange2KeyForMove, KMoveMask,

			errKey);

	TEST2(r, KErrNone);

	r = rep->Move(KRange2KeyForCreate, KDefRangeKeyForMove, KMoveMask,

			errKey);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	r = rep->CommitTransaction(errKey);

	TEST2(r, KErrNone);

	// This key is moved from range where rangemeta is 2 to range

	// where meta is defined by the global default meta.

	r = rep->GetMeta(KDefRangeKeyForMove, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KGlobalDefaultMeta);

	// This key is moved from range where meta is defined by the

	// global default meta to a range where rangemeta is 2.

	r = rep->GetMeta(KRange2KeyForMove, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KRange2DefaultMeta);

	// Test Move a key to a position which has just been deleted but

	// not yet commited.

	// Create two keys to be moved. To save typing, no transaction.

	r = rep->Create(KDefRangeKeyForCreate, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KRange2KeyForCreate, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	// delete the targeted keys but do not commit

	r = rep->Delete(KDefRangeKeyForMove);

	TEST2(r, KErrNone);

	r = rep->Delete(KRange2KeyForMove);

	TEST2(r, KErrNone);

	// move the created keys to target positions

	r = rep->Move(KDefRangeKeyForCreate, KRange2KeyForMove, KMoveMask,

			errKey);

	TEST2(r, KErrNone);

	r = rep->Move(KRange2KeyForCreate, KDefRangeKeyForMove, KMoveMask,

			errKey);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	r = rep->CommitTransaction(errKey);

	TEST2(r, KErrNone);

	// This key is moved from range where rangemeta is 2 to range

	// where meta is defined by the global default meta.

	r = rep->GetMeta(KDefRangeKeyForMove, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KGlobalDefaultMeta);

	// This key is moved from range where meta is defined by the

	// global default meta to a range where rangemeta is 2.

	r = rep->GetMeta(KRange2KeyForMove, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KRange2DefaultMeta);

	// Test Move a key to a position which has a setting defined

	// in the INI file. The metadata of this pre-existing key

	// is permanently attached to that key position and takes

	// precedent over defaultmeta.

	// Create the setting to be moved.

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Create(KRange2KeyForCreate, KIntOrigValue);

	TEST2(r, KErrNone);

	// delete the key occuping the destination of the move.

	r = rep->Delete(KRange2KeyWithMeta4);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	r = rep->CommitTransaction(errKey);

	TEST2(r, KErrNone);

	// Verify target has been deleted.

	TInt a;

	r = rep->Get(KRange2KeyWithMeta4, a);

	TEST2(r, KErrNotFound);

	// move the created keys to target positions

	r = rep->Move(KRange2KeyForCreate, KRange2KeyWithMeta4, KMoveMask,

			errKey);

	TEST2(r, KErrNone);

	// This key is moved within range where rangemeta is 2.

	// Target position of the Move has a setting defined

	// in the INI file. The metadata of this pre-existing key

	// is permanently attached to that key position and takes

	// precedent over the rangemeta.

	r = rep->GetMeta(KRange2KeyWithMeta4, meta);

	TEST2(r, KErrNone);

	TEST2(meta, KMetaAtKeyPos24);

	// cleanup

	r = rep->Reset();

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	}

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

void TMetadataTest::RunSetTestL()

	{

	TheTest.Next(_L("Metadata Set settings test\r\n"));

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt r;

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	const TInt KNewValue = KIntOrigValue + 1;

	r = rep->Set(KMissingSingleMetaKey, KNewValue);

	TEST2(r, KErrNone);

	r = rep->Set(KDefMeta0SingleMeta0Key, KNewValue);

	TEST2(r, KErrNone);

	r = rep->Set(KDefMeta0SingleMeta1Key, KNewValue);

	TEST2(r, KErrNone);

	r = rep->Set(KDefMeta1SingleMeta0Key, KNewValue);

	TEST2(r, KErrNone);

	r = rep->Set(KDefMeta1SingleMeta1Key, KNewValue);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	TUint32 keyInfo;

	r = rep->CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	// check that the Set has changed the settings.

	TInt a;

	r = rep->Get(KMissingSingleMetaKey, a);

	TEST2(r, KErrNone);

	TEST2(a, KNewValue);

	r = rep->Get(KDefMeta0SingleMeta0Key, a);

	TEST2(r, KErrNone);

	TEST2(a, KNewValue);

	r = rep->Get(KDefMeta0SingleMeta1Key, a);

	TEST2(r, KErrNone);

	TEST2(a, KNewValue);

	r = rep->Get(KDefMeta1SingleMeta0Key, a);

	TEST2(r, KErrNone);

	TEST2(a, KNewValue);

	r = rep->Get(KDefMeta1SingleMeta1Key, a);

	TEST2(r, KErrNone);

	TEST2(a, KNewValue);

	// Check the Set's have not change the metadata

	TEST(VerifyMetaDataUnchangedL());

	// Take this opportunity to Reset the keys to exercise the

	// Set-then-Reset path.

	// Transaction not available for Reset.

	r = rep->Reset(KMissingSingleMetaKey);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta0SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta0SingleMeta1Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta1SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta1SingleMeta1Key);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	TEST(VerifyMetaDataUnchangedL());

	}

void TMetadataTest::RunDeleteCreateTestL()

	{

	TheTest.Next(_L("Metadata Delete-Create settings test\r\n"));

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt r;

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Delete(KMissingSingleMetaKey);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta1Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta1Key);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	TUint32 keyInfo;

	r = rep->CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	// Now open the repository again and create the deleted keys.

	rep = CRepository::NewLC(KUidTestRepository);

	// Before Create, check if the Delete's actually happened.

	TInt a;

	r = rep->Get(KMissingSingleMetaKey, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta0SingleMeta0Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta0SingleMeta1Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta1SingleMeta0Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta1SingleMeta1Key, a);

	TEST2(r, KErrNotFound);

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Create(KMissingSingleMetaKey, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta0SingleMeta0Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta0SingleMeta1Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta1SingleMeta0Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta1SingleMeta1Key, KIntOrigValue);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	r = rep->CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	TEST(VerifyMetaDataUnchangedL());

	}

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

void TMetadataTest::RunDeleteCreateTest2L()

	{

	TheTest.Next(_L("Metadata Delete-Create settings (uncommitted) test\r\n"));

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt r;

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Delete(KMissingSingleMetaKey);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta1Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta1Key);

	TEST2(r, KErrNone);

	// Next Create while Delete still in transaction.

	r = rep->Create(KMissingSingleMetaKey, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta0SingleMeta0Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta0SingleMeta1Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta1SingleMeta0Key, KIntOrigValue);

	TEST2(r, KErrNone);

	r = rep->Create(KDefMeta1SingleMeta1Key, KIntOrigValue);

	TEST2(r, KErrNone);

	// Make a dummy change in case the Delete/Create cancel each

	// other, ending up with nothing to commit.

	r = rep->Create(0xA5A5, KIntOrigValue);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	TUint32 keyInfo;

	r = rep->CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	r = rep->Delete(0xA5A5);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	TEST(VerifyMetaDataUnchangedL());

	}

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

void TMetadataTest::RunDeleteResetTestL()

	{

	TheTest.Next(_L("Metadata Delete-Reset settings test\r\n"));

	CRepository* rep = CRepository::NewLC(KUidTestRepository);

	TInt r;

	r = rep->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	TEST2(r, KErrNone);

	rep->CleanupCancelTransactionPushL();

	r = rep->Delete(KMissingSingleMetaKey);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta0SingleMeta1Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Delete(KDefMeta1SingleMeta1Key);

	TEST2(r, KErrNone);

	CleanupStack::Pop(); // transaction

	TUint32 keyInfo;

	r = rep->CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	// check if the delete's actually happened

	rep = CRepository::NewLC(KUidTestRepository);

	TInt a;

	r = rep->Get(KMissingSingleMetaKey, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta0SingleMeta0Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta0SingleMeta1Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta1SingleMeta0Key, a);

	TEST2(r, KErrNotFound);

	r = rep->Get(KDefMeta1SingleMeta1Key, a);

	TEST2(r, KErrNotFound);

	// Next Reset on each deleted key.

	// Transaction not available for Reset.

	r = rep->Reset(KMissingSingleMetaKey);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta0SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta0SingleMeta1Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta1SingleMeta0Key);

	TEST2(r, KErrNone);

	r = rep->Reset(KDefMeta1SingleMeta1Key);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(rep);

	TEST(VerifyMetaDataUnchangedL());

	}

/**

@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1717

@SYMTestCaseDesc Test Set, Delete, Create and Reset on a key with meta of 0 while defaultmeta is non-zero.

@SYMTestPriority High

@SYMTestActions 1. Do a Set. Verify meta does not change. 2. Delete and Create the key. Verify the non-zero defaultmeta is used. 3. Delete and Reset the key. Verify meta is zero.

@SYMTestExpectedResults The test must not fail.

@SYMDEF INC086298

*/

LOCAL_C void INC086298L()

	{

	TheTest.Printf(_L("INC086298 - Setting with no backup meta value is backed up\r\n"));

	TMetadataTest metaDataTester;

	metaDataTester.InitialiseL();

	metaDataTester.RunBasicGetMetaTestsL();

	TheTest.Printf( _L("Metadata tests on .txt file\r\n") );

	metaDataTester.RunTestsL();

	TheTest.Printf( _L("Metadata tests on .cre file\r\n") );

	metaDataTester.InstallCreFileL();

	metaDataTester.RunTestsL();

	}

LOCAL_C void MainL()

	{

	TheTest.Start( _L( " @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1717 CentralRepository metadata test " ) );

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

    INC086298L();

	CleanupStack::PopAndDestroy(&fs);

	TheTest.End();

	TheTest.Close();

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if ( !cleanup )

		return KErrNoMemory;

	TRAPD( err, MainL()  );

	delete cleanup;

	__UHEAP_MARKEND;

	return err;

	}