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 UtcDaliTextControllerTextPopupButtonTouched(void)
 293 {
 294   tet_infoline(" UtcDaliTextControllerTextPopupButtonTouched");
 295   ToolkitTestApplication application;
 296
 297   // Creates a text controller.
 298   ControllerPtr controller = Controller::New();
 299
 300   DALI_TEST_CHECK( controller );
 301
 302   std::string text;
 303   PushButton button;
 304   Property::Map attributes;
 305
 306   // Enable the text input.
 307   // Creates a decorator.
 308   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 309                                                        *controller );
 310
 311   InputMethodContext inputMethodContext = InputMethodContext::New();
 312   // Enables the text input.
 313   controller->EnableTextInput( decorator, inputMethodContext );
 314
 315   // Creates the text's popup.
 316   TextSelectionPopupCallbackInterface& callbackInterface = *controller;
 317   TextSelectionPopup textPopup = TextSelectionPopup::New( &callbackInterface );
 318
 319   Toolkit::TextSelectionPopup::Buttons buttonsToEnable = static_cast<Toolkit::TextSelectionPopup::Buttons>( TextSelectionPopup::CUT        |
 320                                                                                                             TextSelectionPopup::COPY       |
 321                                                                                                             TextSelectionPopup::PASTE      |
 322                                                                                                             TextSelectionPopup::SELECT     |
 323                                                                                                             TextSelectionPopup::SELECT_ALL |
 324                                                                                                             TextSelectionPopup::CLIPBOARD );
 325
 326   textPopup.EnableButtons( buttonsToEnable );
 327   Stage::GetCurrent().Add( textPopup );
 328   textPopup.ShowPopup();
 329
 330   // Render and notify
 331   application.SendNotification();
 332   application.Render();
 333
 334   // Sets some text.
 335   controller->SetText( "Hello world" );
 336
 337   // Select the whole text.
 338   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 339   DALI_TEST_CHECK( button );
 340
 341   button.DoAction( "buttonClick", attributes );
 342
 343   // Call relayout to process the input events.
 344   controller->Relayout( CONTROL_SIZE );
 345
 346   // Cut the text.
 347   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 348   DALI_TEST_CHECK( button );
 349
 350   button.DoAction( "buttonClick", attributes );
 351
 352   // Force to update the model.
 353   controller->GetNaturalSize();
 354
 355   controller->GetText( text );
 356   DALI_TEST_CHECK( text.empty() );
 357
 358   // Set text again.
 359   controller->SetText( "Hello world" );
 360
 361   // Select the whole text.
 362   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 363   DALI_TEST_CHECK( button );
 364
 365   button.DoAction( "buttonClick", attributes );
 366
 367   // Call relayout to process the input events.
 368   controller->Relayout( CONTROL_SIZE );
 369
 370   // Copy to the clipboard.
 371   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_COPY ) );
 372   DALI_TEST_CHECK( button );
 373
 374   button.DoAction( "buttonClick", attributes );
 375
 376   // Call relayout to process the input events.
 377   controller->Relayout( CONTROL_SIZE );
 378
 379   // Cut the text.
 380   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 381   DALI_TEST_CHECK( button );
 382
 383   button.DoAction( "buttonClick", attributes );
 384
 385   // Force to update the model.
 386   controller->GetNaturalSize();
 387
 388   controller->GetText( text );
 389   DALI_TEST_CHECK( text.empty() );
 390
 391   ClipboardEventNotifier clipboardEventNotifier = ClipboardEventNotifier::Get();
 392   clipboardEventNotifier.ContentSelectedSignal().Connect( &ContentSelectedCallback );
 393
 394   // Paste the text.
 395   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_PASTE ) );
 396   DALI_TEST_CHECK( button );
 397
 398   button.DoAction( "buttonClick", attributes );
 399
 400   // Call relayout to process the input events.
 401   controller->Relayout( CONTROL_SIZE );
 402
 403   DALI_TEST_EQUALS( "Hello world", gClipboardText, TEST_LOCATION );
 404
 405   // Show the clipboard.
 406   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CLIPBOARD ) );
 407   DALI_TEST_CHECK( button );
 408
 409   button.DoAction( "buttonClick", attributes );
 410
 411   tet_result(TET_PASS);
 412   END_TEST;
 413 }
 414
 415 int UtcDaliTextControllerGetInputShadowProperty(void)
 416 {
 417   tet_infoline(" UtcDaliTextControllerGetInputShadowProperty");
 418   ToolkitTestApplication application;
 419
 420   // Creates a text controller.
 421   ControllerPtr controller = Controller::New();
 422
 423   DALI_TEST_CHECK( controller );
 424
 425   const std::string& shadowProperties = controller->GetInputShadowProperties();
 426
 427   DALI_TEST_CHECK( shadowProperties.empty() );
 428
 429   tet_result(TET_PASS);
 430   END_TEST;
 431 }
 432
 433 int UtcDaliTextControllerGetInputUnderlineProperty(void)
 434 {
 435   tet_infoline(" UtcDaliTextControllerGetInputUnderlineProperty");
 436   ToolkitTestApplication application;
 437
 438   // Creates a text controller.
 439   ControllerPtr controller = Controller::New();
 440
 441   DALI_TEST_CHECK( controller );
 442
 443   const std::string& underlineProperties = controller->GetInputUnderlineProperties();
 444
 445   DALI_TEST_CHECK( underlineProperties.empty() );
 446
 447   tet_result(TET_PASS);
 448   END_TEST;
 449 }
 450
 451 int UtcDaliTextControllerSetGetAutoScrollEnabled(void)
 452 {
 453   tet_infoline(" UtcDaliTextControllerSetGetAutoScrollEnabled");
 454   ToolkitTestApplication application;
 455
 456   // Creates a text controller.
 457   ControllerPtr controller = Controller::New();
 458
 459   DALI_TEST_CHECK( controller );
 460
 461   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 462
 463   // The auto scrolling shouldn't be enabled if the multi-line is enabled.
 464
 465   // Enable multi-line.
 466   controller->SetMultiLineEnabled( true );
 467
 468   // Enable text scrolling.
 469   controller->SetAutoScrollEnabled( true );
 470
 471   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 472
 473   // Disable multi-line.
 474   controller->SetMultiLineEnabled( false );
 475
 476   // Enable text scrolling.
 477   controller->SetAutoScrollEnabled( true );
 478
 479   // Should be ebabled now.
 480   DALI_TEST_CHECK( controller->IsAutoScrollEnabled() );
 481
 482   tet_result(TET_PASS);
 483   END_TEST;
 484 }
 485
 486 int UtcDaliTextControllerSetGetCheckProperty(void)
 487 {
 488   tet_infoline(" UtcDaliTextControllerSetGetCheckProperty");
 489   ToolkitTestApplication application;
 490
 491   // Creates a text controller.
 492   ControllerPtr controller = Controller::New();
 493
 494   DALI_TEST_CHECK( controller );
 495
 496   // Enable the text input.
 497   // Creates a decorator.
 498   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 499
 500   InputMethodContext inputMethodContext = InputMethodContext::New();
 501   // Enables the text input.
 502   controller->EnableTextInput( decorator, inputMethodContext );
 503
 504   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 505
 506   // Set the text input to password.
 507   controller->SetInputModePassword( true );
 508
 509   DALI_TEST_CHECK( controller->IsInputModePassword() );
 510
 511   // Unset the text input to password.
 512   controller->SetInputModePassword( false );
 513
 514   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 515
 516   tet_result(TET_PASS);
 517   END_TEST;
 518 }
 519
 520 int UtcDaliTextControllerSetGetTapLongPressAction(void)
 521 {
 522   tet_infoline(" UtcDaliTextControllerSetGetTapLongPressAction");
 523   ToolkitTestApplication application;
 524
 525   // Creates a text controller.
 526   ControllerPtr controller = Controller::New();
 527
 528   DALI_TEST_CHECK( controller );
 529
 530   // Test first with no decorator.
 531
 532   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 533   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 534   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 535
 536   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 537   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 538   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 539
 540   // Add a decorator and re-test.
 541
 542   // Creates a decorator.
 543   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 544
 545   InputMethodContext inputMethodContext = InputMethodContext::New();
 546   // Enables the text input.
 547   controller->EnableTextInput( decorator, inputMethodContext );
 548
 549   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 550   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 551   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 552
 553   DALI_TEST_EQUALS( Controller::NoTextTap::SHOW_SELECTION_POPUP, controller->GetNoTextLongPressAction(), TEST_LOCATION ); // The default is SHOW_SELECTION_POPUP
 554   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 555   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 556
 557   END_TEST;
 558 }
 559
 560 int UtcDaliTextControllerSetGetLineSpacingProperty(void)
 561 {
 562   tet_infoline(" UtcDaliTextControllerSetGetLineSpacingProperty");
 563   ToolkitTestApplication application;
 564
 565   const Size size( Dali::Stage::GetCurrent().GetSize() );
 566
 567   // single line text
 568   const std::string textSingle("A Quick Brown Fox Jumps Over The Lazy Dog");
 569
 570   // multi-line text
 571   const std::string textMulti("A Quick Brown\nFox Jumps Over\nThe Lazy Dog");
 572
 573   // Creates a text controller.
 574   ControllerPtr controller = Controller::New();
 575
 576   ConfigureTextLabel(controller);
 577
 578   // single line, line spacing = 0px
 579   {
 580     const float EXPECTED_SPACING = 0.0f;
 581     const Vector2 EXPECTED_LAYOUT_SIZE( 342.0f, 19.0f);
 582     const Vector3 EXPECTED_NATURAL_SIZE( 342.0f, 20.0f, 0.0f );
 583
 584     controller->SetText(textSingle);
 585     controller->Relayout(size);
 586     controller->SetMultiLineEnabled( false );
 587
 588     Vector3 naturalSize  = controller->GetNaturalSize();
 589     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 590     float lineSpacing0 = controller->GetDefaultLineSpacing();
 591
 592     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 593     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 594     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 595   }
 596
 597   // single line, line spacing = 20px
 598   {
 599     const float EXPECTED_SPACING = 20.0f;
 600     const Vector2 EXPECTED_LAYOUT_SIZE( 342.0f, 19.0f );
 601     const Vector3 EXPECTED_NATURAL_SIZE( 342.0f, 40.0f, 0.0f );
 602
 603     controller->SetText(textSingle);
 604     controller->Relayout(size);
 605     controller->SetDefaultLineSpacing( 20 );
 606     controller->SetMultiLineEnabled( false );
 607
 608     Vector3 naturalSize  = controller->GetNaturalSize();
 609     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 610     float lineSpacing0 = controller->GetDefaultLineSpacing();
 611
 612     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 613     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 614     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 615   }
 616
 617   // multi-line, line spacing = 0px
 618   {
 619     const float EXPECTED_SPACING = 0.0f;
 620     const Vector2 EXPECTED_LAYOUT_SIZE( 332.0f, 39.0f );
 621     const Vector3 EXPECTED_NATURAL_SIZE( 118.0f, 58.0f, 0.0f );
 622
 623     controller->SetText(textMulti);
 624     controller->Relayout(size);
 625     controller->SetMultiLineEnabled( true );
 626     controller->SetDefaultLineSpacing( 0 );
 627
 628     Vector3 naturalSize  = controller->GetNaturalSize();
 629     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 630     float lineSpacing0 = controller->GetDefaultLineSpacing();
 631
 632     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 633     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 634     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 635   }
 636
 637   // multi-line, line spacing = 20px
 638   {
 639     const float EXPECTED_SPACING = 20.0f;
 640     const Vector2 EXPECTED_LAYOUT_SIZE( 118.0f, 57.0f );
 641     const Vector3 EXPECTED_NATURAL_SIZE( 118.0f, 118.0f, 0.0f );
 642
 643     controller->SetText(textMulti);
 644     controller->Relayout(size);
 645     controller->SetMultiLineEnabled( true );
 646     controller->SetDefaultLineSpacing( 20 );
 647
 648     Vector3 naturalSize  = controller->GetNaturalSize();
 649     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 650     float lineSpacing0 = controller->GetDefaultLineSpacing();
 651
 652     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 653     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 654     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 655   }
 656
 657   // multi-line, line spacing = 30px
 658   {
 659     const float EXPECTED_SPACING = 30.0f;
 660     const Vector2 EXPECTED_LAYOUT_SIZE( 118.0f, 117.0f );
 661     const Vector3 EXPECTED_NATURAL_SIZE( 118.0f, 148.0f, 0.0f );
 662
 663     controller->SetText(textMulti);
 664     controller->Relayout(size);
 665     controller->SetMultiLineEnabled( true );
 666     controller->SetDefaultLineSpacing( 30 );
 667
 668     Vector3 naturalSize  = controller->GetNaturalSize();
 669     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 670     float lineSpacing0 = controller->GetDefaultLineSpacing();
 671
 672     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 673     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 674     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 675   }
 676
 677
 678   END_TEST;
 679
 680 }
 681
 682 int UtcDaliTextControllerCheckBufferIndices(void)
 683 {
 684   tet_infoline(" UtcDaliTextControllerCheckBufferIndices");
 685   ToolkitTestApplication application;
 686
 687   // Creates a text controller.
 688   ControllerPtr controller = Controller::New();
 689
 690   ConfigureTextLabel(controller);
 691
 692   // Set the text
 693   const std::string text("A Quick Brown Fox Jumps Over The Lazy Dog");
 694   controller->SetText(text);
 695
 696   // Get the implementation of the text controller
 697   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 698
 699   // Tweak some parameters to make the indices to access the text buffer invalid
 700   mImpl.mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl.mModel->mLogicalModel->mText.Count() * 10u;
 701   mImpl.mTextUpdateInfo.mNumberOfCharactersToRemove = 0u;
 702   mImpl.mTextUpdateInfo.mPreviousNumberOfCharacters = 0u;
 703   mImpl.mOperationsPending = Controller::ALL_OPERATIONS;
 704
 705   // Perform a relayout
 706   const Size size( Dali::Stage::GetCurrent().GetSize() );
 707   controller->Relayout(size);
 708
 709   tet_result(TET_PASS);
 710
 711   END_TEST;
 712 }
 713
 714 int UtcDaliTextControllerCheckInputColorChanged(void)
 715 {
 716   tet_infoline(" UtcDaliTextControllerCheckInputColorChanged");
 717   ToolkitTestApplication application;
 718
 719   // Creates a text controller.
 720   ControllerPtr controller = Controller::New();
 721
 722   ConfigureTextLabel(controller);
 723
 724   // Enable the text input.
 725   // Creates a decorator.
 726   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 727                                                        *controller );
 728   InputMethodContext inputMethodContext = InputMethodContext::New();
 729   // Enables the text input.
 730   controller->EnableTextInput( decorator, inputMethodContext );
 731
 732   // Set the text
 733   const std::string text("Hello World!");
 734   controller->SetText(text);
 735
 736   const Vector4 inputColor( 0.0f, 0.0f, 0.0f, 1.0f );
 737   controller->SetInputColor( inputColor );
 738
 739   // Get the implementation of the text controller
 740   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 741
 742   //  Reset operation
 743   mImpl.mOperationsPending = Controller::NO_OPERATION;
 744
 745   // simulate a key event.
 746   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 747
 748   // change the input color
 749   const Vector4 newInputColor( 1.0f, 0.0f, 0.0f, 1.0f );
 750   controller->SetInputColor( newInputColor );
 751
 752   // Check if relayout is requested or not when event state is INACTIVE.
 753   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 754   DALI_TEST_EQUALS( Controller::COLOR, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::COLOR ), TEST_LOCATION );
 755
 756   // Perform a relayout
 757   const Size size( Dali::Stage::GetCurrent().GetSize() );
 758   controller->Relayout(size);
 759
 760   tet_result(TET_PASS);
 761
 762   END_TEST;
 763 }
 764
 765 int UtcDaliTextControllerCheckInputFontFamilyChanged(void)
 766 {
 767   tet_infoline(" UtcDaliTextControllerCheckInputFontFamilyChanged");
 768   ToolkitTestApplication application;
 769
 770   // Creates a text controller.
 771   ControllerPtr controller = Controller::New();
 772
 773   ConfigureTextLabel(controller);
 774
 775   // Enable the text input.
 776   // Creates a decorator.
 777   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 778                                                        *controller );
 779   InputMethodContext inputMethodContext = InputMethodContext::New();
 780   // Enables the text input.
 781   controller->EnableTextInput( decorator, inputMethodContext );
 782
 783   // Set the text and font family
 784   const std::string text("Hello World!");
 785   controller->SetText(text);
 786   controller->SetInputFontFamily("SamsungOneUI_200");
 787
 788   // Get the implementation of the text controller
 789   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 790
 791   //  Reset operation
 792   mImpl.mOperationsPending = Controller::NO_OPERATION;
 793
 794   // simulate a key event.
 795   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 796
 797   // change the input font family
 798   controller->SetInputFontFamily("SamsungOneUI_300");
 799
 800   // Check if relayout is requested or not when event state is INACTIVE.
 801   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 802   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 803                     TEST_LOCATION );
 804
 805   // Perform a relayout
 806   const Size size( Dali::Stage::GetCurrent().GetSize() );
 807   controller->Relayout(size);
 808
 809   tet_result(TET_PASS);
 810
 811   END_TEST;
 812 }
 813
 814 int UtcDaliTextControllerCheckInputFontWeightChanged(void)
 815 {
 816   tet_infoline(" UtcDaliTextControllerCheckInputFontWeightChanged");
 817   ToolkitTestApplication application;
 818
 819   // Creates a text controller.
 820   ControllerPtr controller = Controller::New();
 821
 822   ConfigureTextLabel(controller);
 823
 824   // Enable the text input.
 825   // Creates a decorator.
 826   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 827                                                        *controller );
 828   InputMethodContext inputMethodContext = InputMethodContext::New();
 829   // Enables the text input.
 830   controller->EnableTextInput( decorator, inputMethodContext );
 831
 832   // Set the text
 833   const std::string text("Hello World!");
 834   controller->SetText(text);
 835   controller->SetInputFontWeight( TextAbstraction::FontWeight::NORMAL );
 836
 837   // Get the implementation of the text controller
 838   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 839
 840   // Reset operation
 841   mImpl.mOperationsPending = Controller::NO_OPERATION;
 842
 843   // simulate a key event.
 844   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 845
 846   // change the input font weight
 847   controller->SetInputFontWeight( TextAbstraction::FontWeight::BOLD );
 848
 849   // Check if relayout is requested or not when event state is INACTIVE.
 850   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 851   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 852                     TEST_LOCATION );
 853
 854   // Perform a relayout
 855   const Size size( Dali::Stage::GetCurrent().GetSize() );
 856   controller->Relayout(size);
 857
 858   tet_result(TET_PASS);
 859
 860   END_TEST;
 861 }
 862
 863 int UtcDaliTextControllerCheckInputFontWidthChanged(void)
 864 {
 865   tet_infoline(" UtcDaliTextControllerCheckInputFontWidthChanged");
 866   ToolkitTestApplication application;
 867
 868   // Creates a text controller.
 869   ControllerPtr controller = Controller::New();
 870
 871   ConfigureTextLabel(controller);
 872
 873   // Enable the text input.
 874   // Creates a decorator.
 875   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 876                                                        *controller );
 877   InputMethodContext inputMethodContext = InputMethodContext::New();
 878   // Enables the text input.
 879   controller->EnableTextInput( decorator, inputMethodContext );
 880
 881   // Set the text
 882   const std::string text("Hello World!");
 883   controller->SetText(text);
 884   controller->SetInputFontWidth( TextAbstraction::FontWidth::NORMAL );
 885
 886   // Get the implementation of the text controller
 887   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 888
 889   // Reset operation
 890   mImpl.mOperationsPending = Controller::NO_OPERATION;
 891
 892   // simulate a key event.
 893   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 894
 895   // change the input font width
 896   controller->SetInputFontWidth( TextAbstraction::FontWidth::EXPANDED );
 897
 898   // Check if relayout is requested or not when event state is INACTIVE.
 899   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 900   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 901                     TEST_LOCATION );
 902
 903   // Perform a relayout
 904   const Size size( Dali::Stage::GetCurrent().GetSize() );
 905   controller->Relayout(size);
 906
 907   tet_result(TET_PASS);
 908
 909   END_TEST;
 910 }
 911
 912 int UtcDaliTextControllerCheckInputFontSlantChanged(void)
 913 {
 914   tet_infoline(" UtcDaliTextControllerCheckInputFontSlantChanged");
 915   ToolkitTestApplication application;
 916
 917   // Creates a text controller.
 918   ControllerPtr controller = Controller::New();
 919
 920   ConfigureTextLabel(controller);
 921
 922   // Enable the text input.
 923   // Creates a decorator.
 924   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 925                                                        *controller );
 926   InputMethodContext inputMethodContext = InputMethodContext::New();
 927   // Enables the text input.
 928   controller->EnableTextInput( decorator, inputMethodContext );
 929
 930   // Set the text
 931   const std::string text("Hello World!");
 932   controller->SetText(text);
 933   controller->SetInputFontSlant( TextAbstraction::FontSlant::NORMAL );
 934
 935   // Get the implementation of the text controller
 936   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 937
 938   //  Reset operation
 939   mImpl.mOperationsPending = Controller::NO_OPERATION;
 940
 941   // simulate a key event.
 942   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 943
 944   // change the input font slant
 945   controller->SetInputFontSlant( TextAbstraction::FontSlant::ROMAN );
 946
 947   // Check if relayout is requested or not when event state is INACTIVE.
 948   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 949   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 950                     TEST_LOCATION );
 951
 952   // Perform a relayout
 953   const Size size( Dali::Stage::GetCurrent().GetSize() );
 954   controller->Relayout(size);
 955
 956   tet_result(TET_PASS);
 957
 958   END_TEST;
 959 }
 960
 961 int UtcDaliTextControllerCheckInputFontPointSizeChanged(void)
 962 {
 963   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeChanged");
 964   ToolkitTestApplication application;
 965
 966   // Creates a text controller.
 967   ControllerPtr controller = Controller::New();
 968
 969   ConfigureTextLabel(controller);
 970
 971   // Enable the text input.
 972   // Creates a decorator.
 973   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 974                                                        *controller );
 975   InputMethodContext inputMethodContext = InputMethodContext::New();
 976   // Enables the text input.
 977   controller->EnableTextInput( decorator, inputMethodContext );
 978
 979   // Set the text
 980   const std::string text("Hello World!");
 981   controller->SetText(text);
 982   controller->SetInputFontPointSize( 1.0f );
 983
 984   // Get the implementation of the text controller
 985   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 986
 987   //  Reset operation
 988   mImpl.mOperationsPending = Controller::NO_OPERATION;
 989
 990   // simulate a key event.
 991   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 992
 993   // change the input font point size
 994   controller->SetInputFontPointSize( 1.2f );
 995
 996   // Check if relayout is requested or not when event state is INACTIVE.
 997   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 998   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 999                     TEST_LOCATION );
