/*

* 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 CPcsKeyMap

*

*/

//  INTERNAL INCLUDES

#include "t_cpplpredictivesearchtable.h"

#include "pltables.h"

#include "dbsqlconstants.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <f32file.h> // added for setup2L() 

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

#include <QLocale>

#include <hbinputkeymapfactory.h>

// Database file

_LIT(KDBFile, "c:\\unittest.db");

_LIT(KDBFileWithoutPredSearch, "c:\\contacts_without_pred_search_tables.db");

const TContactItemId KTestContactId = 20;

const TContactItemId KTestContactId2 = 85;

const TContactItemId KTestContactId3 = 7001;

const TContactItemId KTestContactId4 = 56030;

_LIT(KTestFirstName, "123");

_LIT(KTestLastName, "45678");

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

const TInt KMaxDigits = 15;

// 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();

#if defined(USE_ORBIT_KEYMAP)

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

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

    HbKeymapFactory::instance();

#else

    // If Orbit keymap is not used, EUnit shows there is a resource leak in the

    // first test case of UT_CPplPredictiveSearchTable that writes something to

    // the database.

    // To get rid of the resource leak, the following code is here to create DB,

    // and one contact, delete it, delete DB. 

    SetupL();

    UT_DeleteLL(); // Adds and deletes 1 contact

    Teardown();

#endif

    }

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

// 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 = CPplPredictiveSearchTable::NewL(iDB);

	// Create (empty) predictive search tables to DB

	iTable->CreateTableL();

	}

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

// UT_CPplPredictiveSearchTable::Setup2L

// For synchronize tables test case

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

//

void UT_CPplPredictiveSearchTable::Setup2L()

    {

    // 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);

    _LIT(KSourceFile, "c:\\Copy of contacts_without_pred_search_tables.db");

    User::LeaveIfError(fm->Copy(KSourceFile, KDBFileWithoutPredSearch));

    CleanupStack::PopAndDestroy(fm);

    fs.Close();

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

    iTable = CPplPredictiveSearchTable::NewL(iDB);

    }

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

// UT_CPplPredictiveSearchTable::Teardown

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

//

void UT_CPplPredictiveSearchTable::Teardown()

    {

    delete iTable;

	iTable = 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

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); // table 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_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

    RArray<TContactItemId> results11 =  DoPredictiveSearchL(_L("47"));

    CleanupClosePushL(results11);

    EUNIT_ASSERT_EQUALS(3, results11.Count());

    CleanupStack::PopAndDestroy(&results11);

    }

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

// UT_CPplPredictiveSearchTable::UT_DeleteLL

// Delete a the only contact from the table 

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

//

void UT_CPplPredictiveSearchTable::UT_DeleteLL()

    {

    AddContactL(KTestFirstName, KTestLastName, KTestContactId);

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

    TInt id = KUidContactCardValue;

    TUid uid;

    uid.iUid = id;

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

    contact->SetId(KTestContactId);

    TBool lowDiskErrorOccurred(EFalse);

    iTable->DeleteL(*contact, lowDiskErrorOccurred);

    CleanupStack::PopAndDestroy(contact);

    CheckItemCountL();

    }

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

// UT_CPplPredictiveSearchTable::UT_DeleteLL

// Delete contacts one-by-one from the table that has multiple contacts

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

//

void UT_CPplPredictiveSearchTable::UT_DeleteContactsL()

    {

    _LIT(KTestFN, "7 8 ");

    _LIT(KTestLN, "  4  56  1  ");

    TContactItemId contactId = KTestContactId4 + 1;

	// Goes to tables 1 and 4