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

// Test Help Model module to check the PlatSec search order.

// This test uses and additional drive typically F: It should be mapped in the epoc.ini file.

// Mapping is achieved for example thus: _EPOC_DRIVE_F c:\temp

// 

//

// System includes

#include <e32std.h>

#include <e32def.h>

#include <e32test.h>

#include <e32math.h>

#include <f32file.h>

#include <coehelp.h>

// User includes

#include <bautils.h>

#include "HLPMODEL.H"

#include <coreappstest/testserver.h>

#include "SearchOrderTest.h"

// Globals

static TInt64				TheSeed;

static RFs					TheFs;

static RTest				TheTest(_L("TSearch - Test Help Model Searching"));

static CTrapCleanup*		TheTrapCleanup;

static CActiveScheduler*	TheScheduler;

// Constants

const TInt KTestCleanupStack=0x20;

// Panic enum

enum THlpPanic

	{

	EHlpPanicNoBossFile,

	EHlpPanicLast

	};

//

// ---------> Global functions

//

static void Panic(THlpPanic aPanic)

	{

	_LIT(KHlpPanicCategory, "TSearch");

	User::Panic(KHlpPanicCategory, aPanic);

	}

static TInt Rand(const TInt aLow, const TInt aHigh)

//

//	Generate a random number based upon a seed and a range

//

	{

	TReal initialRand = (Math::FRand(TheSeed) * (aHigh - aLow));

	TInt32 rand;

	// Round to 0 decimal places, ie. the nearest whole numer

	Math::Round(initialRand, initialRand, 0);

	Math::Int(rand, initialRand);

	//aSeed = seed;

	return (aLow + rand);

	}

//

// ---------> CHlpSearchTest (header)

//

class CHlpSearchTest: public CBase, public MHlpModelObserver

	{

public: // CONSTRUCT / DESTRUCT

	static void TestHelpModelLD(TBool aOomTesting = EFalse);

	~CHlpSearchTest();

private:

	CHlpSearchTest();	

public: // NEW

	void TestL(TBool aOomTesting = EFalse);

public: // FROM MHlpModelObserver

	void HandleModelEventL(TInt aEvent);

private: // TESTING METHODS

	void BasicCreateAndCloseL();

	void IndexListL(TBool aOomTesting = EFalse);

	void CategoryListL(TBool aOomTesting = EFalse);

	void TopicListForCategoryL();

	void ContextSearchL(TBool aOomTesting = EFalse);

	void IndexSearchL();

	void TextSearchL(TBool aOomTesting = EFalse);

	void CategoryUidSearchL(TBool aOomTesting = EFalse);

private:

	void Reset();

	TBool FileExists(const TDesC& aFileName);

	CDesCArray* CategoryListLC();

private: // MEMBER DATA

	TInt iResponseCount;

	TInt iLastHelpModelResponse;

	TInt iSearchProgressCount;

	TInt iSearchCancelValue;

	TBool iIsAsynchronous;

	TBool iSchedulerStarted;

	CHlpModel* iModel;

	};

//

// ---------> CHlpSearchTest (source)

//

CHlpSearchTest::CHlpSearchTest()

	{

	}

CHlpSearchTest::~CHlpSearchTest()

	{

	delete iModel;

	}

void CHlpSearchTest::TestHelpModelLD(TBool aOomTesting)

	{

	CHlpSearchTest* self = new(ELeave) CHlpSearchTest();

	CleanupStack::PushL(self);

	self->TestL(aOomTesting);

	CleanupStack::PopAndDestroy();

	}

//

//

//

void CHlpSearchTest::TestL(TBool aOomTesting)

	{

	iModel = CHlpModel::NewL(TheFs, this);

	iModel->OpenL();

	BasicCreateAndCloseL();

	IndexListL(aOomTesting);

	CategoryListL(aOomTesting);

	TopicListForCategoryL();

	ContextSearchL(aOomTesting);

	TextSearchL(aOomTesting);

	CategoryUidSearchL(aOomTesting);

	}

