/*

* Copyright (c) 2006 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 case

*

*/

#include <w32std.h>

#include <coecntrl.h>

#include <eikenv.h>

#include <ptikeymappings.h>

#include "BCTestKeymap.h"

#include "BCTestPtiEngcontainer.h"

#include "BCTestPtiEng.hrh"

const TInt KPtiNumKeys = 12;

const TUint16 Keys[]=

    {

        //lower case

        /*1*/ '1', '\t',

        /*2*/ 'a','b','c','\t',

        /*3*/ 'd','e','f','\t',

        /*4*/ 'g','h','i','\t',

        /*5*/ 'j','k','l','\t',

        /*6*/ 'm','n','o','\t',

        /*7*/ 'p','q','r','s','\t',

        /*8*/ 't','u','v','\t',

        /*9*/ 'w','x','y','z','\t',

        /***/ '+','\t',

        /*0*/ '0','\t',

        /*#*/ '#','\t',

        //upper case

        /*1*/ '.', '\t',

        /*2*/ 'A','B','C','\t',

        /*3*/ 'D','E','F','\t',

        /*4*/ 'G','H','I','\t',

        /*5*/ 'J','K','L','\t',

        /*6*/ 'M','N','O','\t',

        /*7*/ 'P','Q','R','S','\t',

        /*8*/ 'T','U','V','\t',

        /*9*/ 'W','X','Y','Z','\t',

        /***/ '-','\t',

        /*0*/ ' ','\t',

        /*#*/ '^',

        '\0'    //string terminator

    };

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

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

// Symbian 2nd static Constructor

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

//

CBCTestKeymap* CBCTestKeymap::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ default constructor

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

//

CBCTestKeymap::CBCTestKeymap():iMap(NULL)

    {    

    }

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

// Destructor

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

//

CBCTestKeymap::~CBCTestKeymap()

    {

    Teardown();

    }

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

// Symbian 2nd Constructor

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

//

void CBCTestKeymap::ConstructL()

    {    

    BuildScriptL();    

    }

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

// CBCTestKeymap::BuildScriptL

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

//

void CBCTestKeymap::BuildScriptL()

    { 

    // Add script as your need.   

    AddTestL( LeftCBA, 

        REP(Down, 2),

        KeyOK, TEND );    

    }

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

// CBCTestKeymap::RunL

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

//

void CBCTestKeymap::RunL( TInt aCmd )

    {

    if ( aCmd != EBCTestCmdPtiKeymap)

        {

        return;

        }

    TestFunctionL();

    }

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

// CBCTestKeymap::TestLayoutDecorator

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

//    

void CBCTestKeymap::TestFunctionL()

    {

    SetupL();

    TestCreateL();

    if ( iMap )

    	{

        TestMapping();

        TestReplaceMappingL();

        TestReverseMapping();

        TestKeyData();

    	}

    }

void CBCTestKeymap::SetupL()

    {

    TRAPD(err, iMap = static_cast<CPtiKeyMappings*>(CreateKeyMapL()));

    if(err == KErrCorrupt)

        {

        AssertTrueL(ETrue, _L("data format err"));

        }

    else

        {

        AssertNotNullL(iMap, _L("created by NewL from descriptor"));

        }

    }

void CBCTestKeymap::Teardown()

    {

    delete iMap;

	iMap = NULL;

    }

void CBCTestKeymap::TestCreateL()

    {

    //raw data format:

    //

    // #map //=2*KPtiNumKeys*sizeof(TPtiKeyMapping) = 2*12*(2*sizeof(int))

    // {index, chars}, {index, chars}, ... , {index, chars} //lower case

    // {INDEX, CHARS}, {INDEX, CHARS}, ... , {INDEX, CHARS} //upper case

    //

    // #chars

    // char1, char2, ... , charN

    //

    TInt16 charBuffer[1+(KPtiNumKeys*2)*2+1+sizeof(Keys)/sizeof(TUint16)];

    RArray<TPtiKeyMapping> maps;

    for (TInt i = 0; i < KPtiNumKeys * 2; i++)

        {

        TPtiKeyMapping map = {0, 0};

        maps.AppendL( map );

        }

    TInt16* ptr = charBuffer+1+maps.Count()*2+1;

    TInt curKey=0;

    TInt index=0;

    for (TInt i = 0; i < sizeof(Keys)/sizeof(TUint16)-1; ++i)

        {

        if (Keys[i] == '\t')

            {

            maps[++curKey].iIndex = index;

            continue;

            }

        *(ptr+index)= Keys[i];

        index++;

        maps[curKey].iNumChars++;

        }

    charBuffer[0]=maps.Count();

    ptr=charBuffer+1;

    for(TInt i=0; i<maps.Count(); ++i)

        {

        *ptr=maps[i].iIndex;

        ptr++;

        *ptr=maps[i].iNumChars;

        ptr++;

        }

    *ptr=index;

    maps.Close();

    Teardown();

    TRAPD(err, iMap = CPtiKeyMappings::NewL(charBuffer));

    if(err == KErrCorrupt)

        {

        AssertTrueL(ETrue, _L("data format err"));

        }

    else if (KErrNotSupported == err )

    	{

    	iMap = NULL;

    	AssertTrueL(ETrue, _L("data format err for not support"));

    	}

    else

        {

        AssertNotNullL(iMap, _L("created by NewL from raw data"));

        }   

    }

