/*

* Copyright (c) 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 "cpixsearchertester.h"

//#include "TestDriver.h"

//#include "Logger.h"

#include <f32file.h>

#include "indevicecfg.h"

#include "CCPixSearcher.h"

#include "CSearchDocument.h"

#include "CCPixIndexer.h"

#include "common.h"

#define TS_ASSERT(a) \

    if ( !a ) User::Leave(KErrNotFound) 

_LIT(KQueryString, "act");

_LIT(KCpixRegFile, "c:\\private\\2001f6f7\\cpixreg.txt");

_LIT(KTestFileBaseAppClassC, "@c:test root file");

_LIT(KAppClassField, CPIX_APPCLASS_FIELD);

_LIT(KNonExistentField, "_foo");

_LIT(KRootFileUserTxt, TEXTAPPCLASS);

_LIT8(KRootMapsGbr8, "@GBR:foo bar root maps");

_LIT8(KRootMapsGbrPath8, "c:\\Data\\foo\\bar\\root\\maps\\street\\gbr");

_LIT(KRootMapsGbr, "@GBR:foo bar root maps");

_LIT(KRootMapsGbrPath, "c:\\Data\\foo\\bar\\root\\maps\\street\\gbr");

_LIT(KInvalidQualifiedBaseAppClass1, "@:foo bar root maps");

_LIT(KInvalidQualifiedBaseAppClass2, ":foo bar root maps");

_LIT(KInvalidQualifiedBaseAppClass3, "foo bar root maps");

_LIT(KInvalidQualifiedBaseAppClass4, "root file");

const TInt KMaxFileSize = 400;

TInt CTestSearcher::SearchForTextL(const TDesC& aQueryString, const TDesC& aDefaultField)

    {

    TInt documentCount(KErrNotFound);

    // Send for indexing

    if ( iSearcher )

        {

        documentCount = iSearcher->SearchL(aQueryString, aDefaultField);

        }

    return documentCount;

    }

void CTestSearcher::AddFileToIndexL(const TDesC& aFileName)

    {

    CSearchDocument* doc = CSearchDocument::NewLC(aFileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);   

    iIndexer->AddL(*doc);

    CleanupStack::PopAndDestroy(doc);

    }

void CTestSearcher::initialsetUp()

    {

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

    iSession.UnDefineVolume(KTestFileBaseAppClassC);

    // define a test volume

    iSession.DefineVolume(KTestFileBaseAppClassC, KNullDesC);

    }

void CTestSearcher::createandinitindexer()

    {

    iIndexer = CCPixIndexer::NewL(iSession);

    iIndexer->OpenDatabaseL(KTestFileBaseAppClassC);

    iIndexer->ResetL();

    }

void CTestSearcher::createsearcher()

    {

    iSearcher = CCPixSearcher::NewL(iSession);

    iSearcher->OpenDatabaseL(KTestFileBaseAppClassC);

    }

void CTestSearcher::harvesttestcontent( TInt aCount )

    {

    for (int i = 0; i < aCount; i++)

        {

        switch (i)

            {

            case 0:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act0.txt")); 

                break;

            case 1:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act1.txt")); 

                break;

            case 2:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act2.txt")); 

                break;

            case 3:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act3.txt")); 

                break;

            case 4:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act4.txt")); 

                break;

            case 5:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act5.txt")); 

                break;

            case 6:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\act6.txt")); 

                break;

            case 7:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\complete.txt")); 

                break;

            case 8:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\index.txt"));    

                break;

            default:

                AddFileToIndexL(_L("c:\\Data\\cpixS60unittest\\introduction.txt"));

                break;

            }

        }

    }

void CTestSearcher::InitAsyncComponents()

    {

    // iWait will cause waiting until some asynchronous event has happened

    iWait = new (ELeave) CActiveSchedulerWait;

    iMyAOClass = CAOTestClass::NewL(this);

    iDocumentCount = 0;

    iDocument = NULL;

    iHandleDocumentLFunctionCalled = EFalse;

    iHandleSetAnalyzerCalled = EFalse;

    }

void CTestSearcher::ReleaseIndexer()

    {

    if (iIndexer)

        {

        iIndexer->ResetL();

        }

    delete iIndexer;

    iIndexer = NULL;

    }

void CTestSearcher::ReleaseSearcher()

    {

    delete iSearcher;

    iSearcher = NULL;

    }

void CTestSearcher::ReleaseAsyncComponents()

    {

    iDocumentCount = 0;

    if ( iDocument )

        {

        delete iDocument;

        iDocument = NULL;

        }

    if( iWait )

        {

        delete iWait;

        iWait = NULL;

        }

    if( iMyAOClass )

        {

        delete iMyAOClass;

        iMyAOClass = NULL;

        }

    }

void CTestSearcher::tearDown()

    {    

    // undefine a test volume

    iSession.UnDefineVolume(KTestFileBaseAppClassC);

    iSession.Close();

    iFs.Close();

    }

void CTestSearcher::HandleOpenDatabaseResultL( TInt /* aError */ )

    {

    if (iWait && iWait->IsStarted())

        {

        // All done, signal that can continue now.

        iWait->AsyncStop();

        }

    }

