diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/tsrc/bc/S60_SDK3.0/bctestptieng/src/bctestptiengine.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/tsrc/bc/S60_SDK3.0/bctestptieng/src/bctestptiengine.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,754 @@
+/*
+* 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 <ptiengine.h>
+#include <ptiuids.hrh>
+#include <ptidefs.h>
+#include <badesca.h>
+#include <ptiuserdicentry.h>
+
+#include "BCTestPtiEngine.h"
+#include "BCTestPtiEngcontainer.h"
+#include "BCTestPtiEng.hrh"
+#include "streamlogger.h"
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Symbian 2nd static Constructor
+// ---------------------------------------------------------------------------
+//
+CBCTestPtiEngine* CBCTestPtiEngine::NewL()
+    {
+    CBCTestPtiEngine* self = new( ELeave ) CBCTestPtiEngine();
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// C++ default constructor
+// ---------------------------------------------------------------------------
+//
+CBCTestPtiEngine::CBCTestPtiEngine():iEngine(NULL)
+    {
+    }
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CBCTestPtiEngine::~CBCTestPtiEngine()
+    {
+    Teardown();
+    }
+
+// ---------------------------------------------------------------------------
+// Symbian 2nd Constructor
+// ---------------------------------------------------------------------------
+//
+void CBCTestPtiEngine::ConstructL()
+    {
+    BuildScriptL();
+    }
+
+// ---------------------------------------------------------------------------
+// CBCTestPtiEngine::BuildScriptL
+// ---------------------------------------------------------------------------
+//
+void CBCTestPtiEngine::BuildScriptL()
+    {
+    // Add script as your need.
+    AddTestL( LeftCBA,
+        REP(Down, 5),
+        KeyOK, TEND );
+    }
+
+// ---------------------------------------------------------------------------
+// CBCTestPtiEngine::RunL
+// ---------------------------------------------------------------------------
+//
+void CBCTestPtiEngine::RunL( TInt aCmd )
+    {
+    if ( aCmd != EBCTestCmdPtiEng)
+        {
+        return;
+        }
+
+    TestFunctionL();
+    }
+
+// ---------------------------------------------------------------------------
+// CBCTestPtiEngine::TestLayoutDecorator
+// ---------------------------------------------------------------------------
+//
+void CBCTestPtiEngine::TestFunctionL()
+    {
+    SetupL();
+    TestLanguageL();
+    TestInfoL();
+    TestInputL();
+    TestJapaneseInputL();
+    TestChineseInputL();
+    //TestDictL();
+    TestOtherL();
+    }
+
+
+void CBCTestPtiEngine::SetupL()
+    {
+    iEngine = CPtiEngine::NewL();
+    AssertNotNullL(iEngine, _L("pti engine created"));
+    }
+
+void CBCTestPtiEngine::Teardown()
+    {
+    if(iEngine)
+        iEngine->CloseCurrentLanguageL();
+    delete iEngine;
+    iEngine=NULL;
+    }
+
+void CBCTestPtiEngine::TestLanguageL()
+    {
+    CArrayFixFlat<TInt>* langs = new (ELeave) CArrayFixFlat<TInt>(100);
+    CleanupStack::PushL(langs);
+    iEngine->GetAvailableLanguagesL(langs);
+
+    AssertTrueL(langs->Count()>0, _L("available languages got"));
+    CleanupStack::PopAndDestroy( 1 ); // cores, langs
+
+    RArray<TInt> langRefs;
+    iEngine->GetAvailableLanguagesL(langRefs);
+    AssertTrueL(langRefs.Count()>0, _L("available languages got into RArray"));
+
+    //
+    //activate
+    //
+    if(langRefs.Count())
+        {
+        MPtiLanguage *lan = iEngine->GetLanguage(langRefs[0]);
+        if (lan->HasInputMode(EPtiEngineMultitapping))
+            {
+            iEngine->ActivateLanguageL(lan->LanguageCode(), EPtiEngineMultitapping);
+            AssertTrueL( ETrue, _L("activate multitapping"));
+            }
+        else
+            {
+            iEngine->ActivateLanguageL(lan->LanguageCode(), EPtiEnginePredictive);
+            AssertTrueL( ETrue, _L("activate predictive"));
+            }
+        }
+
+    langRefs.Close();
+    }
+
+
+void CBCTestPtiEngine::TestInfoL()
+    {
+    TBuf<16> msg;
+    msg.Format(_L("num of lan: %d"), iEngine->NumberOfLanguages());
+    msg.ZeroTerminate();
+    AssertTrueL(iEngine->NumberOfLanguages()>0, msg);
+
+    if (iEngine->InputMode() == EPtiEngineMultitapping)
+        {
+        AssertTrueL(ETrue, _L("input mode is Multitapping"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("input mode is Predictive"));
+        }
+
+    // localized language name
+    TFileName localName;
+    iEngine->GetLocalizedLanguageName(31, localName); //31 is chinese?
+    localName.ZeroTerminate();
+    AssertTrueL(ETrue, localName);
+
+    //observer
+    MPtiObserver* obs = iEngine->Observer();
+    AssertTrueL(ETrue, _L("observer got"));
+    iEngine->SetObserver(obs);
+    AssertTrueL(ETrue, _L("observer set"));
+    }
+
+void CBCTestPtiEngine::TestInputL()
+    {
+    TestInputModeL();
+    TestMultitappingL();
+    TestPredictL();
+    TestLastKeyL();
+    TestNavigationL();
+    TestReorderingL();
+    }
+
+void CBCTestPtiEngine::TestMultitappingL()
+    {
+    //multitapping
+    iEngine->ActivateLanguageL(ELangEnglish, EPtiEngineMultitapping);
+    iEngine->AppendKeyPress(EPtiKey3);
+    iEngine->AppendKeyPress(EPtiKey6);
+    iEngine->AppendKeyPress(EPtiKey6);
+    iEngine->AppendKeyPress(EPtiKey6);
+    iEngine->AppendKeyPress(EPtiKey4);
+    _LIT(KDog, "dog");
+    AssertTrueL( iEngine->CurrentWord()==KDog, _L("multityping input verified"));
+
+    // commit
+    AssertIntL(KErrNone, iEngine->CommitCurrentWord(),
+        _L("Tell engine that current word was accepted"));
+
+    // set external key map
+    TInt ret(0);
+    TBuf<5> testLit;
+    testLit.Copy(_L("abcd"));
+    TRAPD(err, ret = iEngine->SetExternalKeyMapL(EPtiEngineMultitapping, EPtiKey5,
+                                                testLit, EPtiCaseUpper));
+    if ((ret == KErrNone) || (err != KErrNone))
+        {
+        AssertTrueL(ETrue, _L("set external key map failure"));
+        }
+    AssertTrueL(ETrue, _L("external key map set"));
+    }
+
+static void SimuInput(CPtiEngine* aEngine, const TDesC& aKeys)
+    {
+    for(int i=0; i<aKeys.Length(); ++i)
+        {
+        if (aKeys[i] == ' ')
+            {
+            continue;
+            }
+        else if (aKeys[i] == 'p')
+            {
+            continue;
+            }
+        else if (aKeys[i] == 'd')
+            {
+            aEngine->DeleteKeyPress();
+            }
+        else
+            {
+            aEngine->AppendKeyPress(aEngine->CharacterToKey(aKeys[i]));
+            }
+        }
+    }
+
+void CBCTestPtiEngine::TestPredictL()
+    {
+    //predictive
+    iEngine->ActivateLanguageL(ELangEnglish, EPtiEnginePredictive);
+    SimuInput(iEngine, _L("this"));
+
+    TBuf<256> msg=_L("current word is: ");
+    msg.Append(iEngine->CurrentWord());  //may be "this"
+    msg.ZeroTerminate();
+    AssertTrueL( ETrue, msg);
+
+    // next
+    msg=_L("next word is: ");
+    msg.Append(iEngine->NextCandidate()); // Move on to next candidate.
+    msg.ZeroTerminate();
+    AssertTrueL( ETrue, msg);
+    iEngine->CommitCurrentWord();
+
+    // delete
+    SimuInput(iEngine, _L("8447"));
+    msg = _L("current word after del is: ");
+    msg.Append(iEngine->DeleteKeyPress());
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    // reject
+    iEngine->ClearCurrentWord();
+    AssertTrueL(ETrue, _L("reject current word"));
+
+    // char2key
+    AssertIntL(EPtiKey7, iEngine->CharacterToKey('s'), _L("char 's' map to key 7"));
+
+    // candidate list
+    iEngine->ClearCurrentWord();
+    CDesCArray* cands = new (ELeave) CDesCArrayFlat(16);
+    CleanupStack::PushL(cands);
+
+    SimuInput(iEngine, _L("8447"));
+    iEngine->GetCandidateListL(*cands);
+    msg=_L("candidates: ");
+    for (int i = 0; i < cands->Count(); ++i)
+        {
+        msg.Append(cands->MdcaPoint(i));
+        msg.Append(_L(", "));
+        }
+    msg.ZeroTerminate();
+    AssertIntL(cands->Count(), iEngine->NumberOfCandidates(), msg);
+    CleanupStack::PopAndDestroy();  // cands
+
+    // set current word
+    iEngine->SetCurrentWord(_L("dog"));
+    SimuInput(iEngine, _L("t"));
+    msg=_L("dog+t change to: ");
+    msg.Append(iEngine->CurrentWord());
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+    }
+
+void CBCTestPtiEngine::TestInputModeL()
+    {
+    AssertIntL(iEngine->SetInputMode(EPtiEngineMultitapping), KErrNone,
+        _L("set input mode to multitapping"));
+    AssertIntL(iEngine->SetInputMode(EPtiEnginePredictive), KErrNone,
+        _L("set input mode to predictive"));
+    AssertIntL(iEngine->SetInputMode(EPtiEngineNumeric), KErrNone,
+        _L("set input mode to numeric"));
+
+    // set case
+    iEngine->SetCase(EPtiCaseUpper);
+    AssertIntL(EPtiCaseUpper, iEngine->Case(), _L("upper case set"));
+
+    iEngine->SetCase(EPtiCaseLower);
+    AssertIntL(EPtiCaseLower, iEngine->Case(), _L("lower case set"));
+    }
+
+void CBCTestPtiEngine::TestDictL()
+    {
+    CDesCArrayFlat* words = new (ELeave) CDesCArrayFlat(5);
+    CleanupStack::PushL( words );
+    words->AppendL(_L("lorem"));
+    words->AppendL(_L("ipsum"));
+    words->AppendL(_L("dolor"));
+    words->AppendL(_L("sit"));
+    words->AppendL(_L("amet"));
+
+    TBuf<50> filename(_L("C:\\BCTestLog\\TestUserDict.txt"));
+    AssertIntL(KErrNotSupported,
+        iEngine->CreateUserDictionaryL(filename, words, EPtiEngineWordCompletion),
+        _L("user dict created isn't supported"));
+
+    CleanupStack::PopAndDestroy();  //words
+
+
+	TInt err;
+    //attach
+    MPtiUserDictionary* dict = iEngine->AttachUserDictionaryL(filename);
+    if(dict)
+        {
+        AssertTrueL(ETrue, _L("user dict attached"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("user dict attached failure"));
+        }
+
+    //detach
+    if(iEngine->DetachUserDictionary(filename) == KErrNone)
+        {
+        AssertTrueL(ETrue, _L("user dict detach"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("User dict detach failure"));
+        }
+
+    if(iEngine->DetachUserDictionary(0) == KErrNone)
+        {
+        AssertTrueL(ETrue, _L("user dict detach by ID"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("User dict detach by ID failure"));
+        }
+
+    //entry
+    TFileName msg;
+    TPtiUserDictionaryEntry entry(_L("foobar"));
+
+    TInt number = iEngine->NumberOfEntriesInUserDictionary();
+    if(number == KErrNotSupported)
+        {
+        AssertTrueL(ETrue, _L("user dict doesn't support entry"));
+        }
+    else
+        {
+        msg.Format(_L("total %d entries"), number);
+        AssertTrueL(ETrue, msg);
+        }
+
+    err=iEngine->AddUserDictionaryEntry(entry);
+    msg.Format(_L("add entry returns: %d"), err);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    err=iEngine->AddUserDictionaryEntry(entry, 0);
+    msg.Format(_L("add entry with ID 0 returns: %d"), err);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    err=iEngine->RemoveEntryFromUserDictionary(entry);
+    msg.Format(_L("remove entry returns: %d"), err);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    err=iEngine->RemoveEntryFromUserDictionary(entry, 0);
+    msg.Format(_L("remove entry with ID 0 returns: %d"), err);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    err = iEngine->GetUserDictionaryEntry(0, entry);
+    msg.Format(_L("get first entry returns: %d"), err);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    dict = iEngine->DefaultUserDictionary(EPtiEnginePinyin);
+    if(dict)
+        {
+        AssertNotNullL(dict, _L("dict for Pinyin found"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("dict for Pinyin not found"));
+        }
+    }
+
+void CBCTestPtiEngine::TestLastKeyL()
+    {
+    iEngine->ClearCurrentWord();
+    AssertIntL(EPtiKeyNone, iEngine->LastEnteredKey(), _L("none last entered key"));
+
+    SimuInput(iEngine, _L("dog"));
+    AssertIntL(EPtiKeyGHI, iEngine->LastEnteredKey(), _L("last key for 'dog' is GHI"));
+    }
+
+void CBCTestPtiEngine::TestNavigationL()
+    {
+    iEngine->ClearCurrentWord();
+    SimuInput(iEngine, _L("46873"));
+
+    CDesCArray* cands = new (ELeave) CDesCArrayFlat(16);
+    CleanupStack::PushL(cands);
+
+    iEngine->GetCandidateListL(*cands);
+
+    if (cands->Count() == 0)
+    	{
+    	CleanupStack::PopAndDestroy(); // cands
+    	AssertTrueL(ETrue, _L("cands->Count() =0 return"));
+    	return;
+    	}
+
+    AssertIntL(0, iEngine->FirstCandidate().Compare(cands->MdcaPoint(0)),
+        _L("First candidate verified"));
+
+    for (int i = 1; i < cands->Count(); ++i)
+        {
+        AssertIntL(0, iEngine->NextCandidate().Compare(cands->MdcaPoint(i)),
+            _L("next candidate verified"));
+        }
+
+    for (int i = cands->Count() - 2; i >= 0; --i)
+        {
+        AssertIntL(0, iEngine->PreviousCandidate().Compare(cands->MdcaPoint(i)),
+            _L("Previous candidate verified"));
+        }
+
+    CleanupStack::PopAndDestroy(); // cands
+    }
+
+void CBCTestPtiEngine::TestReorderingL()
+    {
+    TInt err=iEngine->SetReordering(ETrue);
+    if(err == KErrNone)
+        {
+        AssertIntL(KErrNone, err, _L("set reordering"));
+        iEngine->ClearCurrentWord();
+        SimuInput(iEngine, _L("364"));
+
+        // get the third candidate
+        TBuf<64> word;
+        iEngine->NextCandidate();
+        iEngine->NextCandidate();
+        word.Copy(iEngine->NextCandidate());
+
+        // comit it 4 times
+        for(int i=0; i<4; ++i)
+            {
+            iEngine->SetCurrentWord(word);
+            iEngine->CommitCurrentWord();
+            }
+        SimuInput(iEngine, _L("364"));
+        AssertIntL(0, iEngine->CurrentWord().Compare(word),
+            _L("reordered candidate verified"));
+        iEngine->SetReordering(EFalse);
+        }
+    else
+        {
+        AssertIntL(KErrNotSupported, err,
+            _L("set reordering isn't supported"));
+        }
+    }
+
+CPtiEngine* CreateEngineL(TInt aLanguage, TPtiEngineInputMode aMode)
+    {
+    CPtiEngine* engine = CPtiEngine::NewL();
+    MPtiLanguage* lang = engine->GetLanguage(aLanguage);
+
+    TBuf<100> numStr;
+
+    if (!lang)
+        {
+        goto fail;
+        }
+
+    if (!lang->HasInputMode(aMode))
+        {
+        goto fail;
+        }
+
+    TInt err = engine->ActivateLanguageL(aLanguage, aMode);
+    if (err != KErrNone)
+        {
+        goto fail;
+        }
+
+    return engine;
+
+fail:
+    delete engine;
+    return NULL;
+    }
+
+void CBCTestPtiEngine::TestChineseInputL()
+    {
+    Teardown();
+
+    if((iEngine = CreateEngineL(ELangPrcChinese, EPtiEngineStroke))!=NULL)
+        {
+        AssertNotNullL(iEngine, _L("Chinese Pinyin activated"));
+        SimuInput(iEngine, _L("wei"));
+
+        int page=0;
+        iEngine->SetCandidatePageLength(20);
+        AssertTrueL(ETrue, _L("page length set to 20"));
+        for(TPtrC str=iEngine->CandidatePage();
+                iEngine->MoreCandidatePages();
+                iEngine->NextCandidatePage())
+            {
+            TFileName res;
+            res.Format(_L("page[%d]: "), page++);
+            for(int j=0; j<str.Length(); ++j)
+                {
+                res.Append(_L("<"));
+                res.AppendNumUC(str[j], EHex);
+                res.Append(_L(">"));
+                }
+            res.ZeroTerminate();
+            AssertTrueL(ETrue, res);
+
+            if(page>10)
+                {
+                break;
+                }
+            }//end of for
+
+        //predict
+        iEngine->PreviousCandidatePage();
+        TPtrC aChar=iEngine->CandidatePage();
+        iEngine->SetPredictiveChineseChar(aChar);
+        AssertTrueL(ETrue, _L("next chinese char predicted"));
+
+        //test next candidate list
+        iEngine->CommitCurrentWord();
+        CDesCArray* cands = new (ELeave) CDesCArrayFlat(16);
+        CleanupStack::PushL(cands);
+
+        TRAPD(err, iEngine->GetNextWordCandidateListL(*cands));
+        if(err == KErrNotSupported)
+            {
+            AssertTrueL(ETrue, _L("predict next candidate not supported"));
+            }
+        else{
+            TFileName msg=_L("candidates: ");
+            for (int i = 0; i < cands->Count(); ++i)
+            {
+                msg.Append(cands->MdcaPoint(i));
+                msg.Append(_L(", "));
+            }
+            msg.ZeroTerminate();
+            AssertTrueL(ETrue, msg);
+            }
+        CleanupStack::PopAndDestroy();  // cands
+
+        //test conversion
+        TInt convCap=iEngine->AvailableCharConversions();
+        if((convCap & EPtiSimplifiedToComplex)!=0)
+            {
+            AssertTrueL(ETrue, _L("can convert from simplified chinese to traditional"));
+            }
+        else
+            {
+            AssertIntL(0, convCap, _L("conv capability:"));
+            }
+        char inbuf[]={0x76, 0x84};
+        char outbuf[]={0,0};
+        iEngine->CharConversion(EPtiSimplifiedToComplex, inbuf, 2, outbuf);
+        AssertTrueL(ETrue, _L("tried char conversion"));
+
+        //Chinese Varient
+        RArray<TInt> modes;
+        iEngine->GetModeNameIndexL(EPtiChineseVariantPrc, modes);
+        AssertTrueL(ETrue, _L("Chinese varient index table got"));
+        modes.Close();
+
+        //phrase list
+        iEngine->ClearCurrentWord();
+        SimuInput(iEngine, _L("wei"));
+        cands = new (ELeave) CDesCArrayFlat(16);
+        CleanupStack::PushL(cands);
+        iEngine->GetChinesePhraseCandidatesL(*cands);
+        AssertTrueL(ETrue, _L("Chinese phrase candidate list got"));
+        CleanupStack::PopAndDestroy();  //cands
+
+        TestSpellL();
+        TestDictL();// test Pinyin dict.
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("unable to activate Chinese Pinyin"));
+        if ( iEngine == NULL )
+            {
+            SetupL();
+            } 
+        iEngine->ActivateLanguageL(ELangEnglish, EPtiEnginePredictive);
+        }
+    }
+
+void CBCTestPtiEngine::TestSpellL()
+    {
+    TBuf<8> spell;
+    TInt err=iEngine->GetSpelling(0x7684, spell, EPtiPinyin);
+    if(err==KErrNotSupported)
+        {
+        AssertTrueL(ETrue, _L("get spelling not support"));
+        }
+    else if(err==KErrNone)
+        {
+        spell.ZeroTerminate();
+        AssertTrueL(ETrue, spell);
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("get spelling failuer"));
+        }
+
+    //phonetic
+    iEngine->ClearCurrentWord();
+    SimuInput(iEngine, _L("wei"));
+    TInt number = iEngine->PhoneticSpellingCount();
+    TFileName msg;
+    msg.Format(_L("phonetic spelling count: %d"), number);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    spell=iEngine->GetPhoneticSpelling(0);
+    AssertTrueL(ETrue, _L("get phonetic spelling for 0"));
+
+    TBool result = iEngine->SelectPhoneticSpelling(0);
+    AssertTrueL(ETrue, _L("select phonetic spelling for 0"));
+
+    number = iEngine->SelectedPhoneticSpelling();
+    msg.Format(_L("selected phonetic spelling: %d"), number);
+    msg.ZeroTerminate();
+    AssertTrueL(ETrue, msg);
+
+    CDesCArray* array = new (ELeave) CDesCArrayFlat(16);
+    CleanupStack::PushL(array);
+    iEngine->GetPhoneticSpellingsL(*array);
+    AssertTrueL(ETrue, _L("phonetic spellings got"));
+    CleanupStack::PopAndDestroy();  //array
+    }
+
+void CBCTestPtiEngine::TestOtherL()
+    {
+    iEngine->HandleCommandL(EPtiCommandNone);
+    AssertTrueL(ETrue, _L("handle command"));
+
+    iEngine->EnableToneMarks(ETrue);
+    iEngine->EnableToneMarks(EFalse);
+    iEngine->ResetToneMark();
+    AssertTrueL(ETrue, _L("tone mark set and reset"));
+
+    TText result;
+    iEngine->ToneMark(result);
+    AssertTrueL(ETrue, _L("tone mark got"));
+
+    if(iEngine->IsToneMarkValidForSpelling())
+        AssertTrueL(ETrue, _L("tone mark is valid for spelling"));
+    else
+        AssertTrueL(ETrue, _L("tone mark is invalid for spelling"));
+
+    if(iEngine->IncrementToneMark(ETrue))
+        AssertTrueL(ETrue, _L("new tone mark was found and set"));
+    else
+        AssertTrueL(ETrue, _L("didn't found new tone mark"));
+
+    if(iEngine->SetToneMark(0))
+        AssertTrueL(ETrue, _L("tone mark was legal"));
+    else
+        AssertTrueL(ETrue, _L("illegal tone mark"));
+
+    //key mapping
+    TBuf<8> mapRes;
+    iEngine->MappingDataForKey(EPtiKey2, mapRes, EPtiCaseLower);
+    AssertTrueL(ETrue, _L("mapping data for key"));
+
+    RArray<TPtiNumericKeyBinding> qwertyMapRes;
+    iEngine->GetNumericModeKeysForQwertyL(ELangEnglish, qwertyMapRes);
+    AssertTrueL(ETrue, _L("get numeric mode keys for qwerty keys"));
+    qwertyMapRes.Close();
+    }
+
+void CBCTestPtiEngine::TestJapaneseInputL()
+    {
+    Teardown();
+
+    if((iEngine = CreateEngineL(ELangJapanese, /*EPtiEngineHiraganaKanji*/EPtiEnginePredictive))!=NULL)
+        {
+        AssertTrueL(ETrue, _L("Japanese Hirakana Kanji activated"));
+        }
+    else
+        {
+        AssertTrueL(ETrue, _L("can not activate Japanese input"));
+        if ( iEngine == NULL )
+            {
+            SetupL();
+            }        
+        iEngine->ActivateLanguageL(ELangEnglish, EPtiEnginePredictive);
+        }
+
+    MPtiEngineCompositionDataInterface* data=iEngine->CompositionData();
+    AssertTrueL(ETrue, _L("Japanese composition data IF got"));
+
+    SimuInput(iEngine, _L("nihon"));
+    TPtrC str=iEngine->ReadingTextL();
+    AssertTrueL(ETrue, _L("reading text for japanese input"));
+    iEngine->ClearCurrentWord();
+    }