//

//

//

void CHlpSearchTest::BasicCreateAndCloseL()

	{

	TheTest.Console()->ClearScreen();

	TheTest.Printf(_L("Testing basic open, close and destruction\n"));

	__UHEAP_MARK;

	CHlpModel::NewLC(TheFs, NULL);

	CleanupStack::PopAndDestroy(); // model

	__UHEAP_MARKEND;

	__UHEAP_MARK;

	CHlpModel* model = CHlpModel::NewLC(TheFs, NULL);

	model->OpenL();

	CleanupStack::PopAndDestroy(); // model

	__UHEAP_MARKEND;

	}

void CHlpSearchTest::IndexListL(TBool aOomTesting)

	{

	TheTest.Console()->ClearScreen();

	TheTest.Printf(_L("Testing index listing\n"));

	Reset();

	iModel->SearchL(EIndexList);

	if(!aOomTesting)

		{

		TheTest(iLastHelpModelResponse == EIndexListAvailable);

		}

	TheTest(iResponseCount == 1);

	// Load the complete list of entries for all help files

	CHlpList* list = CHlpList::NewLC();

	iModel->LoadListL(list);

	TheTest.Printf(_L("\tComplete index listing for all help files..."));

	TInt i=0;

	for(i=0; i<list->MdcaCount(); i++)

		{

		CHlpItem* item = list->Item(i);

		TPtrC pItem(item->Title());

		TheTest.Printf(_L("\nIndex list [0x%08x][indexId=%d]: %S "), item->HelpFileUid(), item->Id(), &pItem);

		}

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

	// Next select an item from the complete list (at random)

	if(list->MdcaCount()!=0)

		{

		CHlpItem* item = list->Item(Rand(0, list->MdcaCount()-1));

		// Save these for later...

		TUint helpFileUid = item->HelpFileUid().iUid;

		TUint indexId = item->Id();

		// Next perform a topic search based on this item

		iModel->IndexSearchL(*item);

		TheTest(iLastHelpModelResponse == EIndexSearchListAvailable);

		CleanupStack::PopAndDestroy(); // list

		// Next load the list of topics which match the index id

		list = CHlpList::NewLC();

		iModel->LoadListL(list);

		TheTest.Printf(_L("\tTopic listing in help file 0x%08x, whose index id = %d"), helpFileUid, indexId);

		for(i=0; i<list->MdcaCount(); i++)

			{

			CHlpItem* item = list->Item(i);

			TPtrC pItem(item->Title());

			TheTest.Printf(_L("\nTopic [Uid: 0x%08x]: %S "), item->HelpFileUid(), &pItem);

			}

	}

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

	CleanupStack::PopAndDestroy(); // list

	}

void CHlpSearchTest::CategoryListL(TBool aOomTesting)

	{

	TheTest.Console()->ClearScreen();

	TheTest.Printf(_L("Testing category listing\n"));

	Reset();

	iModel->SearchL(ECategoryList);

	if(!aOomTesting)

		{

		TheTest(iLastHelpModelResponse == ECategoryListAvailable);

		}

	// Display the index listing...

	CHlpList* list = CHlpList::NewLC();

	iModel->LoadListL(list);

	for(TInt i=0; i<list->MdcaCount(); i++)

		{

		TPtrC pItem(list->MdcaPoint(i));

		TheTest.Printf(_L("\nCategory item %d: %S"), i, &pItem);

		}

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

	CleanupStack::PopAndDestroy(); // list

	}

void CHlpSearchTest::TopicListForCategoryL()

	{

	TheTest.Printf(_L("Testing topic listing\n"));

	Reset();

	// First get a category listing, then get the list of topics

	// for each specified category.

	CDesCArrayFlat* array = STATIC_CAST(CDesCArrayFlat*, CategoryListLC());

	const TInt count = array->Count();

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

		{

		TPtrC pItem = array->MdcaPoint(i);

		TheTest.Printf(_L("\nTopics for Category %S\n"), &pItem);

		// Calling this will result in the topics for this category

		// being printed out in the mixin handler

		iModel->SearchL(ETopicListForCategory, pItem);

		}

	CleanupStack::PopAndDestroy(); // array

	}