void CTestSearcher::HandleSearchResultsL(TInt /* aError */, TInt aEstimatedResultCount)

    {

    iDocumentCount = aEstimatedResultCount;

    if (iWait && iWait->IsStarted())

        {

        // All done, signal that can continue now.

        iWait->AsyncStop();

        }

    }

void CTestSearcher::HandleSetAnalyzerResultL(TInt /*aError*/)

    {

    iHandleSetAnalyzerCalled = ETrue;

    if (iWait && iWait->IsStarted())

        {

        // All done, signal that can continue now.

        iWait->AsyncStop();

        }

    }

void CTestSearcher::HandleDocumentL(TInt /* aError */, CSearchDocument* aDocument)

    {

    iHandleDocumentLFunctionCalled = ETrue;

    if (iWait && iWait->IsStarted())

        {

        if ( iDocument )

            {

            delete iDocument;

            iDocument = NULL;

            }

        iDocument = aDocument;

        // All done, signal that can continue now.

        iWait->AsyncStop();

        }

    }

// Timeout callback

void CTestSearcher::CallCompleted( int /* i */ )

    {

    if (iWait && iWait->IsStarted())

        {

        iWait->AsyncStop();

        }

    }

void CTestSearcher::testKnownTermTestsL()

    {

    // Shakespeare's corpus files have plenty of terms "act" in them EXPECTED RESULTS > 0

    TInt result = SearchForTextL(KQueryString, KNullDesC);

    TS_ASSERT(result > 0);

    // Shakespeare's corpus files have plenty of terms "scene" in them EXPECTED RESULTS > 0

    result = SearchForTextL(_L("scene"), KNullDesC);

    TS_ASSERT(result > 0);

    if(result > 0)

        {

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

            {

            CSearchDocument* document = iSearcher->GetDocumentL(i);     

            TS_ASSERT(document != NULL);

            delete document;

            }

        }

    // Shakespeare's corpus files have no terms "ipod" in them EXPECTED RESULTS IS ZERO

    result = SearchForTextL(_L("ipod"), KNullDesC);

    TS_ASSERT(result == 0);

    // Shakespeare's corpus files have plenty of terms "act" in them EXPECTED RESULTS == 0, but not in this field

    result = SearchForTextL(KQueryString, KNonExistentField);

    TS_ASSERT(result == 0);

    // can search for a known value in a different field

    result = SearchForTextL(_L("usrdoc"), KAppClassField);

    TS_ASSERT(result > 0);

    // can search for a known value in a different field

    result = SearchForTextL(_L("usrdoc"), KNonExistentField);

    TS_ASSERT(result == 0); // TODO XXX TIM why does searching for an existing term in a non-existent field return a non-zero value    

    }

void CTestSearcher::testWildcardTermTests()

    {

    // Shakespeare's corpus files have plenty of terms "act" in them EXPECTED RESULTS > 0

    TInt result = SearchForTextL(_L("a*t"), KNullDesC);

    TS_ASSERT(result > 0);

    // Shakespeare's corpus files have plenty of terms "act" in them EXPECTED RESULTS > 0

    result = SearchForTextL(_L("sc*ne"), KNullDesC);

    TS_ASSERT(result > 0);

    }

