/*

* Copyright (c) 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: This file contains testclass implementation.

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "cpixsearchertest.h"

#include "ccpixsearcher.h"

#include "CSearchDocument.h"

#include "CCPixIndexer.h"

#include "common.h"

#include "cpixsearchertester.h"

#include "multithreadtester.h"

#include "cpixboostertester.h"

#include "cpixanalyzertester.h"

#include "cpixindexerterster.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

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

_LIT(KQueryString, "act");

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

// -----------------------------------------------------------------------------

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

_LIT( KNoErrorString, "No Error" );

_LIT( KErrorString, " *** Error ***" );

TInt doSearch( const TDesC& aSearchString, const TDesC& aBaseAppClass )

    {

    RSearchServerSession session;

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

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

    searcher->OpenDatabaseL( aBaseAppClass );

    TInt docCount = searcher->SearchL( aSearchString, KNullDesC);

    CleanupStack::PopAndDestroy( searcher );

    session.Close();

    return docCount;

    }

void doLog( CStifLogger* logger, TInt error, const TDesC& errorString )

    {

    if( KErrNone == error ) logger->Log( KNoErrorString );

    else logger->Log( errorString );

    }

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// Ccpixsearchertest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void Ccpixsearchertest::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        ENTRY( "TestOpenInvalidIndexdb", Ccpixsearchertest::TestOpenInvalidIndexdbL ),

        ENTRY( "TestOpenValidIndexdb", Ccpixsearchertest::TestOpenValidIndexdbL ),

        ENTRY( "TestAddDocument", Ccpixsearchertest::TestAddDocumentL ),

        ENTRY( "TestAddCancel", Ccpixsearchertest::TestAddCancelL),

        ENTRY( "TestAsyncAddDocument", Ccpixsearchertest::TestAsyncAddDocumentL),

        ENTRY( "TestUpdateDocument", Ccpixsearchertest::TestUpdateDocumentL),

        ENTRY( "TestAsyncUpdate", Ccpixsearchertest::TestAsyncUpdateL),

        ENTRY( "TestDeleteDocument", Ccpixsearchertest::TestDeleteDocumentL),

        ENTRY( "TestAsyncDelete", Ccpixsearchertest::TestAsyncDeleteL),

        ENTRY( "TestReset", Ccpixsearchertest::TestResetL),

        ENTRY( "TestFlush", Ccpixsearchertest::TestFlushL),

        ENTRY( "TestAsyncFlush", Ccpixsearchertest::TestAsyncFlushL),

        ENTRY( "TestAsyncReset", Ccpixsearchertest::TestAsyncResetL),

        ENTRY( "TestHandleIndexingResult", Ccpixsearchertest::TestHandleIndexingResultL),

        ENTRY( "TestSetAnalyzerAsync", Ccpixsearchertest::TestSetAnalyzerAsyncL),

        ENTRY( "TestSearchSession", Ccpixsearchertest::TestSearchSessionL),

        ENTRY( "TestMultiThreading", Ccpixsearchertest::TestMultiThreadingL),

        ENTRY( "TestNoBoost", Ccpixsearchertest::TestNoBoostL),

        ENTRY( "TestBoost", Ccpixsearchertest::TestBoostL),

        ENTRY( "TestFieldBoost", Ccpixsearchertest::TestFieldBoostL),

        ENTRY( "TestStandardAnalyzer", Ccpixsearchertest::TestStandardAnalyzerL),

        ENTRY( "TestWhitespaceTokenizer", Ccpixsearchertest::TestWhitespaceTokenizerL),

        ENTRY( "TestRemoveSnowballAnalyzer", Ccpixsearchertest::TestRemoveSnowballAnalyzerL),

        ENTRY( "TestKnownTerm", Ccpixsearchertest::TestKnownTermL),

        ENTRY( "TestWildcardTerm", Ccpixsearchertest::TestWildcardTermL),

        ENTRY( "TestDefineVolumeWorksNonEmptyPath", Ccpixsearchertest::TestDefineVolumeWorksNonEmptyPathL),

        ENTRY( "TestDefineVolumeWorksWithEmptyPath", Ccpixsearchertest::TestDefineVolumeWorksWithEmptyPathL),

        ENTRY( "TestDefineVolumeErrorScenarios", Ccpixsearchertest::TestDefineVolumeErrorScenariosL),

        ENTRY( "TestSearchCancellation", Ccpixsearchertest::TestSearchCancellationL),        

        ENTRY( "TestSearchAsynchronous", Ccpixsearchertest::TestSearchAsynchronousL),

        ENTRY( "TestSearchLeavesIfNotCancelled", Ccpixsearchertest::TestSearchLeavesIfNotCancelledL),

        ENTRY( "TestOpenIndexDb", Ccpixsearchertest::TestOpenIndexDbL),

        ENTRY( "TestDeleteIndexDbWhileSearching", Ccpixsearchertest::TestDeleteIndexDbWhileSearchingL),

        ENTRY( "TestGetDocumentAsync", Ccpixsearchertest::TestGetDocumentAsyncL),

        ENTRY( "TestGetInvalidDocumentAsync", Ccpixsearchertest::TestGetInvalidDocumentAsyncL),      

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestOpenInvalidIndexdbL

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestOpenInvalidIndexdbL( CStifItemParser& /*aItem*/ )

    {

    RSearchServerSession iSession;

    TInt error = KErrGeneral;

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

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

    _LIT( KTestFormBaseAppClassNoError, "TestOpenInvalidIndexdb: No Error" );

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

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

    if(err == KErrCannotOpenDatabase)

        {

        error = KErrNone;

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    /*CTestSearcher* testsearcher = new CTestSearcher();

    TInt error = KErrNone;

    testsearcher->setUp();

    testsearcher->tearDown();*/

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestOpenValidIndexdbL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestOpenValidIndexdbL( CStifItemParser& /*aItem*/ )

    {

    RSearchServerSession iSession;

    TInt error = KErrGeneral;

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestOpenValidIndexdb: No Error" );

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    if(err != KErrCannotOpenDatabase)

        {

        error = KErrNone;

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestOpenValidIndexdbL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestAddDocumentL( CStifItemParser& aItem )

    {

    RSearchServerSession iSession;

    TInt error = KErrNotFound;

    TPtrC fileName;

    TPtrC searchstring;

    aItem.GetNextString ( searchstring );

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestAddDocumentL: No Error" );

    TInt result =  doSearch( KQueryString , KFileBaseAppClassC );

    if ( result > 0 )

        {

        doLog( iLog, KErrUnknown, KTestFormBaseAppClassNoError );

        iSession.UnDefineVolume( KFileBaseAppClassC );

        iSession.Close();

        return KErrUnknown;

        }

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    // creating CSearchDocument object with unique ID for this application

    if( aItem.GetNextString ( fileName ) == KErrNone )

        {

        CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->AddL(*index_item);

            }

        CleanupStack::PopAndDestroy(index_item);

        }    

    //@TODO add wait here to harvest

    User::After((TTimeIntervalMicroSeconds32)16000000);

    result =  doSearch( KQueryString , KFileBaseAppClassC );

    if ( result > 0 )

        error = KErrNone;

    indexer->ResetL();

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestAddCancelL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestAddCancelL( CStifItemParser& aItem )

    {

    RSearchServerSession iSession;

    TInt error = KErrNotFound;

    TPtrC fileName;

    TPtrC searchstring;

    aItem.GetNextString ( searchstring );

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestAddCancelL: No Error" );

    TInt result =  doSearch( searchstring , KFileBaseAppClassC );

    if ( result > 0 )

        {

        doLog( iLog, KErrUnknown, KTestFormBaseAppClassNoError );

        return KErrUnknown;

        }

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    // creating CSearchDocument object with unique ID for this application

    if( aItem.GetNextString ( fileName ) == KErrNone )

        {

        CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->AddL(*index_item);

            }

        indexer->Cancel();// AddL is an atomic action, cannot cancel it

        CleanupStack::PopAndDestroy(index_item);

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;

    // Cancelled, but the document will still have been added to the IndexDB

    result =  doSearch( searchstring , KFileBaseAppClassC );

    if ( result > 0 )

        error = KErrNone;

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestAsyncAddDocumentL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestAsyncAddDocumentL( CStifItemParser& /*aItem*/ )

    {

    _LIT( KTestFormBaseAppClassNoError, "TestAsyncAddDocumentL: No Error" );

    CTestIndexer* testindexer = new CTestIndexer();

    testindexer->setUp();

    TRAPD ( error , testindexer->testAsyncAddL() );

    testindexer->tearDown();

    delete testindexer;

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestUpdateDocumentL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestUpdateDocumentL( CStifItemParser& aItem )

    {

    RSearchServerSession iSession;

    TInt error = KErrNone;

    TPtrC fileName;

    TPtrC searchstring;

    aItem.GetNextString ( searchstring );

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestUpdateDocumentL: No Error" );    

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    // creating CSearchDocument object with unique ID for this application

    if( aItem.GetNextString ( fileName ) == KErrNone )

        {

        CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->AddL(*index_item);

            }

        CleanupStack::PopAndDestroy(index_item);

        TInt result =  doSearch( searchstring , KFileBaseAppClassC );

        index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->UpdateL(*index_item);

            }

        CleanupStack::PopAndDestroy(index_item);

        User::After((TTimeIntervalMicroSeconds32)16000000);

        TInt result1 = doSearch( searchstring , KFileBaseAppClassC );

        if ( result != result1)

            error = KErrUnknown;

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;    

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestAsyncUpdateL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestAsyncUpdateL( CStifItemParser& /*aItem*/ )

    {

    _LIT( KTestFormBaseAppClassNoError, "TestAsyncUpdateL: No Error" );        

    CTestIndexer* testindexer = new CTestIndexer();

    testindexer->setUp();

    TRAPD ( error , testindexer->testAsyncUpdateL() );

    testindexer->tearDown();

    delete testindexer;

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestDeleteDocumentL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestDeleteDocumentL( CStifItemParser& aItem )

    {

    RSearchServerSession iSession;

    TInt error = KErrNone;

    TPtrC fileName;

    TPtrC searchstring;

    aItem.GetNextString ( searchstring );

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestDeleteDocumentL: No Error" );    

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    // creating CSearchDocument object with unique ID for this application

    if( aItem.GetNextString ( fileName ) == KErrNone )

        {

        CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->AddL(*index_item);

            }

        CleanupStack::PopAndDestroy(index_item);

        User::After((TTimeIntervalMicroSeconds32)16000000);

        TInt result =  doSearch( searchstring , KFileBaseAppClassC );

        // Send for indexing

        if (indexer)

            {

            indexer->DeleteL(fileName);

            }

        User::After((TTimeIntervalMicroSeconds32)16000000);

        TInt result1 = doSearch( searchstring , KFileBaseAppClassC );

        if ( (result-1) != result1)

            error = KErrUnknown;

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;    

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestAsyncDeleteL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestAsyncDeleteL( CStifItemParser& /*aItem*/ )

    {

    _LIT( KTestFormBaseAppClassNoError, "TestAsyncDeleteL: No Error" );        

    CTestIndexer* testindexer = new CTestIndexer();

    testindexer->setUp();

    TRAPD ( error , testindexer->testAsyncDeleteL() );

    testindexer->tearDown();

    delete testindexer;

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }

// -----------------------------------------------------------------------------

// Ccpixsearchertest::TestResetL

// -----------------------------------------------------------------------------

//

TInt Ccpixsearchertest::TestResetL( CStifItemParser& aItem )

    {

    RSearchServerSession iSession;

    TInt error = KErrUnknown;

    TPtrC fileName;

    TPtrC searchstring;

    aItem.GetNextString ( searchstring );

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

    iSession.DefineVolume(KFileBaseAppClassC, KNullDesC);

    _LIT( KTestFormBaseAppClassNoError, "TestResetL: No Error" );    

    CCPixIndexer* indexer = CCPixIndexer::NewLC(iSession);

    TRAPD(err, indexer->OpenDatabaseL( KFileBaseAppClassC ) );   

    // creating CSearchDocument object with unique ID for this application

    if( aItem.GetNextString ( fileName ) == KErrNone )

        {

        CSearchDocument* index_item = CSearchDocument::NewLC(fileName, KNullDesC, KNullDesC, CSearchDocument::EFileParser);

        // Send for indexing

        if (indexer)

            {

            indexer->AddL(*index_item);

            }

        CleanupStack::PopAndDestroy(index_item);

        User::After((TTimeIntervalMicroSeconds32)16000000);

        TInt result =  doSearch( searchstring , KFileBaseAppClassC );

        if ( result )

            {        

            // Send for indexing

            if (indexer)

                {

                indexer->ResetL();

                }        

            result = doSearch( searchstring , KFileBaseAppClassC );

            if ( !result )

                error = KErrNone;

              }

        }

    CleanupStack::PopAndDestroy(indexer);

    indexer = NULL;    

    iSession.UnDefineVolume( KFileBaseAppClassC );

    iSession.Close();

    doLog( iLog, error, KTestFormBaseAppClassNoError );

    return error;

    }