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

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