void CTestSearcher::testDefineVolumeWorksNonEmptyPath()

    {

    TBuf8<KMaxFileSize> cpixRegBuf;

    iFs.Connect();

    // open up the cpixreg.txt file again and make sure 

    // that it IS NOT in there

    TInt err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound == err);

    err = cpixRegBuf.Find(KRootMapsGbrPath8());

    TS_ASSERT(KErrNotFound == err);

    iFile.Close();

    // define a new volume

    err = iSession.DefineVolume(KRootMapsGbr, KRootMapsGbrPath);

    TS_ASSERT(err == KErrNone);

    // open up the cpixreg.txt file and make sure that it IS in there

    err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound != err);

    err = cpixRegBuf.Find(KRootMapsGbrPath8());

    TS_ASSERT(KErrNotFound != err);

    iFile.Close();

    // now undefine the same volume

    err = iSession.UnDefineVolume(KRootMapsGbr);

    TS_ASSERT(err == KErrNone);

    // open up the cpixreg.txt file again and make sure 

    // that it IS NOT in there

    err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound == err);

    err = cpixRegBuf.Find(KRootMapsGbrPath8());

    TS_ASSERT(KErrNotFound == err);

    iFile.Close();

    }

void CTestSearcher::testDefineVolumeWorksWithEmptyPath()

    {

    TBuf8<KMaxFileSize> cpixRegBuf;

    iFs.Connect();

    // open up the cpixreg.txt file again and make sure 

    // that it IS NOT in there

    TInt err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound == err);

    err = cpixRegBuf.Find(KRootMapsGbrPath8());

    TS_ASSERT(KErrNotFound == err);

    iFile.Close();

    // define a new volume

    err = iSession.DefineVolume(KRootMapsGbr, KNullDesC);

    TS_ASSERT(err == KErrNone);

    // open up the cpixreg.txt file and make sure that it IS in there

    err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound != err);

    iFile.Close();

    // now try to redefine the same volume again

    err = iSession.DefineVolume(KRootMapsGbr, KNullDesC);

    TS_ASSERT(err == KErrNone);

    // now undefine the same volume

    err = iSession.UnDefineVolume(KRootMapsGbr);

    TS_ASSERT(err == KErrNone);

    // open up the cpixreg.txt file again and make sure 

    // that it IS NOT in there

    err = iFile.Open(iFs, KCpixRegFile, EFileStreamText);

    iFile.Read(0, cpixRegBuf);

    err = cpixRegBuf.Find(KRootMapsGbr8());

    TS_ASSERT(KErrNotFound == err);

    iFile.Close();

    }

void CTestSearcher::testDefineVolumeErrorScenarios()

    {

    // Attempt to define a volume for a invalid qualified base app classes.

    TInt result = iSession.DefineVolume(KInvalidQualifiedBaseAppClass1, KNullDesC);

    TS_ASSERT(result == KErrCannotDefineVolume);

    result = iSession.DefineVolume(KInvalidQualifiedBaseAppClass2, KNullDesC);

    TS_ASSERT(result == KErrCannotDefineVolume);

    result = iSession.DefineVolume(KInvalidQualifiedBaseAppClass3, KNullDesC);

    TS_ASSERT(result == KErrCannotDefineVolume);

    result = iSession.DefineVolume(KInvalidQualifiedBaseAppClass4, KNullDesC);

    TS_ASSERT(result == KErrCannotDefineVolume);

    // Attempt to undefine a volume that was not defined.

    result = iSession.UnDefineVolume(KRootMapsGbr);

    TS_ASSERT(result == KErrNone);

    }

void CTestSearcher::testSearchCancellation()

    {

    // Test basic cancellation of search request

    iSearcher->SearchL(*this, KQueryString);

    iSearcher->Cancel();

    // If want to set a maximum timeout value for this test case then

    // uncomment this line, which will cause CTestSearcher::CallCompleted

    // to be triggered.

    iMyAOClass->StartL(1000000*20); //Async call: Maximum TimeOut time 20 seconds

    // Wait until either HandleSearchResultsL or Timeout exceeded

    iWait->Start();

    TS_ASSERT(iDocumentCount == 0);

    // Now make sure that subsequent searches work correctly

    iSearcher->SearchL(*this, KQueryString);

    // Wait until HandleSearchResultsL completes

    iWait->Start();

    TS_ASSERT(iDocumentCount > 0);

    }

