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

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