void CBCTestKeymap::TestMapping()

    {

    TestStartMapping();

    TestNextKey();

    }

void CBCTestKeymap::TestStartMapping()

    {

    AssertIntL(

        TUint('a'), iMap->StartMapping(/*TPtiKey::*/EPtiKey2, /*TPtiTextCase::*/EPtiCaseLower),

        _L("press 2 got 'a'"));

    AssertIntL(

        TUint('A'), iMap->StartMapping(/*TPtiKey::*/EPtiKey2, /*TPtiTextCase::*/EPtiCaseUpper),

        _L("press Shift 2 got 'A'"));

    }

void CBCTestKeymap::TestNextKey()

    {

    TBool isAppend = ETrue;

    iMap->StartMapping(EPtiKey3, EPtiCaseLower);

    AssertIntL( TUint16('e'), iMap->NextKey(EPtiKey3, isAppend, EPtiCaseLower),

        _L("press 3, press 3 got 'e'"));

    AssertTrueL( !isAppend, _L("and 'e' is not append"));

    AssertIntL( TUint16('F'), iMap->NextKey(EPtiKey3, isAppend, EPtiCaseUpper),

        _L("then, press Shift 3 got 'F'"));

    AssertIntL( TUint16('g'), iMap->NextKey(EPtiKey4, isAppend, EPtiCaseLower),

        _L("then press 4 as next key, got 'g'"));

    }

void CBCTestKeymap::TestReplaceMappingL()

    {

    TBool isAppend = ETrue;

    _LIT(KNewMapLower, "!@#$");

    _LIT(KNewMapUpper, "%:=&");

    TBuf<5> lowerMap(KNewMapLower);

    TBuf<5> upperMap(KNewMapUpper);

    AssertIntL( KErrNone, iMap->ReplaceKeyMapL(EPtiKey1, lowerMap, EPtiCaseLower),

        _L("Lower case mapping for Key 1 change to !@#$"));

    AssertIntL( KErrNone, iMap->ReplaceKeyMapL(EPtiKey1, upperMap, EPtiCaseUpper),

        _L("Upper case mapping for Key 1 change to %:=&"));

    AssertIntL( TUint('!'), iMap->StartMapping(EPtiKey1, EPtiCaseLower),

        _L("press 1 got '!'"));

    AssertIntL( TUint16('@'), iMap->NextKey(EPtiKey1, isAppend, EPtiCaseLower),

        _L("press 1, again got '@'"));

    AssertIntL( TUint16('='), iMap->NextKey(EPtiKey1, isAppend, EPtiCaseUpper),

        _L("then, press Shift 1 got '@'"));

    AssertIntL( TUint16('a'), iMap->NextKey(EPtiKey2, isAppend, EPtiCaseLower),

        _L("then press 2 as next key, got 'a'"));

    }

void CBCTestKeymap::TestReverseMapping()

    {

    AssertIntL( EPtiKey2, iMap->KeyForCharacter('c'), 

        _L("'c' is mapped by key 2"));

    AssertIntL( EPtiKey9, iMap->KeyForCharacter('X'),

        _L("'X' is mapped by key 9"));

    }

void CBCTestKeymap::TestKeyData()

    {

    TBuf<8> mapStr;

    iMap->GetDataForKey(EPtiKey1, mapStr, EPtiCaseLower);

    AssertTrueL( ETrue, _L("Lower case data for key 1 is !@#$"));

    iMap->GetDataForKey(EPtiKey1, mapStr, EPtiCaseUpper);

    AssertTrueL( ETrue, _L("Upper case data for key 1 is %:=&"));

    }

//static

MPtiKeyMappings* CBCTestKeymap::CreateKeyMapL()

    {

    TBuf<sizeof(Keys)/sizeof(TUint16)> keyStr(Keys);

    return CPtiKeyMappings::NewL(keyStr);

    }