/*

* 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:  Unit test class for testing 12-key predictive search table

*

*/

//  INTERNAL INCLUDES

#include "t_cpplpredictivesearchtable.h"

#include "pltables.h"

#include "dbsqlconstants.h"

#include "c12keykeymap.h"

#include "c12keypredictivesearchtable.h"

#include "cqwertypredictivesearchtable.h"

#include "cpredictivesearchsettingstable.h"

#include "cpredictivesearchsynchronizer.h"

#include "t_predictivesearchtabledefs.h"

#include "predictivesearchlog.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <f32file.h> // CFileMan

// Used to create HbKeymapFactory singleton to get rid of resource leak

#include <QLocale>

#include <hbinputkeymapfactory.h>

// Must have same value as KMaxTokenLength in c12keypredictivesearchtable.cpp

const TInt KMaxTokenLength = 15;

const TInt KTableCount = 12;

// Must have same value as KConversionError in cpplpredictivesearchtable.cpp

const quint64 KConversionError = 0xeeeeeeeeeeeeeee;

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

// UT_CPplPredictiveSearchTable::NewL

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

//

UT_CPplPredictiveSearchTable* UT_CPplPredictiveSearchTable::NewL()

    {

    UT_CPplPredictiveSearchTable* self = UT_CPplPredictiveSearchTable::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// UT_CPplPredictiveSearchTable::NewLC

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

//

UT_CPplPredictiveSearchTable* UT_CPplPredictiveSearchTable::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// UT_CPplPredictiveSearchTable::~UT_CPplPredictiveSearchTable

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

//

UT_CPplPredictiveSearchTable::~UT_CPplPredictiveSearchTable()

    {

    delete iTable;

    iTable = NULL;

    iDB.Close(); // Must close DB before it can be deleted

    RSqlDatabase::Delete(KDBFile);

    }

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

// UT_CPplPredictiveSearchTable::UT_CPplPredictiveSearchTable

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

//

UT_CPplPredictiveSearchTable::UT_CPplPredictiveSearchTable()

    {

    }

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

// UT_CPplPredictiveSearchTable::ConstructL

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

//

void UT_CPplPredictiveSearchTable::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    // Create singleton outside actual test cases so that it is not treated as

    // resource leak, since it can't be deleted.

    HbKeymapFactory::instance();

    }

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

// UT_CPplPredictiveSearchTable::SetupL

// Must start with an empty DB file for each test case

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

//

void UT_CPplPredictiveSearchTable::SetupL()

    {

    // Ignore error

	RSqlDatabase::Delete(KDBFile);

    // If this causes KErrAlreadyExists, iDB won't be fully constructed

	iDB.Create(KDBFile);

	iTable = C12keyPredictiveSearchTable::NewL(iDB);

	iPredSearchQwertyTable = CQwertyPredictiveSearchTable::NewL(iDB);

	iPredSearchSettingsTable = CPredictiveSearchSettingsTable::NewL(iDB);

	// Create (empty) predictive search tables to DB

	iTable->CreateTableL();

	iPredSearchQwertyTable->CreateTableL();

    iPredSearchSettingsTable->CreateTableL();

    iPredictiveSearchSynchronizer =

        CPredictiveSearchSynchronizer::NewL(iDB,

                                            *iTable,

                                            *iPredSearchQwertyTable,

                                            *iPredSearchSettingsTable);  

    HbKeymapFactory::instance();

	}

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

// UT_CPplPredictiveSearchTable::SetupSyncL

// For synchronize tables test case

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

//

void UT_CPplPredictiveSearchTable::SetupSyncL()

    {

	UseSpecificDbL(KDBFileWithoutPredSearch);

    }

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

// UT_CPplPredictiveSearchTable::SetupSyncJust12keyExistsL

// For synchronize tables test case

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

//

void UT_CPplPredictiveSearchTable::SetupSyncJust12keyExistsL()

    {

	UseSpecificDbL(KDBFile12keyButNoQwerty);

    }

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

// UT_CPplPredictiveSearchTable::SetupLanguageChangesL

// For UT_LanguageChangesL case

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

//

void UT_CPplPredictiveSearchTable::SetupLanguageChangesL()

    {

	UseSpecificDbL(KDBFileOtherLanguage);

    }

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

// UT_CPplPredictiveSearchTable::UseSpecificDbL

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

//

