// Copyright (c) 2000-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:

// BioTest.h

//

#ifndef __BIOTEST_H__

#define __BIOTEST_H__

#include <e32test.h>

#include "msvtestutilsbase.h"

#include "BIODB.H"

#include <bautils.h>

#include <bifchangeobserver.h>

// Constants

_LIT(KBifFolderV2, "\\resource\\messaging\\Bif\\");     

// The following must be defined by the test exe

GLREF_D RTest test;

LOCAL_C void doTestsL();

// Globals

TInt TestNum = 0;

class CBioTestUtils;

CBioTestUtils* theUtils = NULL;

//**********************************

// CBioTestUtils

//**********************************

class CBioTestUtils : public CTestUtils

	{

public:

	static CBioTestUtils* NewL(RTest& aTest);

	CBioTestUtils(RTest& aTest);

	void Panic(TInt aPanic);

	//

public:

	void Start(const TDesC& aDes);

	void Complete();

	void End(TInt aRet);

	//

	void ClearBifFoldersL();

	void ClearBifFolderL(TInt aDrive);

	TBool BifInstalledL(CBIODatabase& aDatabase, TUid aId);

	TBool FindFileL(TParse& aParse, const TDesC& aDir, const TDesC& aName);

	//

private:

	void ConstructL();

	TBool DoFindFileL(TParse& aParse, TInt aDrive, const TDesC& aDir, const TDesC& aName);

	//

private:

	TInt iTestNum;

	};

CBioTestUtils* CBioTestUtils::NewL(RTest& aTest)

	{

	CBioTestUtils* self = new(ELeave)CBioTestUtils(aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

CBioTestUtils::CBioTestUtils(RTest& aTest)

: CTestUtils(aTest)

	{

	}

void CBioTestUtils::ConstructL()

	{

	CTestUtils::ConstructL();

	// Is there a D-drive?

	TVolumeInfo info;

	Test()(FileSession().Volume(info, EDriveD) == KErrNone);

	}

void CBioTestUtils::Panic(TInt)

	{

	Test()(EFalse);

	}

void CBioTestUtils::Start(const TDesC& aDes)

	{

	if (iTestNum == 0)

		Test().Start(aDes);

	else

		Test().Next(aDes);

	TestStart(++iTestNum, aDes);

	}

void CBioTestUtils::Complete()

	{

	TestFinish(iTestNum, KErrNone);

	}

void CBioTestUtils::End(TInt aRet)

	{

	if (!aRet)

		TestHarnessCompleted();

	else

		TestHarnessFailed(aRet);

	Test()(aRet == KErrNone);

	if (iTestNum > 0)

		Test().End();

	Test().Close();

	}

void CBioTestUtils::ClearBifFoldersL()

	{

	ClearBifFolderL(EDriveC);

	ClearBifFolderL(EDriveD);

	}

void CBioTestUtils::ClearBifFolderL(TInt aDrive)

	{

	CFileMan* fileMan = CFileMan::NewL(FileSession());

	CleanupStack::PushL(fileMan);

	// Get drive name

	TDriveUnit unit(aDrive);

	TPtrC drive(unit.Name());

	// Generate path

	TParse parse;

	TInt error;

	User::LeaveIfError(parse.Set(KBifFolderV2(), &drive, NULL));

	// Delete the folder

	error = fileMan->RmDir(parse.DriveAndPath());

	if (error != KErrNotFound && error != KErrPathNotFound)

		User::LeaveIfError(error);

	CleanupStack::PopAndDestroy(); // fileMan

	}

TBool CBioTestUtils::BifInstalledL(CBIODatabase& aDatabase, TUid aId)

	{

	TInt index;

	TRAPD(error, aDatabase.GetBioIndexWithMsgIDL(aId, index));

	return !error;

	}

TBool CBioTestUtils::FindFileL(TParse& aParse, const TDesC& aDir, const TDesC& aName)

	{

	// Check rom

	if (DoFindFileL(aParse, EDriveZ, aDir, aName))

		return ETrue;

	// Check alternate drive

	if (DoFindFileL(aParse, EDriveD, aDir, aName))

		return ETrue;

	// Check internal disk

	if (DoFindFileL(aParse, EDriveC, aDir, aName))

		return ETrue;

	// File not found

	return EFalse;

	}

TBool CBioTestUtils::DoFindFileL(TParse& aParse, TInt aDrive, const TDesC& aDir, const TDesC& aName)

	{

	// Generate drive name

	TDriveUnit unit(aDrive);

	TPtrC drive(unit.Name());

	// Generate path and see if file exists

	User::LeaveIfError(aParse.Set(drive, &aDir, &aName));

	return BaflUtils::FileExists(FileSession(), aParse.FullName());

	}

//**********************************

// Global

//**********************************

LOCAL_C void SetupL()

	{

	CActiveScheduler::Install(new(ELeave)CActiveScheduler);

	// Create test class

	theUtils = CBioTestUtils::NewL(test);

	}

LOCAL_C void Close(TInt aRet)

	{

	if (theUtils)

		{

		theUtils->End(aRet);

		delete theUtils;

		}

	delete CActiveScheduler::Current();

	}

LOCAL_C void doMainL()

	{

	SetupL();	

	doTestsL();

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	__ASSERT_ALWAYS(cleanup, User::Invariant());

	TRAPD(ret,doMainL());		

	Close(ret);

	delete cleanup;	

	__UHEAP_MARKEND;

	return KErrNone;

	}

#endif