automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19
  20 #include <stdlib.h>
  21 #include <limits>
  22
  23 #include <dali-toolkit-test-suite-utils.h>
  24 #include <dali-toolkit/dali-toolkit.h>
  25 #include <toolkit-text-utils.h>
  26 #include <dali/devel-api/events/key-event-devel.h>
  27 #include <dali-toolkit/internal/controls/text-controls/text-field-impl.h>
  28 #include <dali-toolkit/internal/text/text-controller.h>
  29 #include <dali-toolkit/internal/text/text-control-interface.h>
  30 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
  31 #include <dali-toolkit/internal/text/text-controller-impl.h>
  32
  33 using namespace Dali;
  34 using namespace Toolkit;
  35 using namespace Text;
  36
  37 namespace
  38 {
  39
  40 const char* const OPTION_SELECT_ALL("option-select_all");   // "Select All" popup option.
  41 const char* const OPTION_CUT("optionCut");                  // "Cut" popup option.
  42 const char* const OPTION_COPY("optionCopy");                // "Copy" popup option.
  43 const char* const OPTION_PASTE("optionPaste");              // "Paste" popup option.
  44 const char* const OPTION_CLIPBOARD("optionClipboard");      // "Clipboard" popup option.
  45
  46 const Size CONTROL_SIZE( 300.f, 60.f );
  47
  48 std::string gClipboardText;
  49 void ContentSelectedCallback( ClipboardEventNotifier& notifier )
  50 {
  51   gClipboardText = notifier.GetContent();
  52 }
  53
  54 // Generate a KeyEvent to send to Core.
  55 Dali::KeyEvent GenerateKey( const std::string& keyName,
  56                             const std::string& keyString,
  57                             int keyCode,
  58                             int keyModifier,
  59                             unsigned long timeStamp,
  60                             const Dali::KeyEvent::State& keyState )
  61 {
  62   return DevelKeyEvent::New( keyName, "", keyString, keyCode, keyModifier, timeStamp, keyState, "", "", Device::Class::NONE, Device::Subclass::NONE );
  63 }
  64
  65 } // namespace
  66
  67 int UtcDaliTextController(void)
  68 {
  69   tet_infoline(" UtcDaliTextController");
  70   ToolkitTestApplication application;
  71
  72   // Creates a text controller.
  73   ControllerPtr controller = Controller::New();
  74   DALI_TEST_CHECK( controller );
  75
  76   tet_result(TET_PASS);
  77   END_TEST;
  78 }
  79
  80 int UtcDaliTextControllerSetGetScrollEnabled(void)
  81 {
  82   tet_infoline(" UtcDaliTextControllerSetGetScrollEnabled");
  83   ToolkitTestApplication application;
  84
  85   // Creates a text controller.
  86   ControllerPtr controller = Controller::New();
  87   DALI_TEST_CHECK( controller );
  88
  89   // Configures the text controller similarly to the text-editor.
  90   ConfigureTextEditor( controller );
  91
  92   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
  93   DALI_TEST_CHECK( controller->IsVerticalScrollEnabled() );
  94
  95   // Configures the text controller similarly to the text-field.
  96   ConfigureTextField( controller );
  97
  98   DALI_TEST_CHECK( controller->IsHorizontalScrollEnabled() );
  99   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 100
 101   // Configures the text controller similarly to the text-label.
 102   ConfigureTextLabel( controller );
 103
 104   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
 105   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 106
 107   tet_result(TET_PASS);
 108   END_TEST;
 109 }
 110
 111 int UtcDaliTextControllerSetIsTextElide(void)
 112 {
 113   tet_infoline(" UtcDaliTextControllerSetIsTextElide");
 114   ToolkitTestApplication application;
 115
 116   // Creates a text controller.
 117   ControllerPtr controller = Controller::New();
 118   DALI_TEST_CHECK( controller );
 119
 120   // Configures the text controller similarly to the text-editor.
 121   ConfigureTextEditor( controller );
 122   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 123
 124   controller->SetTextElideEnabled( true );
 125   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 126
 127   // Configures the text controller similarly to the text-field.
 128   ConfigureTextField( controller );
 129   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 130
 131   controller->SetTextElideEnabled( true );
 132   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 133
 134   // Configures the text controller similarly to the text-label.
 135   ConfigureTextLabel( controller );
 136   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 137
 138   controller->SetTextElideEnabled( false );
 139   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 140
 141   tet_result(TET_PASS);
 142   END_TEST;
 143 }
 144
 145 int UtcDaliTextControllerEnableCursorBlinking(void)
 146 {
 147   tet_infoline(" UtcDaliTextControllerEnableCursorBlinking");
 148   ToolkitTestApplication application;
 149
 150   // Creates a text controller.
 151   ControllerPtr controller = Controller::New();
 152   DALI_TEST_CHECK( controller );
 153
 154   // There is no text input enabled.
 155   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 156
 157   // Enable the text input.
 158   // Creates a decorator.
 159   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 160                                                        *controller );
 161   InputMethodContext inputMethodContext = InputMethodContext::New();
 162   // Enables the text input.
 163   controller->EnableTextInput( decorator, inputMethodContext );
 164
 165   // Enables the cursor blink.
 166   controller->SetEnableCursorBlink( true );
 167
 168   DALI_TEST_CHECK( controller->GetEnableCursorBlink() );
 169
 170   // Disables the cursor blink.
 171   controller->SetEnableCursorBlink( false );
 172
 173   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 174
 175   tet_result(TET_PASS);
 176   END_TEST;
 177 }
 178
 179 int UtcDaliTextControllerImfEvent(void)
 180 {
 181   tet_infoline(" UtcDaliTextController");
 182   ToolkitTestApplication application;
 183
 184   // Creates a text controller.
 185   ControllerPtr controller = Controller::New();
 186
 187   std::string text;
 188   InputMethodContext::EventData imfEvent;
 189
 190   DALI_TEST_CHECK( controller );
 191
 192   // Enable the text input.
 193   // Creates a decorator.
 194   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 195                                                        *controller );
 196
 197   InputMethodContext inputMethodContext = InputMethodContext::New();
 198   // Enables the text input.
 199   controller->EnableTextInput( decorator, inputMethodContext );
 200
 201   // Set the placeholder text.
 202   controller->SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, "Hello Dali" );
 203
 204   // For coverage.
 205   imfEvent = InputMethodContext::EventData( InputMethodContext::GET_SURROUNDING, "", 0, 0 );
 206   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 207
 208   // Send VOID event.
 209   imfEvent = InputMethodContext::EventData( InputMethodContext::VOID, "", 0, 0 );
 210   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 211
 212   controller->GetText( text );
 213   DALI_TEST_CHECK( text.empty() );
 214
 215   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 216   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 217   controller->GetNaturalSize();
 218
 219   // Check 'Delete All' key which means the input panel send a big range
 220   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -100, 100 );
 221   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 222   controller->GetNaturalSize();
 223
 224   controller->GetText( text );
 225   DALI_TEST_EQUALS( "", text, TEST_LOCATION );
 226
 227   // Send COMMIT event.
 228   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 229   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 230
 231   // Force to update the model.
 232   controller->GetNaturalSize();
 233
 234   controller->GetText( text );
 235   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 236
 237   // Send PRE_EDIT event
 238   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 239   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 240
 241   // Force to update the model.
 242   controller->GetNaturalSize();
 243
 244   controller->GetText( text );
 245   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 246
 247   // Send DELETE_SURROUNDING event
 248   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -1, 1 );
 249   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 250
 251   // Force to update the model.
 252   controller->GetNaturalSize();
 253
 254   controller->GetText( text );
 255   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 256
 257   // for coverage
 258   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::UNDERLINE );
 259
 260   // Send PRE_EDIT event
 261   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "wo", 6, 2 );
 262   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 263
 264   // Force to update the model.
 265   controller->GetNaturalSize();
 266
 267   controller->GetText( text );
 268   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 269
 270   // Send GET_SURROUNDING event
 271   imfEvent = InputMethodContext::EventData( InputMethodContext::GET_SURROUNDING, "", 0, 0 );
 272   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 273
 274   controller->GetText( text );
 275   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 276
 277   // Send PRIVATE_COMMAND event
 278   imfEvent = InputMethodContext::EventData( InputMethodContext::PRIVATE_COMMAND, "", 0, 0 );
 279   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 280
 281   controller->GetText( text );
 282   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 283
 284   tet_result(TET_PASS);
 285   END_TEST;
 286 }
 287
 288 int UtcDaliTextControllerImfPreeditStyle(void)
 289 {
 290   tet_infoline(" UtcDaliTextControllerImfPreeditStyle");
 291   ToolkitTestApplication application;
 292
 293   // Creates a text controller.
 294   ControllerPtr controller = Controller::New();
 295
 296   std::string text;
 297   InputMethodContext::EventData imfEvent;
 298
 299   DALI_TEST_CHECK( controller );
 300
 301   // Configures the text controller similarly to the text-field.
 302   ConfigureTextField( controller );
 303
 304   InputMethodContext inputMethodContext = InputMethodContext::New();
 305
 306   // Send COMMIT event.
 307   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 308   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 309
 310   // Force to update the model.
 311   controller->GetNaturalSize();
 312
 313   controller->GetText( text );
 314   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 315
 316   // Send PRE_EDIT event
 317   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 318   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 319   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::NONE );
 320   controller->GetNaturalSize();
 321
 322   controller->GetText( text );
 323   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 324
 325   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 326   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 327
 328   // Set the preedit style as REVERSE
 329   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::REVERSE );
 330   controller->GetNaturalSize();
 331
 332   controller->GetText( text );
 333   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 334
 335   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 336   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 337
 338   // Set the preedit style as HIGHLIGHT
 339   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::HIGHLIGHT );
 340   controller->GetNaturalSize();
 341
 342   controller->GetText( text );
 343   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 344
 345   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 346   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 347
 348   // Set the preedit style as CUSTOM_PLATFORM_STYLE_1
 349   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_1 );
 350   controller->GetNaturalSize();
 351
 352   controller->GetText( text );
 353   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 354
 355   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 356   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 357
 358   // Set the preedit style as CUSTOM_PLATFORM_STYLE_2
 359   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_2 );
 360   controller->GetNaturalSize();
 361
 362   controller->GetText( text );
 363   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 364
 365   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 366   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 367
 368   // Set the preedit style as CUSTOM_PLATFORM_STYLE_3
 369   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_3 );
 370   controller->GetNaturalSize();
 371
 372   controller->GetText( text );
 373   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 374
 375   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 376   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 377
 378   // Set the preedit style as CUSTOM_PLATFORM_STYLE_4
 379   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_4 );
 380   controller->GetNaturalSize();
 381
 382   controller->GetText( text );
 383   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 384
 385   tet_result(TET_PASS);
 386   END_TEST;
 387 }
 388
 389 int UtcDaliTextControllerTextPopupButtonTouched(void)
 390 {
 391   tet_infoline(" UtcDaliTextControllerTextPopupButtonTouched");
 392   ToolkitTestApplication application;
 393
 394   // Creates a text controller.
 395   ControllerPtr controller = Controller::New();
 396
 397   DALI_TEST_CHECK( controller );
 398
 399   std::string text;
 400   PushButton button;
 401   Property::Map attributes;
 402
 403   // Enable the text input.
 404   // Creates a decorator.
 405   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 406                                                        *controller );
 407
 408   InputMethodContext inputMethodContext = InputMethodContext::New();
 409   // Enables the text input.
 410   controller->EnableTextInput( decorator, inputMethodContext );
 411
 412   // Creates the text's popup.
 413   TextSelectionPopupCallbackInterface& callbackInterface = *controller;
 414   TextSelectionPopup textPopup = TextSelectionPopup::New( &callbackInterface );
 415
 416   Toolkit::TextSelectionPopup::Buttons buttonsToEnable = static_cast<Toolkit::TextSelectionPopup::Buttons>( TextSelectionPopup::CUT        |
 417                                                                                                             TextSelectionPopup::COPY       |
 418                                                                                                             TextSelectionPopup::PASTE      |
 419                                                                                                             TextSelectionPopup::SELECT     |
 420                                                                                                             TextSelectionPopup::SELECT_ALL |
 421                                                                                                             TextSelectionPopup::CLIPBOARD );
 422
 423   textPopup.EnableButtons( buttonsToEnable );
 424   application.GetScene().Add( textPopup );
 425   textPopup.ShowPopup();
 426
 427   // Render and notify
 428   application.SendNotification();
 429   application.Render();
 430
 431   // Sets some text.
 432   controller->SetText( "Hello world" );
 433
 434   // Select the whole text.
 435   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 436   DALI_TEST_CHECK( button );
 437
 438   button.DoAction( "buttonClick", attributes );
 439
 440   // Call relayout to process the input events.
 441   controller->Relayout( CONTROL_SIZE );
 442
 443   // Cut the text.
 444   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 445   DALI_TEST_CHECK( button );
 446
 447   button.DoAction( "buttonClick", attributes );
 448
 449   // Force to update the model.
 450   controller->GetNaturalSize();
 451
 452   controller->GetText( text );
 453   DALI_TEST_CHECK( text.empty() );
 454
 455   // Set text again.
 456   controller->SetText( "Hello world" );
 457
 458   // Select the whole text.
 459   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 460   DALI_TEST_CHECK( button );
 461
 462   button.DoAction( "buttonClick", attributes );
 463
 464   // Call relayout to process the input events.
 465   controller->Relayout( CONTROL_SIZE );
 466
 467   // Copy to the clipboard.
 468   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_COPY ) );
 469   DALI_TEST_CHECK( button );
 470
 471   button.DoAction( "buttonClick", attributes );
 472
 473   // Call relayout to process the input events.
 474   controller->Relayout( CONTROL_SIZE );
 475
 476   // Cut the text.
 477   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 478   DALI_TEST_CHECK( button );
 479
 480   button.DoAction( "buttonClick", attributes );
 481
 482   // Force to update the model.
 483   controller->GetNaturalSize();
 484
 485   controller->GetText( text );
 486   DALI_TEST_CHECK( text.empty() );
 487
 488   ClipboardEventNotifier clipboardEventNotifier = ClipboardEventNotifier::Get();
 489   clipboardEventNotifier.ContentSelectedSignal().Connect( &ContentSelectedCallback );
 490
 491   // Paste the text.
 492   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_PASTE ) );
 493   DALI_TEST_CHECK( button );
 494
 495   button.DoAction( "buttonClick", attributes );
 496
 497   // Call relayout to process the input events.
 498   controller->Relayout( CONTROL_SIZE );
 499
 500   DALI_TEST_EQUALS( "Hello world", gClipboardText, TEST_LOCATION );
 501
 502   // Show the clipboard.
 503   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CLIPBOARD ) );
 504   DALI_TEST_CHECK( button );
 505
 506   button.DoAction( "buttonClick", attributes );
 507
 508   tet_result(TET_PASS);
 509   END_TEST;
 510 }
 511
 512 int UtcDaliTextControllerGetInputShadowProperty(void)
 513 {
 514   tet_infoline(" UtcDaliTextControllerGetInputShadowProperty");
 515   ToolkitTestApplication application;
 516
 517   // Creates a text controller.
 518   ControllerPtr controller = Controller::New();
 519
 520   DALI_TEST_CHECK( controller );
 521
 522   const std::string& shadowProperties = controller->GetInputShadowProperties();
 523
 524   DALI_TEST_CHECK( shadowProperties.empty() );
 525
 526   tet_result(TET_PASS);
 527   END_TEST;
 528 }
 529
 530 int UtcDaliTextControllerGetInputUnderlineProperty(void)
 531 {
 532   tet_infoline(" UtcDaliTextControllerGetInputUnderlineProperty");
 533   ToolkitTestApplication application;
 534
 535   // Creates a text controller.
 536   ControllerPtr controller = Controller::New();
 537
 538   DALI_TEST_CHECK( controller );
 539
 540   const std::string& underlineProperties = controller->GetInputUnderlineProperties();
 541
 542   DALI_TEST_CHECK( underlineProperties.empty() );
 543
 544   tet_result(TET_PASS);
 545   END_TEST;
 546 }
 547
 548 int UtcDaliTextControllerSetGetAutoScrollEnabled(void)
 549 {
 550   tet_infoline(" UtcDaliTextControllerSetGetAutoScrollEnabled");
 551   ToolkitTestApplication application;
 552
 553   // Creates a text controller.
 554   ControllerPtr controller = Controller::New();
 555
 556   DALI_TEST_CHECK( controller );
 557
 558   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 559
 560   // The auto scrolling shouldn't be enabled if the multi-line is enabled.
 561
 562   // Enable multi-line.
 563   controller->SetMultiLineEnabled( true );
 564
 565   // Enable text scrolling.
 566   controller->SetAutoScrollEnabled( true );
 567
 568   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 569
 570   // Disable multi-line.
 571   controller->SetMultiLineEnabled( false );
 572
 573   // Enable text scrolling.
 574   controller->SetAutoScrollEnabled( true );
 575
 576   // Should be ebabled now.
 577   DALI_TEST_CHECK( controller->IsAutoScrollEnabled() );
 578
 579   tet_result(TET_PASS);
 580   END_TEST;
 581 }
 582
 583 int UtcDaliTextControllerSetGetCheckProperty(void)
 584 {
 585   tet_infoline(" UtcDaliTextControllerSetGetCheckProperty");
 586   ToolkitTestApplication application;
 587
 588   // Creates a text controller.
 589   ControllerPtr controller = Controller::New();
 590
 591   DALI_TEST_CHECK( controller );
 592
 593   // Enable the text input.
 594   // Creates a decorator.
 595   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 596
 597   InputMethodContext inputMethodContext = InputMethodContext::New();
 598   // Enables the text input.
 599   controller->EnableTextInput( decorator, inputMethodContext );
 600
 601   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 602
 603   // Set the text input to password.
 604   controller->SetInputModePassword( true );
 605
 606   DALI_TEST_CHECK( controller->IsInputModePassword() );
 607
 608   // Unset the text input to password.
 609   controller->SetInputModePassword( false );
 610
 611   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 612
 613   tet_result(TET_PASS);
 614   END_TEST;
 615 }
 616
 617 int UtcDaliTextControllerSetGetTapLongPressAction(void)
 618 {
 619   tet_infoline(" UtcDaliTextControllerSetGetTapLongPressAction");
 620   ToolkitTestApplication application;
 621
 622   // Creates a text controller.
 623   ControllerPtr controller = Controller::New();
 624
 625   DALI_TEST_CHECK( controller );
 626
 627   // Test first with no decorator.
 628
 629   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 630   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 631   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 632
 633   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 634   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 635   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 636
 637   // Add a decorator and re-test.
 638
 639   // Creates a decorator.
 640   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 641
 642   InputMethodContext inputMethodContext = InputMethodContext::New();
 643   // Enables the text input.
 644   controller->EnableTextInput( decorator, inputMethodContext );
 645
 646   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 647   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 648   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 649
 650   DALI_TEST_EQUALS( Controller::NoTextTap::SHOW_SELECTION_POPUP, controller->GetNoTextLongPressAction(), TEST_LOCATION ); // The default is SHOW_SELECTION_POPUP
 651   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 652   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 653
 654   END_TEST;
 655 }
 656
 657 int UtcDaliTextControllerSetGetLineSpacingProperty(void)
 658 {
 659   tet_infoline(" UtcDaliTextControllerSetGetLineSpacingProperty");
 660   ToolkitTestApplication application;
 661
 662   const Size size( application.GetScene().GetSize() );
 663
 664   // single line text
 665   const std::string textSingle("A Quick Brown Fox Jumps Over The Lazy Dog");
 666
 667   // multi-line text
 668   const std::string textMulti("A Quick Brown\nFox Jumps Over\nThe Lazy Dog");
 669
 670   // Creates a text controller.
 671   ControllerPtr controller = Controller::New();
 672
 673   ConfigureTextLabel(controller);
 674
 675   // single line, line spacing = 0px
 676   {
 677     const float EXPECTED_SPACING = 0.0f;
 678     const Vector2 EXPECTED_LAYOUT_SIZE( 360.0f, 19.0f);
 679     const Vector3 EXPECTED_NATURAL_SIZE( 360.0f, 20.0f, 0.0f );
 680
 681     controller->SetText(textSingle);
 682     controller->Relayout(size);
 683     controller->SetMultiLineEnabled( false );
 684
 685     Vector3 naturalSize  = controller->GetNaturalSize();
 686     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 687     float lineSpacing0 = controller->GetDefaultLineSpacing();
 688
 689     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 690     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 691     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 692   }
 693
 694   // single line, line spacing = 20px
 695   {
 696     const float EXPECTED_SPACING = 20.0f;
 697     const Vector2 EXPECTED_LAYOUT_SIZE( 360.0f, 19.0f );
 698     const Vector3 EXPECTED_NATURAL_SIZE( 360.0f, 40.0f, 0.0f );
 699
 700     controller->SetText(textSingle);
 701     controller->Relayout(size);
 702     controller->SetDefaultLineSpacing( 20 );
 703     controller->SetMultiLineEnabled( false );
 704
 705     Vector3 naturalSize  = controller->GetNaturalSize();
 706     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 707     float lineSpacing0 = controller->GetDefaultLineSpacing();
 708
 709     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 710     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 711     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 712   }
 713
 714   // multi-line, line spacing = 0px
 715   {
 716     const float EXPECTED_SPACING = 0.0f;
 717     const Vector2 EXPECTED_LAYOUT_SIZE( 350.0f, 39.0f );
 718     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 58.0f, 0.0f );
 719
 720     controller->SetText(textMulti);
 721     controller->Relayout(size);
 722     controller->SetMultiLineEnabled( true );
 723     controller->SetDefaultLineSpacing( 0 );
 724
 725     Vector3 naturalSize  = controller->GetNaturalSize();
 726     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 727     float lineSpacing0 = controller->GetDefaultLineSpacing();
 728
 729     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 730     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 731     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 732   }
 733
 734   // multi-line, line spacing = 20px
 735   {
 736     const float EXPECTED_SPACING = 20.0f;
 737     const Vector2 EXPECTED_LAYOUT_SIZE( 124.0f, 57.0f );
 738     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 118.0f, 0.0f );
 739
 740     controller->SetText(textMulti);
 741     controller->Relayout(size);
 742     controller->SetMultiLineEnabled( true );
 743     controller->SetDefaultLineSpacing( 20 );
 744
 745     Vector3 naturalSize  = controller->GetNaturalSize();
 746     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 747     float lineSpacing0 = controller->GetDefaultLineSpacing();
 748
 749     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 750     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 751     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 752   }
 753
 754   // multi-line, line spacing = 30px
 755   {
 756     const float EXPECTED_SPACING = 30.0f;
 757     const Vector2 EXPECTED_LAYOUT_SIZE( 124.0f, 117.0f );
 758     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 148.0f, 0.0f );
 759
 760     controller->SetText(textMulti);
 761     controller->Relayout(size);
 762     controller->SetMultiLineEnabled( true );
 763     controller->SetDefaultLineSpacing( 30 );
 764
 765     Vector3 naturalSize  = controller->GetNaturalSize();
 766     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 767     float lineSpacing0 = controller->GetDefaultLineSpacing();
 768
 769     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 770     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 771     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 772   }
 773
 774
 775   END_TEST;
 776
 777 }
 778
 779 int UtcDaliTextControllerCheckBufferIndices(void)
 780 {
 781   tet_infoline(" UtcDaliTextControllerCheckBufferIndices");
 782   ToolkitTestApplication application;
 783
 784   // Creates a text controller.
 785   ControllerPtr controller = Controller::New();
 786
 787   ConfigureTextLabel(controller);
 788
 789   // Set the text
 790   const std::string text("A Quick Brown Fox Jumps Over The Lazy Dog");
 791   controller->SetText(text);
 792
 793   // Get the implementation of the text controller
 794   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 795
 796   // Tweak some parameters to make the indices to access the text buffer invalid
 797   mImpl.mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl.mModel->mLogicalModel->mText.Count() * 10u;
 798   mImpl.mTextUpdateInfo.mNumberOfCharactersToRemove = 0u;
 799   mImpl.mTextUpdateInfo.mPreviousNumberOfCharacters = 0u;
 800   mImpl.mOperationsPending = Controller::ALL_OPERATIONS;
 801
 802   // Perform a relayout
 803   const Size size( application.GetScene().GetSize() );
 804   controller->Relayout(size);
 805
 806   tet_result(TET_PASS);
 807
 808   END_TEST;
 809 }
 810
 811 int UtcDaliTextControllerCheckInputColorChanged(void)
 812 {
 813   tet_infoline(" UtcDaliTextControllerCheckInputColorChanged");
 814   ToolkitTestApplication application;
 815
 816   // Creates a text controller.
 817   ControllerPtr controller = Controller::New();
 818
 819   ConfigureTextLabel(controller);
 820
 821   // Enable the text input.
 822   // Creates a decorator.
 823   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 824                                                        *controller );
 825   InputMethodContext inputMethodContext = InputMethodContext::New();
 826   // Enables the text input.
 827   controller->EnableTextInput( decorator, inputMethodContext );
 828
 829   // Set the text
 830   const std::string text("Hello World!");
 831   controller->SetText(text);
 832
 833   const Vector4 inputColor( 0.0f, 0.0f, 0.0f, 1.0f );
 834   controller->SetInputColor( inputColor );
 835
 836   // Get the implementation of the text controller
 837   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 838
 839   //  Reset operation
 840   mImpl.mOperationsPending = Controller::NO_OPERATION;
 841
 842   // simulate a key event.
 843   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 844
 845   // change the input color
 846   const Vector4 newInputColor( 1.0f, 0.0f, 0.0f, 1.0f );
 847   controller->SetInputColor( newInputColor );
 848
 849   // Check if relayout is requested or not when event state is INACTIVE.
 850   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 851   DALI_TEST_EQUALS( Controller::COLOR, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::COLOR ), TEST_LOCATION );
 852
 853   // Perform a relayout
 854   const Size size( application.GetScene().GetSize() );
 855   controller->Relayout(size);
 856
 857   tet_result(TET_PASS);
 858
 859   END_TEST;
 860 }
 861
 862 int UtcDaliTextControllerCheckInputFontFamilyChanged(void)
 863 {
 864   tet_infoline(" UtcDaliTextControllerCheckInputFontFamilyChanged");
 865   ToolkitTestApplication application;
 866
 867   // Creates a text controller.
 868   ControllerPtr controller = Controller::New();
 869
 870   ConfigureTextLabel(controller);
 871
 872   // Enable the text input.
 873   // Creates a decorator.
 874   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 875                                                        *controller );
 876   InputMethodContext inputMethodContext = InputMethodContext::New();
 877   // Enables the text input.
 878   controller->EnableTextInput( decorator, inputMethodContext );
 879
 880   // Set the text and font family
 881   const std::string text("Hello World!");
 882   controller->SetText(text);
 883   controller->SetInputFontFamily("SamsungOneUI_200");
 884
 885   // Get the implementation of the text controller
 886   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 887
 888   //  Reset operation
 889   mImpl.mOperationsPending = Controller::NO_OPERATION;
 890
 891   // simulate a key event.
 892   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 893
 894   // change the input font family
 895   controller->SetInputFontFamily("SamsungOneUI_300");
 896
 897   // Check if relayout is requested or not when event state is INACTIVE.
 898   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 899   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 900                     TEST_LOCATION );
 901
 902   // Perform a relayout
 903   const Size size( application.GetScene().GetSize() );
 904   controller->Relayout(size);
 905
 906   tet_result(TET_PASS);
 907
 908   END_TEST;
 909 }
 910
 911 int UtcDaliTextControllerCheckInputFontWeightChanged(void)
 912 {
 913   tet_infoline(" UtcDaliTextControllerCheckInputFontWeightChanged");
 914   ToolkitTestApplication application;
 915
 916   // Creates a text controller.
 917   ControllerPtr controller = Controller::New();
 918
 919   ConfigureTextLabel(controller);
 920
 921   // Enable the text input.
 922   // Creates a decorator.
 923   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 924                                                        *controller );
 925   InputMethodContext inputMethodContext = InputMethodContext::New();
 926   // Enables the text input.
 927   controller->EnableTextInput( decorator, inputMethodContext );
 928
 929   // Set the text
 930   const std::string text("Hello World!");
 931   controller->SetText(text);
 932   controller->SetInputFontWeight( TextAbstraction::FontWeight::NORMAL );
 933
 934   // Get the implementation of the text controller
 935   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 936
 937   // Reset operation
 938   mImpl.mOperationsPending = Controller::NO_OPERATION;
 939
 940   // simulate a key event.
 941   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 942
 943   // change the input font weight
 944   controller->SetInputFontWeight( TextAbstraction::FontWeight::BOLD );
 945
 946   // Check if relayout is requested or not when event state is INACTIVE.
 947   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 948   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 949                     TEST_LOCATION );
 950
 951   // Perform a relayout
 952   const Size size( application.GetScene().GetSize() );
 953   controller->Relayout(size);
 954
 955   tet_result(TET_PASS);
 956
 957   END_TEST;
 958 }
 959
 960 int UtcDaliTextControllerCheckInputFontWidthChanged(void)
 961 {
 962   tet_infoline(" UtcDaliTextControllerCheckInputFontWidthChanged");
 963   ToolkitTestApplication application;
 964
 965   // Creates a text controller.
 966   ControllerPtr controller = Controller::New();
 967
 968   ConfigureTextLabel(controller);
 969
 970   // Enable the text input.
 971   // Creates a decorator.
 972   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 973                                                        *controller );
 974   InputMethodContext inputMethodContext = InputMethodContext::New();
 975   // Enables the text input.
 976   controller->EnableTextInput( decorator, inputMethodContext );
 977
 978   // Set the text
 979   const std::string text("Hello World!");
 980   controller->SetText(text);
 981   controller->SetInputFontWidth( TextAbstraction::FontWidth::NORMAL );
 982
 983   // Get the implementation of the text controller
 984   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 985
 986   // Reset operation
 987   mImpl.mOperationsPending = Controller::NO_OPERATION;
 988
 989   // simulate a key event.
 990   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 991
 992   // change the input font width
 993   controller->SetInputFontWidth( TextAbstraction::FontWidth::EXPANDED );
 994
 995   // Check if relayout is requested or not when event state is INACTIVE.
 996   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 997   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 998                     TEST_LOCATION );
 999