void UT_CPplPredictiveSearchTable::UseSpecificDbL(const TDesC& aDbFile)

    {

    // Copy an existing DB file that does not contain predictive search tables

    // to a DB file that will be used in test.

    RFs fs;

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

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

    CleanupStack::PushL(fm);

    User::LeaveIfError(fm->Copy(aDbFile, KDBFile));

    CleanupStack::PopAndDestroy(fm);

    fs.Close();

    User::LeaveIfError(iDB.Open(KDBFile));

    iTable = C12keyPredictiveSearchTable::NewL(iDB);

    iPredSearchQwertyTable = CQwertyPredictiveSearchTable::NewL(iDB);

	iPredSearchSettingsTable = CPredictiveSearchSettingsTable::NewL(iDB);

    iPredictiveSearchSynchronizer =

        CPredictiveSearchSynchronizer::NewL(iDB,

                                            *iTable,

                                            *iPredSearchQwertyTable,

                                            *iPredSearchSettingsTable);

    }

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

// UT_CPplPredictiveSearchTable::Teardown

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

//

void UT_CPplPredictiveSearchTable::Teardown()

    {

    delete iPredictiveSearchSynchronizer;

    iPredictiveSearchSynchronizer = NULL;

    delete iTable;

	iTable = NULL;

	delete iPredSearchQwertyTable;

	iPredSearchQwertyTable = NULL;

	delete iPredSearchSettingsTable;

	iPredSearchSettingsTable = NULL;

	iDB.Close(); // Must close DB before it can be deleted

	RSqlDatabase::Delete(KDBFile);

    }

// TEST CASES

// Dummy case to see if the first case always results a resource leak (2 heap cells)

void UT_CPplPredictiveSearchTable::UT_DummyL()

    {    

    // The first test case that writes to tables, seems to cause resource leak

    // if the DB file did not have predictive search tables already.

    AddContactL(KTestFirstName, KNullDesC, KTestContactId);

    }

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

// UT_CPplPredictiveSearchTable::UT_CreateInDbLL

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

//

void UT_CPplPredictiveSearchTable::UT_CreateInDbLL()

    {

    CheckItemCountL(); // all empty

    AddContactL(KTestFirstName, KTestLastName, KTestContactId);

    CheckItemCountL(0, 1, 0, 0, 1); // Tables 1 and 4 have one entry

    }

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

// UT_CPplPredictiveSearchTable::UT_CreateInDbManyContactsL

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

//

void UT_CPplPredictiveSearchTable::UT_CreateInDbManyContactsL()

    {

	AddContactL(_L(" 1 22 333 4"), _L("  505 6768"), KTestContactId);

	// Only 4 tokens are stored: first two LN and first two FN. 

	CheckItemCountL(0, 1, 1, 0, 0, 1, 1);

	AddContactL(_L(" 1 22 333 4"), _L("777  505 6768"), KTestContactId2);

	// Adds contact to tables 1 2 7 5

	CheckItemCountL(0, 2, 2, 0, 0, 2, 1, 1);

	AddContactL(_L(" 1 22 333 4"), _L("  5 6"), KTestContactId3);

	// Adds contact to tables 1 2 5 6

	CheckItemCountL(0, 3, 3, 0, 0, 3, 2, 1);

	AddContactL(_L("858585"), _L("88"), KTestContactId4);

	// Adds contact to table 8

	CheckItemCountL(0, 3, 3, 0, 0, 3, 2, 1, 1);

	TContactItemId id = KTestContactId4;

	AddContactL(KNullDesC, KNullDesC, ++id);

	// Contact is not added to any table

	CheckItemCountL(0, 3, 3, 0, 0, 3, 2, 1, 1);

	AddContactL(_L("1 1 1 1 1 1 1"), KNullDesC, ++id);

	// Adds contact to table 1

	CheckItemCountL(0, 4, 3, 0, 0, 3, 2, 1, 1);

	AddContactL(KNullDesC, _L("  22 22 2 2 222222"), ++id);

	// Adds contact to table 2

	CheckItemCountL(0, 4, 4, 0, 0, 3, 2, 1, 1);

	}

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

// UT_CPplPredictiveSearchTable::UT_CreateInDbWithHashAndStarL

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

//

void UT_CPplPredictiveSearchTable::UT_CreateInDbWithHashAndStarL()

    {

	AddContactL(_L(" # * +"), _L(" +*# **"), KTestContactId);

	AddContactL(_L("*"), _L("+355"), KTestContactId2); 

    CheckItemCountL(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1);

	}

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

