[dali_1.0.8] Merge branch 'tizen'
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit-internal / utc-Dali-TextView-Relayout-Utilities.cpp
1 /*
2  * Copyright (c) 2014 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 <dali-toolkit-test-suite-utils.h>
22 #include <dali-toolkit/dali-toolkit.h>
23
24 // Internal headers are allowed here
25 #include <dali-toolkit/internal/controls/text-view/relayout-utilities.h>
26 #include <dali-toolkit/internal/controls/text-view/text-view-processor.h>
27
28 using namespace Dali;
29 using namespace Dali::Toolkit;
30 using namespace Dali::Toolkit::Internal;
31
32 void dali_text_view_relayout_utils_startup(void)
33 {
34   test_return_value = TET_UNDEF;
35 }
36
37 void dali_text_view_relayout_utils_cleanup(void)
38 {
39   test_return_value = TET_PASS;
40 }
41
42 namespace
43 {
44
45 const Toolkit::Internal::TextView::LayoutParameters DEFAULT_LAYOUT_PARAMETERS;
46
47 // Data structures used to create an 'experiment' in TET cases
48
49
50 bool TestEqual( float x, float y )
51 {
52   return ( fabsf( x - y ) < Math::MACHINE_EPSILON_1000 );
53 }
54
55 //////////////////////////////////////////////////////////////////
56
57 struct CalculateSubLineLayoutTest
58 {
59   std::string description;
60   std::string inputLine;
61   float parentWidth;
62   std::size_t groupIndex;
63   std::size_t wordIndex;
64   std::size_t characterIndex;
65   TextViewRelayout::HorizontalWrapType splitPolicy;
66   float shrinkFactor;
67
68   float resultLineLength;
69   float resultMaxCharHeight;
70   float resultMaxAscender;
71 };
72
73 bool TestCalculateSubLineLayout( const CalculateSubLineLayoutTest& test,  const char* location )
74 {
75   tet_printf( "%s", test.description.c_str() );
76
77   // Create styled text.
78   MarkupProcessor::StyledTextArray inputStyledText;
79   MarkupProcessor::GetStyledTextArray( test.inputLine, inputStyledText, true );
80
81   // Create styled text layout info.
82   Toolkit::Internal::TextView::RelayoutData relayoutData;
83   TextViewProcessor::CreateTextInfo( inputStyledText,
84                                      DEFAULT_LAYOUT_PARAMETERS,
85                                      relayoutData );
86
87   // Prepare input parameters and the result structure and call the function to be tested.
88
89   // Creaqte indices.
90   TextViewProcessor::TextInfoIndices indices( 0, test.groupIndex, test.wordIndex, test.characterIndex );
91
92   // Get the input line.
93   TextViewProcessor::LineLayoutInfo inputLineLayout;
94
95   if( !relayoutData.mTextLayoutInfo.mLinesLayoutInfo.empty() )
96   {
97     inputLineLayout = *relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin();
98   }
99
100   // Result struct.
101   TextViewRelayout::SubLineLayoutInfo resultLayoutInfo;
102
103   CalculateSubLineLayout( test.parentWidth,
104                           indices,
105                           inputLineLayout,
106                           test.splitPolicy,
107                           test.shrinkFactor,
108                           resultLayoutInfo  );
109
110   // Check results.
111   if( !TestEqual( test.resultLineLength, resultLayoutInfo.mLineLength ) )
112   {
113     tet_printf( "Fail. different line length %f == %f. %s", test.resultLineLength, resultLayoutInfo.mLineLength, location );
114     return false;
115   }
116
117   if( !TestEqual( test.resultMaxCharHeight, resultLayoutInfo.mMaxCharHeight ) )
118   {
119     tet_printf( "Fail. different max character height %f == %f. %s", test.resultMaxCharHeight, resultLayoutInfo.mMaxCharHeight, location );
120     return false;
121   }
122
123   if( !TestEqual( test.resultMaxAscender, resultLayoutInfo.mMaxAscender ) )
124   {
125     tet_printf( "Fail. different max ascender %f == %f. %s", test.resultMaxAscender, resultLayoutInfo.mMaxAscender, location );
126     return false;
127   }
128
129   return true;
130 }
131
132 //////////////////////////////////////////////////////////////////
133
134 struct AlignmentOffsetTest
135 {
136   Toolkit::Alignment::Type alignment;
137   float parentSize;
138   float wholeTextSize;
139
140   float resultOffset;
141 };
142
143 bool TestAlignmentOffset( const AlignmentOffsetTest& test, const char* location )
144 {
145   float offset = 0.f;
146
147   switch( test.alignment )
148   {
149     case Toolkit::Alignment::HorizontalLeft:
150     case Toolkit::Alignment::HorizontalCenter:
151     case Toolkit::Alignment::HorizontalRight:
152     {
153       offset = TextViewRelayout::CalculateXoffset( test.alignment, test.parentSize, test.wholeTextSize );
154       break;
155     }
156     case Toolkit::Alignment::VerticalTop:
157     case Toolkit::Alignment::VerticalCenter:
158     case Toolkit::Alignment::VerticalBottom:
159     {
160       offset = TextViewRelayout::CalculateYoffset( test.alignment, test.parentSize, test.wholeTextSize );
161       break;
162     }
163   }
164
165   // Check results.
166   if( !TestEqual( test.resultOffset, offset ) )
167   {
168     tet_printf( "Fail. different offset %f == %f. %s", test.resultOffset, offset, location );
169     return false;
170   }
171
172   return true;
173 }
174
175 //////////////////////////////////////////////////////////////////
176
177 struct JustificationOffsetTest
178 {
179   Toolkit::TextView::LineJustification justification;
180   float wholeTextWidth;
181   float lineLength;
182
183   float resultOffset;
184 };
185
186 bool TestJustificationOffset( const JustificationOffsetTest& test, const char* location )
187 {
188   float offset = TextViewRelayout::CalculateJustificationOffset( test.justification, test.wholeTextWidth, test.lineLength );
189
190   // Check results.
191   if( !TestEqual( test.resultOffset, offset ) )
192   {
193     tet_printf( "Fail. different offset %f == %f. %s", test.resultOffset, offset, location );
194     return false;
195   }
196
197   return true;
198 }
199
200 //////////////////////////////////////////////////////////////////
201
202 struct CalculateVisibilityTest
203 {
204   Vector3 position;
205   Size size;
206   Size parentSize;
207   TextViewRelayout::VisibilityTestType type;
208
209   bool resultVisible;
210 };
211
212 bool TestCalculateVisibility( const CalculateVisibilityTest& test, const char* location )
213 {
214   if( test.resultVisible != TextViewRelayout::IsVisible( test.position, test.size, test.parentSize, test.type ) )
215   {
216     tet_printf( "Fail. different visibility. Type %d, %s", test.type, location );
217     return false;
218   }
219
220   return true;
221 }
222
223 //////////////////////////////////////////////////////////////////
224
225 } // namespace
226
227
228 int UtcDaliTextViewDefaultConstructorDestructor_RU(void)
229 {
230   ToolkitTestApplication application;
231
232   tet_infoline("UtcDaliTextViewDefaultConstructorDestructor : ");
233
234   // Test RelayoutParameters defaults.
235   TextViewRelayout::RelayoutParameters relayoutParameters;
236
237   DALI_TEST_EQUALS( relayoutParameters.mPositionOffset, Vector3::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
238   DALI_TEST_EQUALS( relayoutParameters.mLineSize, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
239   DALI_TEST_EQUALS( relayoutParameters.mWordSize, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
240   DALI_TEST_EQUALS( relayoutParameters.mCharacterSize, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
241   DALI_TEST_EQUALS( relayoutParameters.mIndices.mLineIndex, 0u, TEST_LOCATION );
242   DALI_TEST_EQUALS( relayoutParameters.mIndices.mGroupIndex, 0u, TEST_LOCATION );
243   DALI_TEST_EQUALS( relayoutParameters.mIndices.mWordIndex, 0u, TEST_LOCATION );
244   DALI_TEST_EQUALS( relayoutParameters.mIndices.mCharacterIndex, 0u, TEST_LOCATION );
245   DALI_TEST_EQUALS( relayoutParameters.mCharacterGlobalIndex, 0u, TEST_LOCATION );
246   DALI_TEST_CHECK( !relayoutParameters.mIsFirstCharacter );
247   DALI_TEST_CHECK( !relayoutParameters.mIsFirstCharacterOfWord );
248   DALI_TEST_CHECK( !relayoutParameters.mIsNewLine );
249   DALI_TEST_CHECK( !relayoutParameters.mIsNewLineCharacter );
250   DALI_TEST_CHECK( !relayoutParameters.mIsWhiteSpace );
251   DALI_TEST_CHECK( !relayoutParameters.mIsVisible );
252
253   // Test FadeParameter defaults
254   TextViewRelayout::FadeParameters fadeParameters;
255
256   DALI_TEST_EQUALS( fadeParameters.mRightFadeBoundary, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
257   DALI_TEST_EQUALS( fadeParameters.mRightFadeThreshold, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
258   DALI_TEST_EQUALS( fadeParameters.mRightFadeBoundaryOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
259   DALI_TEST_EQUALS( fadeParameters.mRightFadeThresholdOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
260   DALI_TEST_EQUALS( fadeParameters.mRightAlphaCoeficients, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
261   DALI_TEST_EQUALS( fadeParameters.mLeftFadeBoundary, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
262   DALI_TEST_EQUALS( fadeParameters.mLeftFadeThreshold, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
263   DALI_TEST_EQUALS( fadeParameters.mLeftFadeBoundaryOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
264   DALI_TEST_EQUALS( fadeParameters.mLeftFadeThresholdOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
265   DALI_TEST_EQUALS( fadeParameters.mLeftAlphaCoeficients, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
266   DALI_TEST_EQUALS( fadeParameters.mTopFadeBoundary, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
267   DALI_TEST_EQUALS( fadeParameters.mTopFadeThreshold, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
268   DALI_TEST_EQUALS( fadeParameters.mTopFadeBoundaryOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
269   DALI_TEST_EQUALS( fadeParameters.mTopFadeThresholdOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
270   DALI_TEST_EQUALS( fadeParameters.mTopAlphaCoeficients, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
271   DALI_TEST_EQUALS( fadeParameters.mBottomFadeBoundary, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
272   DALI_TEST_EQUALS( fadeParameters.mBottomFadeThreshold, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
273   DALI_TEST_EQUALS( fadeParameters.mBottomFadeBoundaryOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
274   DALI_TEST_EQUALS( fadeParameters.mBottomFadeThresholdOffset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
275   DALI_TEST_EQUALS( fadeParameters.mBottomAlphaCoeficients, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
276   DALI_TEST_CHECK( !fadeParameters.mIsPartiallyVisible );
277
278   // Test EllipsizeParameters defaults
279   TextViewRelayout::EllipsizeParameters ellipsizeParameters;
280
281   DALI_TEST_EQUALS( ellipsizeParameters.mPosition, Vector3::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
282   DALI_TEST_EQUALS( ellipsizeParameters.mLineDescender, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
283   DALI_TEST_EQUALS( ellipsizeParameters.mLineWidth, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
284   DALI_TEST_EQUALS( ellipsizeParameters.mEllipsizeBoundary, Vector2::ZERO, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
285   DALI_TEST_EQUALS( ellipsizeParameters.mFirstIndex, 0u, TEST_LOCATION );
286   DALI_TEST_EQUALS( ellipsizeParameters.mLastIndex, 0u, TEST_LOCATION );
287   DALI_TEST_CHECK( !ellipsizeParameters.mEllipsizeLine );
288   DALI_TEST_CHECK( !ellipsizeParameters.mIsLineWidthFullyVisible );
289   DALI_TEST_CHECK( !ellipsizeParameters.mIsLineHeightFullyVisible );
290   DALI_TEST_CHECK( !ellipsizeParameters.mIsNextLineFullyVisibleHeight );
291   DALI_TEST_CHECK( !ellipsizeParameters.mCreateEllipsizedTextActors );
292   DALI_TEST_CHECK( !ellipsizeParameters.mLineFits );
293   DALI_TEST_CHECK( !ellipsizeParameters.mWordFits );
294
295   // Test UnderlineInfo defaults
296   TextViewRelayout::UnderlineInfo underlineInfo;
297
298   DALI_TEST_EQUALS( underlineInfo.mMaxHeight, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
299   DALI_TEST_EQUALS( underlineInfo.mMaxThickness, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
300   DALI_TEST_EQUALS( underlineInfo.mPosition, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
301
302   // Test TextUnderlineStatus defaults
303   TextViewRelayout::TextUnderlineStatus textUnderlineStatus;
304
305   DALI_TEST_CHECK( textUnderlineStatus.mUnderlineInfo.empty() );
306   DALI_TEST_EQUALS( textUnderlineStatus.mCharacterGlobalIndex, 0u, TEST_LOCATION );
307   DALI_TEST_EQUALS( textUnderlineStatus.mLineGlobalIndex, 0u, TEST_LOCATION );
308   DALI_TEST_CHECK( !textUnderlineStatus.mCurrentUnderlineStatus );
309
310   // Test SubLineLayoutInfo defaults
311   TextViewRelayout::SubLineLayoutInfo subLineLayoutInfo;
312
313   DALI_TEST_EQUALS( subLineLayoutInfo.mLineLength, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
314   DALI_TEST_EQUALS( subLineLayoutInfo.mMaxCharHeight, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
315   DALI_TEST_EQUALS( subLineLayoutInfo.mMaxAscender, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
316   END_TEST;
317 }
318
319 int UtcDaliTextViewCalculateSubLineLayout(void)
320 {
321   ToolkitTestApplication application;
322
323   tet_infoline("UtcDaliTextViewCalculateSubLineLayout : ");
324
325   struct CalculateSubLineLayoutTest calculateSubLineLayoutTest[] =
326   {
327     //WrapByCharacter
328     {
329       "The line is wraped by character. All characters have the same size.",
330       "Hello world", // input line
331       100.f,         // parent width
332       0,
333       0,              // indices
334       0,
335       TextViewRelayout::WrapByCharacter, // split policy
336       1.f,
337       // results
338       91.041672f, // line length. (only fits 8 characters 8x11.38)
339       11.380209f, // max character height
340       10.242188f  // max ascender
341     },
342     {
343       "The line is wraped by character. There are characters with different sizes.",
344       "Hello <font size='14'>world</font>", // input line
345       100.f,         // parent width
346       0,
347       0,              // indices
348       0,
349       TextViewRelayout::WrapByCharacter, // split policy
350       1.f,
351       // results
352       94.835075f, // line length. (only fits 8 characters 6x11.38 + 2x13.27)
353       13.276911f, // max character height
354       11.949220f  // max ascender
355     },
356     {
357       "The line is wraped by character. There are characters with different sizes. It calculates the layout for the second line.",
358       "Hello <font size='14'>wo</font>rld hell<font size='14'>o world</font>", // input line
359       100.f,         // parent width
360       0,
361       2,              // indices. The third character of the third word starts in a new line.
362       2,
363       TextViewRelayout::WrapByCharacter, // split policy
364       1.f,
365       // results
366       91.041672f, // line length. (only fits 8 characters 8x11.38)
367       11.380209f, // max character height
368       10.242188f  // max ascender
369     },
370     {
371       "The line is wraped by character. There are characters with different sizes. It calculates the layout for the third line.",
372       "Hello <font size='14'>wo</font>rld hell<font size='14'>o world</font>", // input line
373       100.f,         // parent width
374       0,
375       4,              // indices. The fifth character of the fifth word starts in a new line.
376       4,
377       TextViewRelayout::WrapByCharacter, // split policy
378       1.f,
379       // results
380       92.938377f, // line length. (only fits 8 characters 8x11.38)
381       13.276911f, // max character height
382       11.949220f  // max ascender
383     },
384
385     //WrapByWord
386     {
387       "The line is wraped by word. All characters have the same size.",
388       "Hello world", // input line
389       100.f,         // parent width
390       0,
391       0,              // indices. It shouldn't use the index character so 9999999 shouldn't make it crash.
392       9999999,
393       TextViewRelayout::WrapByWord, // split policy
394       1.f,
395       // results
396       56.901047f, // line length. (only fits 5 characters 5x11.38, white space is not counted)
397       11.380209f, // max character height
398       10.242188f  // max ascender
399     },
400     {
401       "The line is wraped by word. There are characters with different sizes.",
402       "Hell<font size='14'>o</font> world", // input line
403       100.f,         // parent width
404       0,
405       0,              // indices.
406       0,
407       TextViewRelayout::WrapByWord, // split policy
408       1.f,
409       // results
410       58.797747f, // line length. (only fits 5 characters 4x11.38 + 13.276911, white space is not counted)
411       13.276911f, // max character height
412       11.949220f  // max ascender
413     },
414     {
415       "The line is wraped by word. There are characters with different sizes. It calculates the layout for the second line.",
416       "Hello <font size='14'>wo</font>rld <font size='16'>hello world</font>", // input line
417       100.f,         // parent width
418       0,
419       2,              // indices. The third word starts in a new line.
420       0,
421       TextViewRelayout::WrapByWord, // split policy
422       1.f,
423       // results
424       60.694449f, // line length. (only fits 5 characters 2x13.276911 + 3x11.38)
425       13.276911f, // max character height
426       11.949220f  // max ascender
427     },
428     {
429       "The line is wraped by word. The word doen't fit.",
430       "Hello world", // input line
431       40.f,          // parent width
432       0,
433       0,              // indices. The third word starts in a new line.
434       0,
435       TextViewRelayout::WrapByWord, // split policy
436       1.f,
437       // results
438       0.f,        // line length. (The word doesn't fit)
439       11.380209f, // max character height
440       10.242188f  // max ascender
441     },
442
443     //WrapByWordAndSplit
444     {
445       "The line is wraped by word and by character. All characters have the same size. There is not a long word.",
446       "Hello world hello world", // input line
447       100.f,         // parent width
448       0,
449       0,              // indices.
450       0,
451       TextViewRelayout::WrapByWordAndSplit, // split policy
452       1.f,
453       // results
454       56.901047f, // line length. (only fits 5 characters 5x11.38, white space is not counted)
455       11.380209f, // max character height
456       10.242188f  // max ascender
457     },
458     {
459       "The line is wraped by word and by character. All characters have the same size. There is a long word.",
460       "Helloooooooo world", // input line
461       100.f,         // parent width
462       0,
463       0,              // indices.
464       0,
465       TextViewRelayout::WrapByWordAndSplit, // split policy
466       1.f,
467       // results
468       91.041672f, // line length. (only fits 8 characters 8x11.38)
469       11.380209f, // max character height
470       10.242188f  // max ascender
471     },
472     {
473       "The line is wraped by word and by character. There are characters with different sizes. There is a long word. It calculates the layout for the second line.",
474       "Helloooooooo <font size='14'>world</font>", // input line
475       100.f,         // parent width
476       0,
477       0,              // indices.
478       8,
479       TextViewRelayout::WrapByWordAndSplit, // split policy
480       1.f,
481       // results
482       45.520836f, // line length. (only fits 8 characters 8x11.38)
483       11.380209f, // max character height
484       10.242188f  // max ascender
485     },
486     {
487       "The line is wraped by word and by character. There are characters with different sizes. There is a shrink factor.",
488       "Helloooooooo<font size='14'> world</font>", // input line
489       100.f,         // parent width
490       0,
491       0,              // indices.
492       8,
493       TextViewRelayout::WrapByWordAndSplit, // split policy
494       0.7f,
495       // results
496       95.593755f, // line length. (only fits 12 characters 8x11.38)
497       7.9661463f, // max character height
498       7.169531f  // max ascender
499     },
500
501     //WrapByLineAndSplit
502     {
503       "The line is wraped by end of line and by character. All characters have the same size.",
504       "Hello world", // input line
505       100.f,         // parent width
506       0,
507       0,              // indices
508       0,
509       TextViewRelayout::WrapByLineAndSplit, // split policy
510       1.f,
511       // results
512       91.041672f, // line length. (only fits 8 characters 8x11.38)
513       11.380209f, // max character height
514       10.242188f  // max ascender
515     },
516     {
517       "The line fits in the width.",
518       "Hello", // input line
519       100.f,         // parent width
520       0,
521       0,             // indices
522       0,
523       TextViewRelayout::WrapByLineAndSplit, // split policy
524       1.f,
525       // results
526       56.901047f, // line length. (only fits 5 characters 5x11.38)
527       11.380209f, // max character height
528       10.242188f  // max ascender
529     },
530     {
531       "The line is wraped by end of line and by character. All characters have the same size. It calculates the layout for the second line.",
532       "Hello world, hello world", // input line
533       100.f,         // parent width
534       0,
535       2,             // indices
536       2,
537       TextViewRelayout::WrapByLineAndSplit, // split policy
538       1.f,
539       // results
540       91.041672f, // line length. (only fits 8 characters 8x11.38)
541       11.380209f, // max character height
542       10.242188f  // max ascender
543     },
544   };
545   const std::size_t numberOfTests( 15 );
546
547   for( std::size_t index = 0; index < numberOfTests; ++index )
548   {
549     const CalculateSubLineLayoutTest& test = calculateSubLineLayoutTest[index];
550
551     if( !TestCalculateSubLineLayout( test, TEST_LOCATION ) )
552     {
553       tet_result( TET_FAIL );
554     }
555   }
556
557   tet_result( TET_PASS );
558   END_TEST;
559 }
560
561 int UtcDaliTextViewCalculateAlignmentOffsets(void)
562 {
563   ToolkitTestApplication application;
564
565   tet_infoline("UtcDaliTextViewCalculateAlignmentOffsets : ");
566
567   struct AlignmentOffsetTest alignmentOffsetTest[] =
568   {
569     {
570       Toolkit::Alignment::HorizontalLeft,
571       100.f,
572       75.f,
573       0.f
574     },
575     {
576       Toolkit::Alignment::HorizontalCenter,
577       100.f,
578       75.f,
579       12.5f
580     },
581     {
582       Toolkit::Alignment::HorizontalRight,
583       100.f,
584       75.f,
585       25.f
586     },
587     {
588       Toolkit::Alignment::VerticalTop,
589       100.f,
590       75.f,
591       0.f
592     },
593     {
594       Toolkit::Alignment::VerticalCenter,
595       100.f,
596       75.f,
597       12.5f
598     },
599     {
600       Toolkit::Alignment::VerticalBottom,
601       100.f,
602       75.f,
603       25.f
604     }
605   };
606   const std::size_t numberOfTests( 6 );
607
608   for( std::size_t index = 0; index < numberOfTests; ++index )
609   {
610     const AlignmentOffsetTest& test = alignmentOffsetTest[index];
611
612     if( !TestAlignmentOffset( test, TEST_LOCATION ) )
613     {
614       tet_result( TET_FAIL );
615     }
616   }
617
618   tet_result( TET_PASS );
619   END_TEST;
620 }
621
622 int UtcDaliTextViewCalculateJustificationOffsets(void)
623 {
624   ToolkitTestApplication application;
625
626   tet_infoline("UtcDaliTextViewCalculateJustificationOffsets : ");
627
628   struct JustificationOffsetTest justificationOffsetTest[] =
629   {
630     {
631       Toolkit::TextView::Left,
632       100.f,
633       75.f,
634       0.f
635     },
636     {
637       Toolkit::TextView::Justified,
638       100.f,
639       75.f,
640       0.f
641     },
642     {
643       Toolkit::TextView::Center,
644       100.f,
645       150.f,
646       -25.f
647     },
648     {
649       Toolkit::TextView::Right,
650       100.f,
651       75.f,
652       25.f
653     },
654   };
655   const std::size_t numberOfTests( 4 );
656
657   for( std::size_t index = 0; index < numberOfTests; ++index )
658   {
659     const JustificationOffsetTest& test = justificationOffsetTest[index];
660
661     if( !TestJustificationOffset( test, TEST_LOCATION ) )
662     {
663       tet_result( TET_FAIL );
664     }
665   }
666
667   tet_result( TET_PASS );
668   END_TEST;
669 }
670
671
672 int UtcDaliTextViewCalculateVisibility(void)
673 {
674   ToolkitTestApplication application;
675
676   tet_infoline("UtcDaliTextViewCalculateVisibility : ");
677
678   struct CalculateVisibilityTest calculateVisibilityTest[] =
679   {
680     {
681       Vector3( 0.f, 10.f, 0.f ),
682       Size( 10.f, 10.f ),
683       Size( 100.f, 100.f ),
684       TextViewRelayout::FULLY_VISIBLE,
685       true
686     },
687     {
688       Vector3( 10.f, 10.f, 0.f ),
689       Size( 10.f, 10.f ),
690       Size( 100.f, 100.f ),
691       TextViewRelayout::FULLY_VISIBLE,
692       true
693     },
694     {
695       Vector3( 0.f, 10.f, 0.f ),
696       Size( 150.f, 10.f ),
697       Size( 100.f, 100.f ),
698       TextViewRelayout::FULLY_VISIBLE,
699       false
700     },
701     {
702       Vector3( 0.f, 10.f, 0.f ),
703       Size( 10.f, 10.f ),
704       Size( 100.f, 100.f ),
705       TextViewRelayout::FULLY_VISIBLE_WIDTH,
706       true
707     },
708     {
709       Vector3( 95.f, 10.f, 0.f ),
710       Size( 10.f, 10.f ),
711       Size( 100.f, 100.f ),
712       TextViewRelayout::FULLY_VISIBLE_WIDTH,
713       false
714     },
715     {
716       Vector3( 0.f, 10.f, 0.f ),
717       Size( 10.f, 10.f ),
718       Size( 100.f, 100.f ),
719       TextViewRelayout::FULLY_VISIBLE_HEIGHT,
720       true
721     },
722     {
723       Vector3( 0.f, 0.f, 0.f ),
724       Size( 10.f, 10.f ),
725       Size( 100.f, 100.f ),
726       TextViewRelayout::FULLY_VISIBLE_HEIGHT,
727       false
728     },
729     {
730       Vector3( -10.f, 10.f, 0.f ),
731       Size( 150.f, 150.f ),
732       Size( 100.f, 100.f ),
733       TextViewRelayout::PARTIALLY_VISIBLE,
734       true
735     },
736     {
737       Vector3( -100.f, -100.f, 0.f ),
738       Size( 10.f, 10.f ),
739       Size( 100.f, 100.f ),
740       TextViewRelayout::PARTIALLY_VISIBLE,
741       false
742     },
743     {
744       Vector3( -10.f, 10.f, 0.f ),
745       Size( 50.f, 10.f ),
746       Size( 100.f, 100.f ),
747       TextViewRelayout::PARTIALLY_VISIBLE_WIDTH,
748       true
749     },
750     {
751       Vector3( 110.f, 10.f, 0.f ),
752       Size( 10.f, 10.f ),
753       Size( 100.f, 100.f ),
754       TextViewRelayout::PARTIALLY_VISIBLE_WIDTH,
755       false
756     },
757     {
758       Vector3( 0.f, 20.f, 0.f ),
759       Size( 10.f, 50.f ),
760       Size( 100.f, 100.f ),
761       TextViewRelayout::PARTIALLY_VISIBLE_HEIGHT,
762       true
763     },
764     {
765       Vector3( 0.f, -10.f, 0.f ),
766       Size( 10.f, 10.f ),
767       Size( 100.f, 100.f ),
768       TextViewRelayout::PARTIALLY_VISIBLE_HEIGHT,
769       false
770     },
771   };
772   const std::size_t numberOfTests( 13 );
773
774   for( std::size_t index = 0; index < numberOfTests; ++index )
775   {
776     const CalculateVisibilityTest& test = calculateVisibilityTest[index];
777
778     if( !TestCalculateVisibility( test, TEST_LOCATION ) )
779     {
780       tet_result( TET_FAIL );
781     }
782   }
783
784   tet_result( TET_PASS );
785   END_TEST;
786 }
787
788 int UtcDaliTextViewMiscelaneousAsserts(void)
789 {
790   ToolkitTestApplication application;
791
792   tet_infoline("UtcDaliTextViewMiscelaneousAsserts : ");
793
794   float offset = 0.f;
795
796   bool assert1 = false;
797   bool assert2 = false;
798   try
799   {
800     offset = Toolkit::Internal::TextViewRelayout::CalculateXoffset( Toolkit::Alignment::VerticalTop, 100.f, 50.f );
801   }
802   catch( Dali::DaliException& e )
803   {
804     tet_printf( "Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str() );
805     DALI_TEST_EQUALS( e.mCondition, "!\"TextViewRelayout::CalculateXoffset: Wrong horizontal text alignment. Did you set a vertical one?\"", TEST_LOCATION );
806     assert1 = true;
807   }
808   catch( ... )
809   {
810     tet_result( TET_FAIL );
811   }
812   DALI_TEST_EQUALS( offset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
813
814   try
815   {
816     offset = Toolkit::Internal::TextViewRelayout::CalculateYoffset( Toolkit::Alignment::HorizontalRight, 100.f, 50.f );
817   }
818   catch( Dali::DaliException& e )
819   {
820     tet_printf( "Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str() );
821     DALI_TEST_EQUALS( e.mCondition, "!\"TextViewRelayout::CalculateXoffset: Wrong vertical text alignment. Did you set an horizontal one?\"", TEST_LOCATION );
822     assert2 = true;
823   }
824   catch( ... )
825   {
826     tet_result( TET_FAIL );
827   }
828   DALI_TEST_EQUALS( offset, 0.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
829
830   DALI_TEST_CHECK( assert1 && assert2 );
831
832   END_TEST;
833 }