1000   // Perform a relayout
1001   const Size size( application.GetScene().GetSize() );
1002   controller->Relayout(size);
1003
1004   tet_result(TET_PASS);
1005
1006   END_TEST;
1007 }
1008
1009 int UtcDaliTextControllerCheckInputFontSlantChanged(void)
1010 {
1011   tet_infoline(" UtcDaliTextControllerCheckInputFontSlantChanged");
1012   ToolkitTestApplication application;
1013
1014   // Creates a text controller.
1015   ControllerPtr controller = Controller::New();
1016
1017   ConfigureTextLabel(controller);
1018
1019   // Enable the text input.
1020   // Creates a decorator.
1021   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
1022                                                        *controller );
1023   InputMethodContext inputMethodContext = InputMethodContext::New();
1024   // Enables the text input.
1025   controller->EnableTextInput( decorator, inputMethodContext );
1026
1027   // Set the text
1028   const std::string text("Hello World!");
1029   controller->SetText(text);
1030   controller->SetInputFontSlant( TextAbstraction::FontSlant::NORMAL );
1031
1032   // Get the implementation of the text controller
1033   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1034
1035   //  Reset operation
1036   mImpl.mOperationsPending = Controller::NO_OPERATION;
1037
1038   // simulate a key event.
1039   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
1040
1041   // change the input font slant
1042   controller->SetInputFontSlant( TextAbstraction::FontSlant::ROMAN );
1043
1044   // Check if relayout is requested or not when event state is INACTIVE.
1045   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1046   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
1047                     TEST_LOCATION );
1048
1049   // Perform a relayout
1050   const Size size( application.GetScene().GetSize() );
1051   controller->Relayout(size);
1052
1053   tet_result(TET_PASS);
1054
1055   END_TEST;
1056 }
1057
1058 int UtcDaliTextControllerCheckInputFontPointSizeChanged(void)
1059 {
1060   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeChanged");
1061   ToolkitTestApplication application;
1062
1063   // Creates a text controller.
1064   ControllerPtr controller = Controller::New();
1065
1066   ConfigureTextLabel(controller);
1067
1068   // Enable the text input.
1069   // Creates a decorator.
1070   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
1071                                                        *controller );
1072   InputMethodContext inputMethodContext = InputMethodContext::New();
1073   // Enables the text input.
1074   controller->EnableTextInput( decorator, inputMethodContext );
1075
1076   // Set the text
1077   const std::string text("Hello World!");
1078   controller->SetText(text);
1079   controller->SetInputFontPointSize( 1.0f );
1080
1081   // Get the implementation of the text controller
1082   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1083
1084   //  Reset operation
1085   mImpl.mOperationsPending = Controller::NO_OPERATION;
1086
1087   // simulate a key event.
1088   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
1089
1090   // change the input font point size
1091   controller->SetInputFontPointSize( 1.2f );
1092
1093   // Check if relayout is requested or not when event state is INACTIVE.
1094   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1095   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
1096                     TEST_LOCATION );
1097
1098   // Perform a relayout
1099   const Size size( application.GetScene().GetSize() );
1100   controller->Relayout(size);
1101
1102   tet_result(TET_PASS);
1103
1104   END_TEST;
1105 }
1106
1107 int UtcDaliTextControllerSelectEvent(void)
1108 {
1109   tet_infoline(" UtcDaliTextControllerSelectEvent");
1110   ToolkitTestApplication application;
1111
1112   // Creates a text controller.
1113   ControllerPtr controller = Controller::New();
1114
1115   // Configures the text controller similarly to the text-field.
1116   ConfigureTextField( controller );
1117
1118   // Set the text
1119   const std::string text("Hello World!");
1120   controller->SetText( text );
1121
1122   // Select the whole text.
1123   controller->SelectEvent( 0.f, 0.f, SelectionType::INTERACTIVE );
1124
1125   // Perform a relayout
1126   const Size size( application.GetScene().GetSize() );
1127   controller->Relayout(size);
1128
1129   // Get the implementation of the text controller
1130   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1131
1132   // Check if the whole text is selected or not.
1133   std::string retrieved_text;
1134   mImpl.RetrieveSelection( retrieved_text, false );
1135   DALI_TEST_EQUALS( "Hello", retrieved_text, TEST_LOCATION );
1136
1137   // Select the whole text.
1138   controller->SelectEvent( 0.f, 0.f, SelectionType::ALL );
1139
1140   // Perform a relayout
1141   controller->Relayout( size );
1142
1143   mImpl.RetrieveSelection( retrieved_text, false );
1144   DALI_TEST_EQUALS( text, retrieved_text, TEST_LOCATION );
1145
1146   END_TEST;
1147 }
1148
1149
1150 int UtcDaliTextControllerRemoveTextChangeEventData(void)
1151 {
1152   tet_infoline(" UtcDaliTextControllerRemoveTextChangeEventData");
1153   ToolkitTestApplication application;
1154
1155   // Creates a text controller.
1156   ControllerPtr controller = Controller::New();
1157
1158   ConfigureTextField( controller );
1159
1160   // Set the text
1161   const std::string text( "Hello World!" );
1162   controller->SetText( text );
1163   controller->SetInputFontPointSize( 1.0f );
1164
1165   // Get the implementation of the text controller
1166   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1167
1168   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1169
1170   // Send DELETE_SURROUNDING event
1171   InputMethodContext::EventData imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -1, 1 );
1172   InputMethodContext inputMethodContext = InputMethodContext::New();
1173   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1174
1175   // Force to update the model.
1176   controller->GetNaturalSize();
1177
1178   // Simulate a key event to delete text
1179   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Dali::KeyEvent::DOWN ) );
1180
1181   DALI_TEST_EQUALS( EventData::EDITING, mImpl.mEventData->mState, TEST_LOCATION );
1182
1183   // Perform a relayout
1184   const Size size( application.GetScene().GetSize() );
1185   controller->Relayout( size );
1186
1187   tet_result(TET_PASS);
1188
1189   END_TEST;
1190 }
1191
1192 int UtcDaliTextControllerCheckInputFontPointSizeUpdated(void)
1193 {
1194   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeUpdated");
1195   ToolkitTestApplication application;
1196
1197   // Creates a text controller.
1198   ControllerPtr controller = Controller::New();
1199
1200   ConfigureTextField(controller);
1201
1202   // Set the text
1203   const std::string text("Hello World!");
1204   controller->SetText( text );
1205   controller->SetInputFontPointSize( 1.0f );
1206   controller->KeyboardFocusGainEvent();
1207
1208   application.SendNotification();
1209   application.Render();
1210
1211   // Perform a relayout
1212   const Size size( application.GetScene().GetSize() );
1213   controller->Relayout(size);
1214
1215   // simulate a key event.
1216   controller->KeyEvent( GenerateKey( "a", "a", 38, 0, 0, Dali::KeyEvent::DOWN ) );
1217
1218   // change the input font point size
1219   controller->SetInputFontPointSize( 20.f );
1220
1221   application.SendNotification();
1222   application.Render();
1223
1224   // Perform a relayout
1225   controller->Relayout(size);
1226
1227   tet_result(TET_PASS);
1228
1229   END_TEST;
1230 }
1231
1232 int UtcDaliTextControllerDeleteSurroundings(void)
1233 {
1234   tet_infoline(" UtcDaliTextControllerDeleteSurroundings");
1235   ToolkitTestApplication application;
1236
1237   // Creates a text controller.
1238   ControllerPtr controller = Controller::New();
1239
1240   ConfigureTextField( controller );
1241
1242   // Get the implementation of the text controller
1243   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1244
1245   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1246
1247   InputMethodContext inputMethodContext = InputMethodContext::New();
1248   // Add some pre-edit text, such as Korean
1249   InputMethodContext::EventData imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "ㅂㅂㅂ", 0, 3 );
1250   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1251
1252   // Perform a relayout
1253   const Size size( application.GetScene().GetSize() );
1254
1255   application.SendNotification();
1256   application.Render();
1257
1258   controller->Relayout( size );
1259
1260   // Simulate a key event to delete one text
1261   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Dali::KeyEvent::DOWN ) );
1262
1263   // Send DELETE_SURROUNDING event (Delete All text)
1264   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -2, 2 );
1265   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1266
1267   application.SendNotification();
1268   application.Render();
1269
1270   controller->Relayout( size );
1271
1272   // simulate a key event to add text
1273   controller->KeyEvent( GenerateKey( "ㅇ", "ㅇ", 238, 0, 0, Dali::KeyEvent::DOWN ) );
1274   controller->KeyEvent( GenerateKey( "ㅇ", "ㅇ", 238, 0, 0, Dali::KeyEvent::DOWN ) );
1275
1276   DALI_TEST_EQUALS( EventData::EDITING, mImpl.mEventData->mState, TEST_LOCATION );
1277
1278   // Force to update the model.
1279   controller->GetNaturalSize();
1280
1281   application.SendNotification();
1282   application.Render();
1283
1284   controller->Relayout( size );
1285
1286   tet_result(TET_PASS);
1287
1288   END_TEST;
1289 }