1000
1001   // Perform a relayout
1002   const Size size( Dali::Stage::GetCurrent().GetSize() );
1003   controller->Relayout(size);
1004
1005   tet_result(TET_PASS);
1006
1007   END_TEST;
1008 }
1009
1010 int UtcDaliTextControllerSelectEvent(void)
1011 {
1012   tet_infoline(" UtcDaliTextControllerSelectEvent");
1013   ToolkitTestApplication application;
1014
1015   // Creates a text controller.
1016   ControllerPtr controller = Controller::New();
1017
1018   // Configures the text controller similarly to the text-field.
1019   ConfigureTextField( controller );
1020
1021   // Set the text
1022   const std::string text("Hello World!");
1023   controller->SetText( text );
1024
1025   // Select the whole text.
1026   controller->SelectEvent( 0.f, 0.f, false );
1027
1028   // Perform a relayout
1029   const Size size( Dali::Stage::GetCurrent().GetSize() );
1030   controller->Relayout(size);
1031
1032   // Get the implementation of the text controller
1033   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1034
1035   // Check if the whole text is selected or not.
1036   std::string retrieved_text;
1037   mImpl.RetrieveSelection( retrieved_text, false );
1038   DALI_TEST_EQUALS( "Hello", retrieved_text, TEST_LOCATION );
1039
1040   // Select the whole text.
1041   controller->SelectEvent( 0.f, 0.f, true );
1042
1043   // Perform a relayout
1044   controller->Relayout( size );
1045
1046   mImpl.RetrieveSelection( retrieved_text, false );
1047   DALI_TEST_EQUALS( text, retrieved_text, TEST_LOCATION );
1048
1049   END_TEST;
1050 }
1051
1052
1053 int UtcDaliTextControllerMaxLengthSetText(void)
1054 {
1055   tet_infoline(" UtcDaliTextControllerMaxLengthSetText");
1056   ToolkitTestApplication application;
1057
1058   // Creates a text controller.
1059   ControllerPtr controller = Controller::New();
1060
1061   ConfigureTextLabel(controller);
1062
1063   const Length MAX_TEXT_LENGTH = 1024u * 32u;
1064
1065   // make over length world
1066   int maxLength = (1024u * 32u) + 10u;
1067   char world[maxLength];
1068   for( int i = 0; i < maxLength; i++ )
1069   {
1070     world[i] = 'a';
1071   }
1072
1073   // Set the text
1074   std::string text(world);
1075   controller->SetText( text );
1076
1077   // Perform a relayout
1078   const Size size( Dali::Stage::GetCurrent().GetSize() );
1079   controller->Relayout(size);
1080
1081   // check text length
1082   controller->GetText( text );
1083   Length textSize = text.size();
1084
1085   DALI_TEST_EQUALS( MAX_TEXT_LENGTH, textSize, TEST_LOCATION );
1086
1087   END_TEST;
1088 }
1089
1090 int UtcDaliTextControllerRemoveTextChangeEventData(void)
1091 {
1092   tet_infoline(" UtcDaliTextControllerRemoveTextChangeEventData");
1093   ToolkitTestApplication application;
1094
1095   // Creates a text controller.
1096   ControllerPtr controller = Controller::New();
1097
1098   ConfigureTextField( controller );
1099
1100   // Set the text
1101   const std::string text( "Hello World!" );
1102   controller->SetText( text );
1103   controller->SetInputFontPointSize( 1.0f );
1104
1105   // Get the implementation of the text controller
1106   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1107
1108   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1109
1110   // Send DELETE_SURROUNDING event
1111   InputMethodContext::EventData imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -1, 1 );
1112   InputMethodContext inputMethodContext = InputMethodContext::New();
1113   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1114
1115   // Force to update the model.
1116   controller->GetNaturalSize();
1117
1118   // Simulate a key event to delete text
1119   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Dali::KeyEvent::Down ) );
1120
1121   DALI_TEST_EQUALS( EventData::EDITING, mImpl.mEventData->mState, TEST_LOCATION );
1122
1123   // Perform a relayout
1124   const Size size( Dali::Stage::GetCurrent().GetSize() );
1125   controller->Relayout( size );
1126
1127   tet_result(TET_PASS);
1128
1129   END_TEST;
1130 }