void CHlpSearchTest::ContextSearchL(TBool aOomTesting)

	{

	TheTest.Printf(_L("Testing context searching\n"));

	Reset();

	// Context search for an item we know exists

	_LIT(KContext1,	"This_is_a_multi_word_context2");

	TUid uid = { 16777216 };

	TCoeHelpContext coeSearchContext(uid, KContext1);

	iModel->ContextSearchL(coeSearchContext);

	if(!aOomTesting)

		{

		TheTest(iLastHelpModelResponse == ETopicAvailable);

		}

	// Context search for an item we know doesn't exist

	_LIT(KContext2,	"ABCDEFG");

	TUid uid2 = { 00000000 };

	TCoeHelpContext coeSearchContext2(uid2, KContext2);

	iModel->ContextSearchL(coeSearchContext2);

	TheTest(iLastHelpModelResponse == ETopicNotFound);

	}

void CHlpSearchTest::TextSearchL(TBool aOomTesting)

	{

	if(aOomTesting)

		return;

	_LIT(KFullTextShouldNotBeFound,	"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

	TheTest.Printf(_L("Testing text searching (when item shouldn't be found)\n"));

	Reset();

	iSchedulerStarted = EFalse;

	iIsAsynchronous = ETrue;

	iModel->SearchL(EFullTextSearch, KFullTextShouldNotBeFound);

	iSchedulerStarted = ETrue;

	CActiveScheduler::Start();

	TheTest(iLastHelpModelResponse == ESearchListNoneFound);

	_LIT(KFullTextShouldBeFound,	"boss");

	TheTest.Printf(_L("Testing text searching (when item should be found)\n"));

	Reset();

	iSchedulerStarted = EFalse;

	iIsAsynchronous = ETrue;

	iModel->SearchL(EFullTextSearch, KFullTextShouldBeFound);

	iSchedulerStarted = ETrue;

	CActiveScheduler::Start();

	TheTest(iLastHelpModelResponse == ESearchListAvailable);

	TheTest.Printf(_L("\tTesting asynch cancel function\n"));

	TInt searchCancelValue = Max(1, iSearchProgressCount / 2); // stop half way through

	Reset();

	iSearchCancelValue = searchCancelValue;

	iSchedulerStarted = EFalse;

	iIsAsynchronous = ETrue;

	iModel->SearchL(EFullTextSearch, KFullTextShouldBeFound);

	iSchedulerStarted = ETrue;

	CActiveScheduler::Start();

	}

void CHlpSearchTest::CategoryUidSearchL(TBool aOomTesting)

	{

	TheTest.Console()->ClearScreen();

	TheTest.Printf(_L("Testing category uid searching - *requires boss help file*\n"));

    if	((!FileExists(_L("C:\\Resource\\Help\\Boss-1.hlp"))) && (!FileExists(_L("Z:\\Resource\\Help\\Boss-1.hlp"))))

		Panic(EHlpPanicNoBossFile);

	Reset();

	iModel->CategoryUIDSearchL(TUid::Uid(16777216)); // hard coded category uid from Boss1.hlp

	if(!aOomTesting)

		{

		TheTest(iLastHelpModelResponse == ETopicListAvailable);

		}

	TheTest(iResponseCount == 1);

	// Display the index listing...

	CHlpList* list = CHlpList::NewLC();

	iModel->LoadListL(list);

	for(TInt i=0; i<list->MdcaCount(); i++)

		{

		TPtrC pItem(list->MdcaPoint(i));

		TheTest.Printf(_L("\nCategory item %d: %S"), i, &pItem);

		}

	CleanupStack::PopAndDestroy(); // list

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

	// Test for a category that we know doesn't exist

	Reset();

	iModel->CategoryUIDSearchL(KNullUid);

	TheTest(iLastHelpModelResponse == ETopicListNoneFound);

	TheTest(iResponseCount == 1);

	}

//

//

//

void CHlpSearchTest::Reset()

	{

	iResponseCount = 0;

	iLastHelpModelResponse = KErrGeneral;

	iIsAsynchronous = EFalse;

	iSearchProgressCount = 0;

	iSearchCancelValue = KErrNone-1; // Anything less that KErrNone

	}

TBool CHlpSearchTest::FileExists(const TDesC& aFileName)

	{

	TEntry entry;

	TInt error = TheFs.Entry(aFileName, entry);

	if	(error == KErrInUse)

		return ETrue;

	if	(error < KErrNone)

		return EFalse;

	return (!entry.IsDir());

	}

CDesCArray* CHlpSearchTest::CategoryListLC()

	{

	// Get and print the category listing

	CDesCArrayFlat* array = new(ELeave) CDesCArrayFlat(5);

	CleanupStack::PushL(array);

	iModel->CategoryListL(array);

	return array;

	}

//

//

//

void CHlpSearchTest::HandleModelEventL(TInt aEvent)

	{

	iResponseCount++;

	iLastHelpModelResponse = aEvent;

	// If this test included an asynch search, and there was a cancel value set

	// then cancel the asynch searcher

	if	(++iSearchProgressCount == iSearchCancelValue && iIsAsynchronous)

		{

		// Reset this otherwise we'll get stuck in a loop

		iSearchCancelValue = KErrNone-1;

		// Only works for full test searching as this is the only search type 

		// which uses an active object, and even then it doesn't use them properly.

		TheTest(iModel->CancelSearch() == KErrNone);

		}

	switch (aEvent)

		{

	case ESearchListAvailable:		// text searches

		TheTest.Printf(_L("\n\tESearchListAvailable\n"));

		break;

	case ECategoryListAvailable:

		{

		TheTest.Printf(_L("\n\tECategoryListAvailable\n"));

		// Get and print the category listing

		CDesCArrayFlat* array = STATIC_CAST(CDesCArrayFlat*, CategoryListLC());

		const TInt count = array->Count();

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

			{

			TPtrC pItem = array->MdcaPoint(i);

			TheTest.Printf(_L("Category %d: %S\n"), i, &pItem);

			}

		CleanupStack::PopAndDestroy(); // array

		break;

		}

	case ECategoryListNoneFound:

		TheTest.Printf(_L("\n\tECategoryListNoneFound\n"));

		break;

	case ETopicListAvailable:		// category expansion

		{

		TheTest.Printf(_L("\n\tETopicListAvailable\n"));

		CHlpList* list = CHlpList::NewLC();

		iModel->LoadListL(list);

		TInt count = list->MdcaCount();

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

			{

			CHlpItem* item = list->Item(i);

			TPtrC pTitle(*item->iTitle);

			TheTest.Printf(_L("Topic %d: %S (id = %d)\n"), i, &pTitle, item->iId);

			}

		CleanupStack::PopAndDestroy(); // list

		break;

		}

	case ETopicListNoneFound:

		TheTest.Printf(_L("\n\tETopicListNoneFound\n"));

		break;

	case ETopicAvailable:			// topic text

		TheTest.Printf(_L("\n\tETopicAvailable\n"));

		break;

	case ETopicNotFound:

		TheTest.Printf(_L("\n\tETopicNotFound\n"));

		break;

	case EIndexListAvailable:		// index list

		TheTest.Printf(_L("\n\tEIndexListAvailable\n"));

		break;

	case EIndexListNoneFound:

		TheTest.Printf(_L("\n\tEIndexListNoneFound\n"));

		break;

	case EIndexSearchListAvailable:	// topic list from index phrase

		TheTest.Printf(_L("\n\tEIndexSearchListAvailable\n"));