// UT_CPplPredictiveSearchTable::UT_UpdateLL

// Update an existing contact

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

//

void UT_CPplPredictiveSearchTable::UT_UpdateLL()

    {

    _LIT(KTestUpdatedName, "0581");

    // Add one contact to DB

    AddContactL(KTestFirstName, KTestLastName, KTestContactId);

    // Update some field

    TInt id = KUidContactCardValue;

    TUid uid;

    uid.iUid = id;

    CContactItem* contact = CContactItem::NewLC(uid);

    // Only first name is changed, but also the last name must be filled to

    // CContactItemField.

    CContactItemField* field =

        CContactItemField::NewL(KStorageTypeText, KUidContactFieldGivenName);

    field->TextStorage()->SetTextL(KTestUpdatedName);

    contact->AddFieldL(*field); // Takes ownership

    field = NULL;

    field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldFamilyName);

    field->TextStorage()->SetTextL(KTestLastName);  

    contact->AddFieldL(*field); // Takes ownership

	contact->SetId(KTestContactId);

    iTable->UpdateL(*contact);

    CleanupStack::PopAndDestroy(contact);

    CheckItemCountL(1, 0, 0, 0, 1); // tables 0 and 4 have one entry

    RArray<TInt32> results = DoPredictiveSearchL(KTestUpdatedName);

    CleanupClosePushL(results);

    EUNIT_ASSERT_EQUALS(1, results.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results[0]);

    CleanupStack::PopAndDestroy(&results);

    RArray<TInt32> results2 = DoPredictiveSearchL(KTestFirstName);

    CleanupClosePushL(results2);

    EUNIT_ASSERT_EQUALS(0, results.Count());

    CleanupStack::PopAndDestroy(&results2);

    }

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

// UT_CPplPredictiveSearchTable::UT_UpdateLBothFieldsL

// Update an existing contact

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

//

void UT_CPplPredictiveSearchTable::UT_UpdateLBothFieldsL()

    {

    _LIT(KTestUpdatedFirstName, "777");

    _LIT(KTestUpdatedLastName, "012345");

    // Add some contacts

    AddContactL(KTestFirstName, KTestLastName, KTestContactId);

    AddContactL(_L("9876"), _L("888"), KTestContactId2);

    AddContactL(_L("5050"), _L("2"), KTestContactId3);

    CheckItemCountL(0, 1, 1, 0, 1, 1, 0, 0, 1, 1);

    // Update FN and LN of second contact

    TInt id = KUidContactCardValue;

    TUid uid;

    uid.iUid = id;

    CContactItem* contact = CContactItem::NewLC(uid);

    // Only first name is changed, but also the last name must be filled to

    // CContactItemField.

    CContactItemField* field =

       CContactItemField::NewL(KStorageTypeText, KUidContactFieldGivenName);

    field->TextStorage()->SetTextL(KTestUpdatedFirstName);

    contact->AddFieldL(*field); // Takes ownership

    field = NULL;

    field = CContactItemField::NewL(KStorageTypeText, KUidContactFieldFamilyName);

    field->TextStorage()->SetTextL(KTestUpdatedLastName);  

    contact->AddFieldL(*field); // Takes ownership

    contact->SetId(KTestContactId2);

    iTable->UpdateL(*contact);

    CleanupStack::PopAndDestroy(contact);

    CheckItemCountL(1, 1, 1, 0, 1, 1, 0, 1, 0, 0);

    RArray<TInt32> results = DoPredictiveSearchL(KTestUpdatedFirstName);

    CleanupClosePushL(results);

    EUNIT_ASSERT_EQUALS(1, results.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId2, results[0]);

    CleanupStack::PopAndDestroy(&results);

    RArray<TInt32> results2 = DoPredictiveSearchL(KTestUpdatedLastName);

    CleanupClosePushL(results2);

    EUNIT_ASSERT_EQUALS(1, results2.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId2, results2[0]);

    CleanupStack::PopAndDestroy(&results2);

    }

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

// UT_CPplPredictiveSearchTable::UT_SearchL

// Search contacts from the table 

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

//

