Dali 3D User Interface Engine
utc-Dali-PropertyValue.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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 #include <iomanip>
20 #include <stdlib.h>
22 #include <dali-test-suite-utils.h>
23 
24 using namespace Dali;
25 
26 namespace
27 {
28 
29 void CheckTypeName(const Property::Type& type)
30 {
31  switch(type)
32  {
33  case Property::NONE:
34  {
35  DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
36  break;
37  }
38  case Property::BOOLEAN:
39  {
40  DALI_TEST_CHECK( "BOOLEAN" == std::string(PropertyTypes::GetName( type ) ) );
41  break;
42  }
43  case Property::FLOAT:
44  {
45  DALI_TEST_CHECK( "FLOAT" == std::string(PropertyTypes::GetName( type ) ) );
46  break;
47  }
48  case Property::INTEGER:
49  {
50  DALI_TEST_CHECK( "INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
51  break;
52  }
53  case Property::VECTOR2:
54  {
55  DALI_TEST_CHECK( "VECTOR2" == std::string(PropertyTypes::GetName( type ) ) );
56  break;
57  }
58  case Property::VECTOR3:
59  {
60  DALI_TEST_CHECK( "VECTOR3" == std::string(PropertyTypes::GetName( type ) ) );
61  break;
62  }
63  case Property::VECTOR4:
64  {
65  DALI_TEST_CHECK( "VECTOR4" == std::string(PropertyTypes::GetName( type ) ) );
66  break;
67  }
68  case Property::MATRIX3:
69  {
70  DALI_TEST_CHECK( "MATRIX3" == std::string(PropertyTypes::GetName( type ) ) );
71  break;
72  }
73  case Property::MATRIX:
74  {
75  DALI_TEST_CHECK( "MATRIX" == std::string(PropertyTypes::GetName( type ) ) );
76  break;
77  }
79  {
80  DALI_TEST_CHECK( "RECTANGLE" == std::string(PropertyTypes::GetName( type ) ) );
81  break;
82  }
83  case Property::ROTATION:
84  {
85  DALI_TEST_CHECK( "ROTATION" == std::string(PropertyTypes::GetName( type ) ) );
86  break;
87  }
88  case Property::STRING:
89  {
90  DALI_TEST_CHECK( "STRING" == std::string(PropertyTypes::GetName( type ) ) );
91  break;
92  }
93  case Property::ARRAY:
94  {
95  DALI_TEST_CHECK( "ARRAY" == std::string(PropertyTypes::GetName( type ) ) );
96  break;
97  }
98  case Property::MAP:
99  {
100  DALI_TEST_CHECK( "MAP" == std::string(PropertyTypes::GetName( type ) ) );
101  break;
102  }
103  } // switch(type)
104 
105 } // CheckTypeName
106 
107 template <typename T>
109 {
111  {
112  Property::Value copy( value );
113  DALI_TEST_CHECK( value.Get<T>() == copy.Get<T>() );
114  }
115 };
116 
117 } // unnamed namespace
118 
120 {
122 }
123 
125 {
127 }
128 
129 
131 {
132  Property::Value value;
133 
134  DALI_TEST_CHECK( value.GetType() == Property::NONE );
135 
136  END_TEST;
137 }
138 
140 {
142 
143  DALI_TEST_CHECK( value.GetType() == Property::NONE );
144 
145  END_TEST;
146 }
147 
149 {
150  Property::Value value(true);
151 
152  DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
153  DALI_TEST_CHECK( value.Get<bool>() == true );
154 
155  END_TEST;
156 }
157 
159 {
161 
162  DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
163  DALI_TEST_CHECK( value.Get<bool>() == false );
164 
165  END_TEST;
166 }
167 
169 {
170  Property::Value value(2.f);
171 
172  DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
173  DALI_TEST_CHECK( value.Get<float>() == 2.f );
174 
175  END_TEST;
176 }
177 
179 {
181 
182  DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
183  DALI_TEST_CHECK( value.Get<float>() == 0.f );
184 
185  END_TEST;
186 }
187 
189 {
190  Property::Value value(1);
191 
192  DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
193  DALI_TEST_CHECK( value.Get<int>() == 1 );
194 
195  END_TEST;
196 }
197 
199 {
201 
202  DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
203  DALI_TEST_CHECK( value.Get<int>() == 0 );
204 
205  END_TEST;
206 }
207 
209 {
210  Vector2 v(1,1);
211  Property::Value value(v);
212 
213  DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
214  DALI_TEST_CHECK( value.Get<Vector2>() == v );
215 
216  END_TEST;
217 }
218 
220 {
222 
223  DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
224  DALI_TEST_CHECK( value.Get<Vector2>() == Vector2::ZERO );
225 
226  END_TEST;
227 }
228 
230 {
231  Vector3 v(1.f,2.f,3.f);
232  Property::Value value(v);
233 
234  DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
235  DALI_TEST_CHECK( value.Get<Vector3>() == v );
236 
237  END_TEST;
238 }
239 
241 {
243 
244  DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
245  DALI_TEST_CHECK( value.Get<Vector3>() == Vector3() );
246 
247  END_TEST;
248 }
249 
251 {
252  Vector4 v(1.f,1.f,1.f,0.9f);
253  Property::Value value(v);
254 
255  DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
256  DALI_TEST_CHECK( value.Get<Vector4>() == v );
257 
258  END_TEST;
259 }
260 
262 {
264 
265  DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
266  DALI_TEST_CHECK( value.Get<Vector4>() == Vector4() );
267 
268  END_TEST;
269 }
270 
272 {
273  Matrix3 v(1.0,1.0,1.0, 1.0,1.0,1.0, 1.0,1.0,1.0);
274  Property::Value value(v);
275 
276  DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
277  DALI_TEST_CHECK( value.Get<Matrix3>() == v );
278 
279  END_TEST;
280 }
281 
283 {
285 
286  DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
287  DALI_TEST_CHECK( value.Get<Matrix3>() == Matrix3() );
288 
289  END_TEST;
290 }
291 
293 {
294  float a[] = {1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0};
295  Matrix v(a);
296  Property::Value value(v);
297 
298  DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
299  DALI_TEST_CHECK( value.Get<Matrix>() == v );
300 
301  END_TEST;
302 }
303 
305 {
307 
308  DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
309  DALI_TEST_CHECK( value.Get<Matrix>() == Matrix() );
310 
311  END_TEST;
312 }
313 
315 {
316  Rect<int> v(1.0,1.0,1.0,1.0);
317  Property::Value value(v);
318 
320  DALI_TEST_CHECK( value.Get<Rect<int> >() == v );
321 
322  END_TEST;
323 }
324 
326 {
328 
329  DALI_TEST_CHECK( value.GetType() == Property::RECTANGLE );
330  DALI_TEST_CHECK( value.Get<Rect<int> >() == Rect<int>(0,0,0,0) );
331 
332  END_TEST;
333 }
334 
336 {
338  Property::Value value( input );
339 
340  DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
341  AngleAxis result = value.Get<AngleAxis>();
342  DALI_TEST_EQUALS( result.angle, input.angle, TEST_LOCATION );
343  DALI_TEST_EQUALS( result.axis, input.axis, TEST_LOCATION );
344 
345  END_TEST;
346 }
347 
349 {
350  Quaternion v( Vector4(1.0,1.0,1.0,1.0) );
351  Property::Value value(v);
352 
353  DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
354  DALI_TEST_CHECK( value.Get<Quaternion>() == v );
355 
356  END_TEST;
357 }
358 
360 {
362 
363  DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
364  AngleAxis result = value.Get<AngleAxis>();
365  DALI_TEST_EQUALS( result.angle, Radian(0.f), TEST_LOCATION );
366  DALI_TEST_EQUALS( result.axis, Vector3::ZERO, TEST_LOCATION ); // identity quaternion returns a zero angle-axis
367 
368  END_TEST;
369 }
370 
372 {
373  std::string v("1");
374  Property::Value value(v);
375 
376  DALI_TEST_CHECK( value.GetType() == Property::STRING );
377  DALI_TEST_CHECK( value.Get<std::string>() == v );
378 
379  END_TEST;
380 }
381 
383 {
385 
386  DALI_TEST_CHECK( value.GetType() == Property::STRING );
387  DALI_TEST_CHECK( value.Get<std::string>() == std::string() );
388 
389  END_TEST;
390 }
391 
393 {
394  Property::Array foo;
395  Property::Value value( foo );
396 
397  DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
398  DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
399 
400  END_TEST;
401 }
402 
404 {
405  Property::Array foo;
406  foo.PushBack( Property::Value() );
407  Property::Value value( foo );
408 
409  DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
410  DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 1 );
411 
412  END_TEST;
413 }
414 
416 {
418 
419  DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
420  DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
421 
422  END_TEST;
423 }
424 
426 {
427  Property::Map map;
428  Property::Value value( map );
429 
430  DALI_TEST_CHECK( value.GetType() == Property::MAP );
431  DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
432 
433  END_TEST;
434 }
435 
437 {
438  Property::Map map;
439  map.Insert( "", "" );
440  Property::Value value( map );
441 
442  DALI_TEST_CHECK( value.GetType() == Property::MAP );
443  DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 1 );
444 
445  END_TEST;
446 }
447 
449 {
451 
452  DALI_TEST_CHECK( value.GetType() == Property::MAP );
453  DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
454 
455  END_TEST;
456 }
457 
459 {
460  Property::Value value;
461  Property::Value value2( value );
462  DALI_TEST_EQUALS( value.GetType(), value2.GetType(), TEST_LOCATION );
463  DALI_TEST_EQUALS( value.GetMap(), value2.GetMap(), TEST_LOCATION );
464  DALI_TEST_EQUALS( value.GetArray(), value2.GetArray(), TEST_LOCATION );
465  END_TEST;
466 }
467 
469 {
470  CheckCopyCtorP<bool> check(true);
471  END_TEST;
472 }
473 
475 {
476  CheckCopyCtorP<float> check(1.f);
477  END_TEST;
478 }
479 
481 {
482  CheckCopyCtorP<int> check(1);
483  END_TEST;
484 }
485 
487 {
488  CheckCopyCtorP<Vector2> check( Vector2(2,1) );
489  END_TEST;
490 }
491 
493 {
494  CheckCopyCtorP<Vector3> check( Vector3(3.f,2.f,1.f) );
495  END_TEST;
496 }
497 
499 {
500  CheckCopyCtorP<Vector3> check( Vector4(4.f,3.f,2.f,1.f) );
501  END_TEST;
502 }
503 
505 {
506  CheckCopyCtorP<Matrix3> check( Matrix3::IDENTITY );
507  END_TEST;
508 }
509 
511 {
512  CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
513  END_TEST;
514 }
515 
517 {
518  CheckCopyCtorP<Rect<int> > check( Rect<int>(1.0,1.0,1.0,1.0) );
519  END_TEST;
520 }
521 
523 {
524  CheckCopyCtorP<AngleAxis> check( AngleAxis(Degree(1.0), Vector3(1.0,1.0,1.0)) );
525  END_TEST;
526 }
527 
529 {
530  CheckCopyCtorP<Quaternion> check( Quaternion( Vector4(1.0, 1.0, 1.0, 1.0) ) );
531  END_TEST;
532 }
533 
535 {
536  CheckCopyCtorP<std::string> check( std::string("1") );
537  END_TEST;
538 }
539 
541 {
543  Property::Array* array= value1.GetArray();
544  array->PushBack(Property::Value(1));
545 
546  Property::Value value2( value1 );
547  DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
548  DALI_TEST_EQUALS( value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION );
549 
550  END_TEST;
551 }
552 
554 {
556  Property::Map* map = value1.GetMap();
557  (*map)["1"] = Property::Value(1);
558 
559  Property::Value value2( value1 );
560  DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
561  DALI_TEST_EQUALS( value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION );
562  DALI_TEST_EQUALS( value1.GetMap()->GetKey( 0 ), value2.GetMap()->GetKey( 0 ), TEST_LOCATION );
563 
564  END_TEST;
565 }
566 
568 {
569  Property::Value value;
570  Property::Value* self = &value;
571  value = *self;
572  DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
573  DALI_TEST_CHECK( value.GetMap() == NULL );
574  DALI_TEST_CHECK( value.GetArray() == NULL );
575  END_TEST;
576 }
577 
579 {
580  Property::Value value;
581  value = Property::Value(); // type match
582  DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
583  Property::Value copy( false );
584  copy = value; // type mismatch
585  DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
586  END_TEST;
587 }
588 
590 {
591  Property::Value value;
592  value = Property::Value(true); // type mismatch
593  DALI_TEST_CHECK( true == value.Get<bool>() );
594  Property::Value copy( false );
595  copy = value; // type match
596  DALI_TEST_CHECK( true == copy.Get<bool>() );
597  END_TEST;
598 }
599 
601 {
602  Property::Value value;
603  value = Property::Value(10); // type mismatch
604  DALI_TEST_CHECK( 10 == value.Get<int>() );
605  Property::Value copy( 99 );
606  copy = value; // type match
607  DALI_TEST_CHECK( 10 == copy.Get<int>() );
608  END_TEST;
609 }
610 
612 {
613  Property::Value value;
614  value = Property::Value(10.f); // mismatch
615  DALI_TEST_CHECK( Dali::Equals(10.f, value.Get<float>() ) );
616  Property::Value copy(321.f);
617  copy = value; // match
618  DALI_TEST_CHECK( Dali::Equals(10.f, copy.Get<float>() ) );
619  END_TEST;
620 }
621 
623 {
624  Property::Value value;
625  value = Property::Value( Vector2(1,2) ); // mismatch
626  DALI_TEST_CHECK( Vector2(1,2) == value.Get<Vector2>() );
628  copy = value; // match
629  DALI_TEST_CHECK( Vector2(1,2) == copy.Get<Vector2>() );
630  END_TEST;
631 }
632 
634 {
635  Property::Value value;
636  value = Property::Value( Vector3(1.f,2.f,3.f) ); // mismatch
637  DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == value.Get<Vector3>() );
639  copy = value; // match
640  DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == copy.Get<Vector3>() );
641  END_TEST;
642 }
643 
645 {
646  Property::Value value;
647  value = Property::Value( Vector4(1,2,3,4) ); // mismatch
648  DALI_TEST_CHECK( Vector4(1,2,3,4) == value.Get<Vector4>() );
649  Property::Value copy( Vector4(0,1,2,3) );
650  copy = value; // match
651  DALI_TEST_CHECK( Vector4(1,2,3,4) == copy.Get<Vector4>() );
652  END_TEST;
653 }
654 
656 {
657  Property::Value value;
658  value = Property::Value( Matrix3::IDENTITY ); // mismatch
659  DALI_TEST_CHECK( Matrix3::IDENTITY == value.Get<Matrix3>() );
661  copy = value; // match
662  DALI_TEST_CHECK( Matrix3::IDENTITY == copy.Get<Matrix3>() );
663  END_TEST;
664 }
665 
667 {
668  Property::Value value;
669  value = Property::Value( Matrix::IDENTITY ); // mismatch
670  DALI_TEST_CHECK( Matrix::IDENTITY == value.Get<Matrix>() );
671  Matrix foo;
672  Property::Value copy( foo );
673  copy = value; // match
674  DALI_TEST_CHECK( Matrix::IDENTITY == copy.Get<Matrix>() );
675  END_TEST;
676 }
677 
679 {
680  Property::Value value;
681  typedef Dali::Rect<int> Rectangle;
682  value = Property::Value( Rectangle(4,3,2,1) ); // mismatch
683  DALI_TEST_CHECK( Rectangle(4,3,2,1) == value.Get<Rectangle>() );
685  copy = value; // match
686  Rectangle copyRect;
687  copy.Get(copyRect);
688  DALI_TEST_CHECK( Rectangle(4,3,2,1) == copyRect );
689  END_TEST;
690 }
691 
693 {
694  Property::Value value;
695  value = Property::Value( Quaternion(1,1,1,1) ); // mismatch
696  DALI_TEST_CHECK( Quaternion(1,1,1,1) == value.Get<Quaternion>() );
698  copy = value; // match
699  DALI_TEST_CHECK( Quaternion(1,1,1,1) == copy.Get<Quaternion>() );
700  END_TEST;
701 }
702 
703 
705 {
706  Property::Value value;
707  value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS ) ); // mismatch
711  copy = value; // match
712  DALI_TEST_EQUALS( value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION );
713  DALI_TEST_EQUALS( value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION );
714  END_TEST;
715 }
716 
718 {
719  Property::Value value;
720  value = Property::Value("yes"); // mismatch
721  DALI_TEST_CHECK( "yes" == value.Get<std::string>() );
722  Property::Value copy("no");
723  copy = value; // match
724  DALI_TEST_CHECK( "yes" == copy.Get<std::string>() );
725  END_TEST;
726 }
727 
729 {
730  Property::Value value;
731  value = Property::Value(Property::ARRAY); // mismatch
732  value.GetArray()->PushBack(10);
733  DALI_TEST_CHECK( value.GetArray() );
735  copy = value; // match
736  Property::Array array;
737  copy.Get( array );
738  int getItem = 0;
739  array[0].Get( getItem );
740  DALI_TEST_CHECK( getItem == 10 );
741  END_TEST;
742 }
743 
745 {
746  Property::Value value;
747  value = Property::Value(Property::MAP); // mismatch
748  value.GetMap()->Insert("key", "value");
749  Property::Value copy( Property::MAP ); // match
750  copy = value;
751  Property::Map map;
752  copy.Get( map );
753  DALI_TEST_CHECK( map.GetKey(0) == "key" );
754  END_TEST;
755 }
756 
758 {
759  Property::Value value;
760  DALI_TEST_CHECK( value.GetType() == Property::NONE );
761  END_TEST;
762 }
763 
765 {
766  Property::Value value(true);
767  bool boolean( false );
768  DALI_TEST_CHECK( value.Get( boolean ) == true );
769  DALI_TEST_CHECK( value.Get<bool>() == true );
770  std::string string;
771  DALI_TEST_CHECK( value.Get( string ) == false );
772  value = Property::Value(1.f);
773  DALI_TEST_CHECK( value.Get<float>() == 1.f );
774  END_TEST;
775 }
776 
778 {
779  Property::Value value;
780  DALI_TEST_CHECK( value.Get<bool>() == false );
781  bool boolean( false );
782  DALI_TEST_CHECK( value.Get( boolean ) == false );
783  END_TEST;
784 }
785 
787 {
788  Property::Value value(1.1f);
789  float flow( 0.0f );
790  DALI_TEST_EQUALS( 1.1f, value.Get<float>(), TEST_LOCATION );
791  DALI_TEST_EQUALS( true, value.Get( flow ), TEST_LOCATION );
792  DALI_TEST_EQUALS( 1.1f, flow, TEST_LOCATION );
793 
794  Property::Value intValue(100);
795  DALI_TEST_EQUALS( 100.f, intValue.Get<float>(), TEST_LOCATION );
796  DALI_TEST_EQUALS( true, intValue.Get( flow ), TEST_LOCATION );
797  DALI_TEST_EQUALS( 100.f, flow, TEST_LOCATION );
798 
799  END_TEST;
800 }
801 
803 {
804  Property::Value value;
805  float result( 1.0f );
806  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
807  DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
808  Property::Value value2( "" );
809  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
810  DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
811  END_TEST;
812 }
813 
815 {
816  Property::Value value(123);
817  int result( 10 );
818  DALI_TEST_EQUALS( 123, value.Get<int>(), TEST_LOCATION );
819  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
820  DALI_TEST_EQUALS( 123, result, TEST_LOCATION );
821 
822  Property::Value floatValue(21.f);
823  DALI_TEST_EQUALS( 21, floatValue.Get<int>(), TEST_LOCATION );
824  DALI_TEST_EQUALS( true, floatValue.Get( result ), TEST_LOCATION );
825  DALI_TEST_EQUALS( 21, result, TEST_LOCATION );
826 
827  END_TEST;
828 }
829 
831 {
832  Property::Value value;
833  int result( 10 );
834  DALI_TEST_EQUALS( 0, value.Get<int>(), TEST_LOCATION );
835  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
836  DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
838  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
839  DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
840  END_TEST;
841 }
842 
844 {
845  Property::Value value( Rect<int>(1,2,3,4) );
846  Rect<int> result(4,3,2,1);
847  DALI_TEST_EQUALS( Rect<int>(1,2,3,4), value.Get< Rect<int> >(), TEST_LOCATION );
848  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
849  DALI_TEST_EQUALS( Rect<int>(1,2,3,4), result, TEST_LOCATION );
850  END_TEST;
851 }
852 
854 {
855  Property::Value value;
856  Rect<int> result(4,3,2,1);
857  DALI_TEST_EQUALS( Rect<int>(0,0,0,0), value.Get< Rect<int> >(), TEST_LOCATION );
858  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
859  DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
861  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
862  DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
863  END_TEST;
864 }
865 
867 {
868  Property::Value value( Vector2(1.0f,2.0f) );
869  Vector2 result;
870  DALI_TEST_EQUALS( Vector2(1.0f,2.0f), value.Get< Vector2 >(), TEST_LOCATION );
871  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
872  DALI_TEST_EQUALS( Vector2(1.0f,2.0f), result, TEST_LOCATION );
873  END_TEST;
874 }
875 
877 {
878  Property::Value value;
879  Vector2 result;
880  DALI_TEST_EQUALS( Vector2(0.f,0.f), value.Get< Vector2 >(), TEST_LOCATION );
881  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
882  DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
884  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
885  DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
886  END_TEST;
887 }
888 
890 {
891  Property::Value value( Vector3(1.0f,2.0f,-1.f) );
892  Vector3 result;
893  DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), value.Get< Vector3 >(), TEST_LOCATION );
894  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
895  DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), result, TEST_LOCATION );
896  END_TEST;
897 }
898 
900 {
901  Property::Value value;
902  Vector3 result;
903  DALI_TEST_EQUALS( Vector3(0.f,0.f,0.f), value.Get< Vector3 >(), TEST_LOCATION );
904  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
905  DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
907  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
908  DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
909  END_TEST;
910 }
911 
913 {
914  Property::Value value( Vector4(1.f,2.f,-1.f,-3.f) );
915  Vector4 result;
916  DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), value.Get< Vector4 >(), TEST_LOCATION );
917  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
918  DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), result, TEST_LOCATION );
919  END_TEST;
920 }
921 
923 {
924  Property::Value value;
925  Vector4 result;
926  DALI_TEST_EQUALS( Vector4(0.f,0.f,0.f,0.f), value.Get< Vector4 >(), TEST_LOCATION );
927  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
928  DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
930  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
931  DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
932  END_TEST;
933 }
934 
936 {
937  Property::Value value( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f) );
938  Matrix3 result;
939  DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), value.Get< Matrix3 >(), TEST_LOCATION );
940  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
941  DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
942  END_TEST;
943 }
944 
946 {
947  Property::Value value;
948  Matrix3 result(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f);
949  DALI_TEST_EQUALS( Matrix3(), value.Get< Matrix3 >(), TEST_LOCATION );
950  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
951  DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
953  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
954  DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
955  END_TEST;
956 }
957 
959 {
960  float matrixValues[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
961  Matrix input( matrixValues );
962  Property::Value value( input );
963  Matrix result;
964  DALI_TEST_EQUALS( input, value.Get< Matrix >(), TEST_LOCATION );
965  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
966  DALI_TEST_EQUALS( input, result, TEST_LOCATION );
967  END_TEST;
968 }
969 
971 {
972  Property::Value value;
973  Matrix result( Matrix::IDENTITY );
974  DALI_TEST_EQUALS( Matrix(), value.Get< Matrix >(), TEST_LOCATION );
975  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
977 
979  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
981  END_TEST;
982 }
983 
985 {
987  Property::Value value( input );
988  AngleAxis result = value.Get<AngleAxis>();
989  DALI_TEST_EQUALS( input.angle, result.angle, TEST_LOCATION );
990  DALI_TEST_EQUALS( input.axis, result.axis, TEST_LOCATION );
991 
992  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
993  DALI_TEST_EQUALS( input, result, TEST_LOCATION );
994  END_TEST;
995 }
996 
998 {
999  Property::Value value;
1000  AngleAxis b = value.Get<AngleAxis>();
1001  AngleAxis result;
1004  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1006 
1007  Property::Value value2("");
1008  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1010  END_TEST;
1011 }
1012 
1014 {
1015  Property::Value value( Quaternion(1.f,2.f,3.f,4.f) );
1016  Quaternion result;
1017  DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), value.Get< Quaternion >(), TEST_LOCATION );
1018  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1019  DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1020  END_TEST;
1021 }
1022 
1024 {
1025  Property::Value value;
1026  Quaternion result(1.f,2.f,3.f,4.f);
1027  DALI_TEST_EQUALS( Quaternion(), value.Get< Quaternion >(), TEST_LOCATION );
1028  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1029  DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1030 
1031  Property::Value value2("");
1032  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1033  DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1034  END_TEST;
1035 }
1036 
1038 {
1039  Property::Value value( std::string("hello") );
1040  std::string result;
1041  DALI_TEST_EQUALS( std::string("hello"), value.Get< std::string >(), TEST_LOCATION );
1042  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1043  DALI_TEST_EQUALS( std::string("hello"), result, TEST_LOCATION );
1044 
1045  Property::Value value2( "C hi!" );
1046  DALI_TEST_EQUALS( "C hi!", value2.Get< std::string >(), TEST_LOCATION );
1047  DALI_TEST_EQUALS( true, value2.Get( result ), TEST_LOCATION );
1048  DALI_TEST_EQUALS( "C hi!", result, TEST_LOCATION );
1049  END_TEST;
1050 }
1051 
1053 {
1054  Property::Value value;
1055  std::string result("doesn't change");
1056  DALI_TEST_EQUALS( std::string(), value.Get< std::string >(), TEST_LOCATION );
1057  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1058  DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
1059 
1060  Property::Value value2(10);
1061  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1062  DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
1063 
1064  Property::Value value3((char*)NULL);
1065  DALI_TEST_EQUALS( true, value3.Get( result ), TEST_LOCATION );
1066  DALI_TEST_EQUALS( std::string(), result, TEST_LOCATION );
1067  END_TEST;
1068 }
1069 
1071 {
1073  DALI_TEST_CHECK( NULL != value.GetArray() );
1074  value.GetArray()->PushBack( Property::Value(1) );
1075  Property::Array got = value.Get<Property::Array>();
1076  DALI_TEST_CHECK( got[0].Get<int>() == 1);
1077  Property::Array result;
1078  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1079  DALI_TEST_CHECK( result[0].Get<int>() == 1);
1080  END_TEST;
1081 }
1082 
1084 {
1085  Property::Value value;
1086  DALI_TEST_CHECK( NULL == value.GetArray() );
1087  Property::Array result;
1088  result.PushBack( Property::Value( 10 ) );
1089  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1090  DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
1091 
1092  Property::Value value2("");
1093  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1094  DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
1095  END_TEST;
1096 }
1097 
1099 {
1101  DALI_TEST_CHECK( NULL == value.GetArray() );
1102  DALI_TEST_CHECK( NULL != value.GetMap() );
1103  value.GetMap()->Insert("key", Property::Value(1));
1104  Property::Map result = value.Get<Property::Map>();
1105  DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1106  DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1107  DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1108  END_TEST;
1109 }
1110 
1112 {
1113  Property::Value value;
1114  DALI_TEST_CHECK( NULL == value.GetMap() );
1115  DALI_TEST_EQUALS( 0u, value.Get<Property::Map>().Count(), TEST_LOCATION );
1116  Property::Map result;
1117  result.Insert("key", "value" );
1118  DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1119  DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION );
1120 
1121  Property::Value value2("");
1122  DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1123  DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
1124  END_TEST;
1125 }
1126 
1128 {
1129  TestApplication application;
1130  tet_infoline("Testing Property::Value output stream");
1131  typedef Dali::Rect<int> Rectangle;
1132 
1133  Property::Value value(true);
1134  {
1135  std::ostringstream stream;
1136  stream << value;
1137  DALI_TEST_CHECK( stream.str() == "1" )
1138  }
1139 
1140  {
1141  Property::Value empty;
1142  std::ostringstream stream;
1143  stream << empty;
1144  DALI_TEST_EQUALS( stream.str(), "empty type", TEST_LOCATION );
1145  }
1146 
1147  {
1149  std::ostringstream stream;
1150  stream << empty;
1151  DALI_TEST_CHECK( stream.str() == "undefined type" )
1152  }
1153 
1154  {
1155  value = Property::Value(20.2f);
1156  std::ostringstream stream;
1157  stream << value;
1158  DALI_TEST_CHECK( stream.str() == "20.2" )
1159  }
1160 
1161  {
1162  value = Property::Value(-25);
1163  std::ostringstream stream;
1164  stream << value;
1165  DALI_TEST_CHECK( stream.str() == "-25" )
1166  }
1167 
1168  {
1169  value = Property::Value( Vector2(1.f,1.f) );
1170  std::ostringstream stream;
1171  stream << value;
1172  DALI_TEST_CHECK( stream.str() == "[1, 1]" );
1173  }
1174 
1175  {
1176  value = Property::Value( Vector3(1.f,1.f,1.f) );
1177  std::ostringstream stream;
1178  stream << value;
1179  DALI_TEST_CHECK( stream.str() == "[1, 1, 1]" );
1180  }
1181 
1182  {
1183  value = Property::Value( Vector4(-4.f,-3.f,-2.f,-1.f) );
1184  std::ostringstream stream;
1185  stream << value;
1186  DALI_TEST_EQUALS( stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION );
1187  }
1188 
1189  {
1191  std::ostringstream stream;
1192  stream << value;
1193  DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0], [0, 1, 0], [0, 0, 1] ]" );
1194  }
1195 
1196  {
1197  value = Property::Value( Matrix::IDENTITY );
1198  std::ostringstream stream;
1199  stream << value;
1200  DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]" );
1201  }
1202 
1203  {
1204  value = Property::Value( Rectangle(1,2,3,4) );
1205  std::ostringstream stream;
1206  stream << value;
1207  DALI_TEST_CHECK( stream.str() == "[1, 2, 3, 4]" );
1208  }
1209 
1210  {
1212  std::ostringstream stream;
1213  stream << value;
1214  tet_printf("angle axis = %s \n", stream.str().c_str() );
1215  DALI_TEST_EQUALS( stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION );
1216  }
1217 
1218  {
1219  value = Property::Value( std::string( "Foo" ) );
1220  std::ostringstream stream;
1221  stream << value;
1222  DALI_TEST_CHECK( stream.str() == "Foo" );
1223  }
1224 
1225  // Maps and arrays currently not supported, we just check a message is output
1226  {
1227  Property::Map map;
1228  value = Property::Value( map );
1229  std::ostringstream stream;
1230  stream << value;
1231  DALI_TEST_CHECK( !stream.str().empty() );
1232  }
1233  {
1234  Property::Array array;
1235  value = Property::Value( array );
1236  std::ostringstream stream;
1237  stream << value;
1238  DALI_TEST_CHECK( !stream.str().empty() );
1239  }
1240 
1241  END_TEST;
1242 }
Dali Docs Home
Read more about Dali