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