void UT_CPplPredictiveSearchTable::UT_SearchL()

    {

    // Create some contacts

    AddContactL(_L("123704"), _L("39"), KTestContactId);

    AddContactL(_L("908"), KNullDesC, KTestContactId2);

    AddContactL(KNullDesC, _L("967"), KTestContactId3);

    // Tables 0 and 2 are empty, since company name is not used

    CheckItemCountL(0, 1, 0, 1, 0, 0, 0, 0, 0, 2); 

    // One contact matches

    RArray<TContactItemId> results = DoPredictiveSearchL(_L("1"));

    CleanupClosePushL(results);

    EUNIT_ASSERT_EQUALS(1, results.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results[0]);

    CleanupStack::PopAndDestroy(&results);

    // No matches

    RArray<TContactItemId> results2 = DoPredictiveSearchL(_L("124"));

    CleanupClosePushL(results2);

    EUNIT_ASSERT_EQUALS(0, results2.Count());

    CleanupStack::PopAndDestroy(&results2);

    // Two matches

    RArray<TContactItemId> results3 = DoPredictiveSearchL(_L("9"));

    CleanupClosePushL(results3);

    EUNIT_ASSERT_EQUALS(2, results3.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId2, results3[0]);

    EUNIT_ASSERT_EQUALS(KTestContactId3, results3[1]);

    CleanupStack::PopAndDestroy(&results3);

    }

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

// UT_CPplPredictiveSearchTable::UT_SearchWithSpacesL

// Search contacts having spaces from the table 

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

//

void UT_CPplPredictiveSearchTable::UT_SearchWithSpacesL()

    {

    // Create some contacts

    // Goes to tables 8, 4 and 0

    AddContactL(_L(" 8075 4702 380"), _L(" 470 038"), KTestContactId);

    // Goes to tables 0 and 4

    AddContactL(_L(" 0 00"), _L(" 470 038  38"), KTestContactId2);

    // Goes to table 1 and 4

    AddContactL(KNullDesC, _L(" 123 47  "), KTestContactId3);

    CheckItemCountL(2, 1, 0, 0, 3, 0, 0, 0, 1, 0);

    // No matches

    RArray<TContactItemId> results = DoPredictiveSearchL(_L("2"));

    TInt count = results.Count();

    results.Close();

    EUNIT_ASSERT_EQUALS(0, count);

    RArray<TContactItemId> results2 = DoPredictiveSearchL(_L("07"));

    count = results2.Count();

    results2.Close();

    EUNIT_ASSERT_EQUALS(0, count);

    RArray<TContactItemId> results3 = DoPredictiveSearchL(_L("1230"));

    count = results3.Count();

    results3.Close();

    EUNIT_ASSERT_EQUALS(0, count);

    RArray<TContactItemId> results4 = DoPredictiveSearchL(_L("5047"));

    count = results4.Count();

    results4.Close();

    EUNIT_ASSERT_EQUALS(0, count);

    RArray<TContactItemId> results5 = DoPredictiveSearchL(_L("4700"));

    count = results5.Count();

    results5.Close();

    EUNIT_ASSERT_EQUALS(0, count);

    // One match

    RArray<TContactItemId> results6 = DoPredictiveSearchL(_L("00"));

    CleanupClosePushL(results6);

    EUNIT_ASSERT_EQUALS(1, results6.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId2, results6[0]);

    CleanupStack::PopAndDestroy(&results6);

    RArray<TContactItemId> results7 = DoPredictiveSearchL(_L("4702"));

    CleanupClosePushL(results7);

    EUNIT_ASSERT_EQUALS(1, results7.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results7[0]);

    CleanupStack::PopAndDestroy(&results7);

    // Two matches

    RArray<TContactItemId> results8 = DoPredictiveSearchL(_L("470"));

    CleanupClosePushL(results8);

    EUNIT_ASSERT_EQUALS(2, results8.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results8[0]);

    EUNIT_ASSERT_EQUALS(KTestContactId2, results8[1]);

    CleanupStack::PopAndDestroy(&results8);

    RArray<TContactItemId> results9 = DoPredictiveSearchL(_L("0"));

    CleanupClosePushL(results9);

    EUNIT_ASSERT_EQUALS(2, results9.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results9[0]);

    EUNIT_ASSERT_EQUALS(KTestContactId2, results9[1]);

    CleanupStack::PopAndDestroy(&results9);

    RArray<TContactItemId> results10 = DoPredictiveSearchL(_L("038"));

    CleanupClosePushL(results10);

    EUNIT_ASSERT_EQUALS(2, results10.Count());

    EUNIT_ASSERT_EQUALS(KTestContactId, results10[0]);

    EUNIT_ASSERT_EQUALS(KTestContactId2, results10[1]);

    CleanupStack::PopAndDestroy(&results10);

    // Three matches