void CTestSearcher::testSearchAsynchronous()

    {

    iSearcher->SearchL(*this, KQueryString);

    // Wait until HandleSearchResultsL completes

    iWait->Start();

    TS_ASSERT(iDocumentCount > 0);

    }

void CTestSearcher::testSearchLeavesIfNotCancelled()

    {

    // Perform first search

    TRAPD(err, iSearcher->SearchL(*this, KQueryString) );

    TS_ASSERT(iDocumentCount == 0);

    TS_ASSERT(err == KErrNone);

    // before ::HandleSearchResults has been called, 

    // initiate a second search. 

    TRAP(err, iSearcher->SearchL(*this, KQueryString));

    TS_ASSERT(err == KErrInUse);

    // Wait until HandleSearchResultsL completes

    iWait->Start();

    TS_ASSERT(iDocumentCount > 0);

    }

void CTestSearcher::testOpenIndexDb()

    {

    // Make sure cannot open an invalid index db

    _LIT(KInvalidQualifiedBaseAppClass, "@x:test invalid");

    CCPixSearcher* searcher = CCPixSearcher::NewLC(iSession);

    TRAPD(err, searcher->OpenDatabaseL(KInvalidQualifiedBaseAppClass) );

    TS_ASSERT(!searcher->IsDatabaseOpen());

    TS_ASSERT(err == KErrCannotOpenDatabase);

    TRAP(err, searcher->SearchL(KQueryString));

    TS_ASSERT(err == KErrNotReady);

    CleanupStack::PopAndDestroy(searcher);

    searcher = NULL; 

    // check that same searcher object can open a second indexDb

    searcher = CCPixSearcher::NewLC(iSession);

    TRAP(err, searcher->OpenDatabaseL(_L("root")));

    TS_ASSERT(searcher->IsDatabaseOpen());

    searcher->SearchL(KQueryString);

    TS_ASSERT(err == KErrNone);

    TRAP(err, searcher->OpenDatabaseL(KTestFileBaseAppClassC));

    TS_ASSERT(err == KErrNone);

    TS_ASSERT(searcher->IsDatabaseOpen());

    const TInt docCount = searcher->SearchL(KQueryString);

    TS_ASSERT(docCount > 0);

    CleanupStack::PopAndDestroy(searcher);

    searcher = NULL; 

    // check that asynchronous open works as expected

    searcher = CCPixSearcher::NewLC(iSession);

    TRAP(err, searcher->OpenDatabaseL(*this, _L("root")));

    // If want to set a maximum timeout value for this test case then

    // uncomment this line, which will cause CTestSearcher::CallCompleted

    // to be triggered.

    iMyAOClass->StartL(1000000*10); //Async call: Maximum TimeOut time 10 seconds

    iWait->Start();

    TS_ASSERT(searcher->IsDatabaseOpen());

    CleanupStack::PopAndDestroy(searcher);

    }

void CTestSearcher::testDeleteIndexDbWhileSearching()

    {

    CCPixSearcher* searcher = CCPixSearcher::NewLC(iSession);

    TRAPD(err, searcher->OpenDatabaseL(KTestFileBaseAppClassC) );

    TS_ASSERT(searcher->IsDatabaseOpen());

    //TS_ASSERT(searcher->GetBaseAppClass() != KNullDesC);

    TS_ASSERT( (searcher->GetBaseAppClass().Compare( KNullDesC)) );

    //Set Standard Analyzer to improve code coverage of search

    searcher->SetAnalyzerL(*this,_L( "" CPIX_ANALYZER_STANDARD ));

    iWait->Start(); //Start Wait AO

    TS_ASSERT(iHandleSetAnalyzerCalled);

    TRAP(err, searcher->SearchL(*this, KQueryString));

    // don't wait for the search results.

    CleanupStack::PopAndDestroy(searcher);

    searcher = NULL; 

    // is there a panic???

    }

void CTestSearcher::testGetDocumentAsync()

    {