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

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