2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <dali-test-suite-utils.h>
19 #include <dali/public-api/dali-core.h>
27 void utc_dali_property_map_startup(void)
29 test_return_value = TET_UNDEF;
32 void utc_dali_property_map_cleanup(void)
34 test_return_value = TET_PASS;
37 int UtcDaliPropertyMapPopulate(void)
40 DALI_TEST_CHECK(map.Empty());
44 map["world"] = "world";
46 map["world"] = 3; // same item as line above
47 DALI_TEST_CHECK(!map.Empty()); // Should no longer be empty
48 DALI_TEST_CHECK(map.Count() == 4); // Should only have four items, not five!!
49 DALI_TEST_CHECK(map["hello"].Get<int>() == 1);
50 DALI_TEST_CHECK(map["world"].Get<int>() == 3);
51 DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
52 DALI_TEST_CHECK(map[100].Get<int>() == 9);
55 DALI_TEST_CHECK(map.Empty());
59 int UtcDaliPropertyMapCopyAndAssignment(void)
66 Property::Map assignedMap;
67 assignedMap["foo"] = 3;
69 DALI_TEST_CHECK(assignedMap.Count() == 2);
71 DALI_TEST_CHECK(assignedMap.Count() == 3);
73 Property::Map copiedMap(map);
74 DALI_TEST_CHECK(copiedMap.Count() == 3);
77 DALI_TEST_CHECK(map.Count() == 3);
79 DALI_TEST_CHECK(map.Count() == 3);
84 int UtcDaliPropertyMapMoveConstructor(void)
90 DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
92 Property::Map map2(std::move(map1));
93 DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
95 // Calling any methods on map1 will debug assert
96 const char* exceptionMessage = "Cannot use an object previously used as an r-value";
97 DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
98 DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
99 DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
100 DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
101 DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
102 DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
103 DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
104 DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
105 DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
106 DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
107 DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
108 DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
109 DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
110 DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
111 DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
112 DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
113 DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
114 DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
115 DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
116 DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
117 DALI_TEST_ASSERTION(map1[0], exceptionMessage);
118 DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
119 DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
124 int UtcDaliPropertyMapMoveAssignmentOperator(void)
130 DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
133 map2[10] = "DALi again";
134 DALI_TEST_EQUALS(1u, map2.Count(), TEST_LOCATION);
136 map2 = std::move(map1);
137 DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
139 // Calling any methods on map1 will debug assert
140 const char* exceptionMessage = "Cannot use an object previously used as an r-value";
141 DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
142 DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
143 DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
144 DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
145 DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
146 DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
147 DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
148 DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
149 DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
150 DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
151 DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
152 DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
153 DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
154 DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
155 DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
156 DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
157 DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
158 DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
159 DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
160 DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
161 DALI_TEST_ASSERTION(map1[0], exceptionMessage);
162 DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
163 DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
166 map2 = std::move(map2);
167 DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION); // No debug assert as nothing should happen
172 int UtcDaliPropertyMapConstOperator(void)
178 DALI_TEST_CHECK(map.Count() == 3);
180 const Property::Map& constMap(map);
181 DALI_TEST_CHECK(constMap["world"].Get<int>() == 2);
182 DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
184 DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
185 DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
190 constMap["invalidKey"];
191 tet_result(TET_FAIL);
193 catch(DaliException& e)
195 DALI_TEST_ASSERT(e, "!\"Invalid Key\"", TEST_LOCATION);
201 int UtcDaliPropertyMapGetValue(void)
206 map[Actor::Property::COLOR] = Color::MAGENTA;
208 Property::Value& value = map.GetValue(0);
209 DALI_TEST_CHECK(value.Get<int>() == 1);
210 value = 10; // Allows the actual changing of the value as we have a ref
211 DALI_TEST_CHECK(map["hello"].Get<int>() == 10);
213 Property::Value& value2 = map.GetValue(2);
214 DALI_TEST_CHECK(value2.Get<Vector4>() == Color::MAGENTA);
215 value2 = Color::CYAN;
216 DALI_TEST_EQUALS(map[Actor::Property::COLOR].Get<Vector4>(), Color::CYAN, TEST_LOCATION);
222 tet_result(TET_FAIL);
224 catch(DaliException& e)
226 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
232 // deprecated API, only retrieve the key from the string-value pairs
233 int UtcDaliPropertyMapGetKey(void)
238 map[Actor::Property::COLOR] = Color::MAGENTA;
240 DALI_TEST_CHECK(map.GetKey(0) == "hello");
241 DALI_TEST_CHECK(map.GetKey(1) == "world");
247 tet_result(TET_FAIL);
249 catch(DaliException& e)
251 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
258 tet_result(TET_FAIL);
260 catch(DaliException& e)
262 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
268 int UtcDaliPropertyMapGetKeyAt(void)
273 map[Actor::Property::COLOR] = Color::MAGENTA;
275 DALI_TEST_CHECK(map.GetKeyAt(0) == "hello");
276 DALI_TEST_CHECK(map.GetKeyAt(1) == "world");
277 DALI_TEST_CHECK(map.GetKeyAt(2) == Actor::Property::COLOR);
283 tet_result(TET_FAIL);
285 catch(DaliException& e)
287 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
293 int UtcDaliPropertyMapGetPair(void)
298 map[Actor::Property::COLOR] = Color::MAGENTA;
300 DALI_TEST_CHECK(map.GetPair(0).first == "hello");
301 DALI_TEST_CHECK(map.GetPair(0).second.Get<int>() == 1);
302 DALI_TEST_CHECK(map.GetPair(1).first == "world");
303 DALI_TEST_CHECK(map.GetPair(1).second.Get<int>() == 2);
309 tet_result(TET_FAIL);
311 catch(DaliException& e)
313 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
320 tet_result(TET_FAIL);
322 catch(DaliException& e)
324 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
330 int UtcDaliPropertyMapGetKeyValue(void)
335 map[Actor::Property::COLOR] = Color::MAGENTA;
337 DALI_TEST_CHECK(map.GetKeyValue(0).first == "hello");
338 DALI_TEST_CHECK(map.GetKeyValue(0).second.Get<int>() == 1);
339 DALI_TEST_CHECK(map.GetKeyValue(1).first == "world");
340 DALI_TEST_CHECK(map.GetKeyValue(1).second.Get<int>() == 2);
341 DALI_TEST_CHECK(map.GetKeyValue(2).first == Actor::Property::COLOR);
342 DALI_TEST_CHECK(map.GetKeyValue(2).second.Get<Vector4>() == Color::MAGENTA);
348 tet_result(TET_FAIL);
350 catch(DaliException& e)
352 DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
358 int UtcDaliPropertyMapFind(void)
366 Property::Value* value = NULL;
368 value = map.Find("hello");
369 DALI_TEST_CHECK(value);
370 DALI_TEST_CHECK(value->Get<int>() == 1);
372 const std::string world("world");
373 value = map.Find(world);
374 DALI_TEST_CHECK(value);
375 DALI_TEST_CHECK(value->Get<int>() == 2);
377 value = map.Find(100);
378 DALI_TEST_CHECK(value);
379 DALI_TEST_CHECK(value->Get<int>() == 9);
381 value = map.Find(10, Property::STRING);
382 DALI_TEST_CHECK(value);
383 DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
385 value = map.Find(10, Property::INTEGER);
386 DALI_TEST_CHECK(value == NULL);
388 value = map.Find("invalidKey");
389 DALI_TEST_CHECK(!value);
394 int UtcDaliPropertyMapFindIndexThenString(void)
396 // Define the valid keys and values to test with.
397 std::string stringKeyValid = "bar";
398 std::string stringKeyInvalid = "aardvark";
399 int indexKeyValid = 100;
400 int indexKeyInvalid = 101;
402 // Define invalid key and value to test with.
403 std::string stringValueValid = "DALi";
404 int indexValueValid = 3;
406 // Set up a property map containing the valid keys and values defined above.
410 map[stringKeyValid] = stringValueValid;
411 map[indexKeyValid] = indexValueValid;
413 Property::Value* value = NULL;
415 // TEST: If both index and string are valid, the Property::Value of the index is returned.
416 value = map.Find(indexKeyValid, stringKeyValid);
418 DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
420 // TEST: If only the index is valid, the Property::Value of the index is returned.
421 value = map.Find(indexKeyValid, stringKeyInvalid);
423 DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
425 // TEST: If only the string is valid, the Property::Value of the string is returned.
426 value = map.Find(indexKeyInvalid, stringKeyValid);
428 DALI_TEST_EQUALS(value->Get<std::string>(), stringValueValid, TEST_LOCATION);
430 // TEST: If neither the index or string are valid, then a NULL pointer is returned.
431 value = map.Find(indexKeyInvalid, stringKeyInvalid);
433 DALI_TEST_CHECK(value == NULL);
438 int UtcDaliPropertyMapOperatorIndex(void)
446 const Property::Map map2 = map;
447 const Property::Value& value10 = map2[10];
448 DALI_TEST_EQUALS(value10.Get<std::string>(), "DALi", TEST_LOCATION);
450 const Property::Value& value100 = map2[100];
451 DALI_TEST_EQUALS(value100.Get<int>(), 9, TEST_LOCATION);
453 const Property::Value& valueHello = map2["hello"];
454 DALI_TEST_EQUALS(valueHello.Get<int>(), 1, TEST_LOCATION);
459 int UtcDaliPropertyMapInsertP(void)
462 DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
463 map.Insert("foo", "bar");
464 DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
465 Property::Value* value = map.Find("foo");
466 DALI_TEST_CHECK(value);
467 DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
469 map.Insert(std::string("foo2"), "testing");
470 DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
471 value = map.Find("foo2");
472 DALI_TEST_CHECK(value);
473 DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
475 map.Insert(10, "DALi");
476 DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
477 value = map.Find(10);
478 DALI_TEST_CHECK(value);
479 DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
482 DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
483 value = map.Find(100);
484 DALI_TEST_CHECK(value);
485 DALI_TEST_CHECK(value->Get<int>() == 9);
490 int UtcDaliPropertyMapAddP(void)
493 DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
494 map.Add("foo", "bar");
495 DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
496 Property::Value* value = map.Find("foo");
497 DALI_TEST_CHECK(value);
498 DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
500 map.Add(std::string("foo2"), "testing");
501 DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
502 value = map.Find("foo2");
503 DALI_TEST_CHECK(value);
504 DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
507 DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
508 value = map.Find(10);
509 DALI_TEST_CHECK(value);
510 DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
513 DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
514 value = map.Find(100);
515 DALI_TEST_CHECK(value);
516 DALI_TEST_CHECK(value->Get<int>() == 9);
521 int UtcDaliPropertyMapAddChainP(void)
524 DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
527 .Add(std::string("foo2"), "testing")
531 DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
533 Property::Value* value = map.Find("foo");
534 DALI_TEST_CHECK(value);
535 DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
537 value = map.Find("foo2");
538 DALI_TEST_CHECK(value);
539 DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
541 value = map.Find(10);
542 DALI_TEST_CHECK(value);
543 DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
545 value = map.Find(100);
546 DALI_TEST_CHECK(value);
547 DALI_TEST_CHECK(value->Get<int>() == 9);
552 int UtcDaliPropertyMapAnonymousAddChainP(void)
557 TestMap(Property::Map map)
564 TestMap mapTest(Property::Map().Add("foo", "bar").Add(std::string("foo2"), "testing").Add(10, "DALi").Add(100, 9));
566 Property::Value* value = mapTest.mMap.Find("foo");
567 DALI_TEST_CHECK(value);
568 DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
570 value = mapTest.mMap.Find("foo2");
571 DALI_TEST_CHECK(value);
572 DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
574 value = mapTest.mMap.Find(10);
575 DALI_TEST_CHECK(value);
576 DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
578 value = mapTest.mMap.Find(100);
579 DALI_TEST_CHECK(value);
580 DALI_TEST_CHECK(value->Get<int>() == 9);
585 int UtcDaliPropertyMapMerge(void)
592 DALI_TEST_CHECK(map.Count() == 3);
594 // Create another map with the same keys but different values
598 map[10] = "3DEngine";
600 // Merge map2 into map1, count should still be 2, map values should be from map2
602 DALI_TEST_CHECK(map.Count() == 3);
603 DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
604 DALI_TEST_CHECK(map["world"].Get<int>() == 4);
605 DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
607 // Create another map with different keys
612 // Merge map3 into map1, count should increase, existing values should match previous and new values should match map3
614 DALI_TEST_CHECK(map.Count() == 5);
615 DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
616 DALI_TEST_CHECK(map["world"].Get<int>() == 4);
617 DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
618 DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
619 DALI_TEST_CHECK(map[100].Get<int>() == 6);
621 // Create an empty map and attempt to merge, should be successful, nothing should change
623 DALI_TEST_CHECK(map4.Empty());
625 DALI_TEST_CHECK(map4.Empty());
626 DALI_TEST_CHECK(map.Count() == 5);
627 DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
628 DALI_TEST_CHECK(map["world"].Get<int>() == 4);
629 DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
630 DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
631 DALI_TEST_CHECK(map[100].Get<int>() == 6);
633 // Merge map into map4, map4 should be the same as map now.
635 DALI_TEST_CHECK(map4.Count() == 5);
636 DALI_TEST_CHECK(map4["hello"].Get<int>() == 3);
637 DALI_TEST_CHECK(map4["world"].Get<int>() == 4);
638 DALI_TEST_CHECK(map4["foo"].Get<int>() == 5);
639 DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
640 DALI_TEST_CHECK(map4[100].Get<int>() == 6);
642 // Attempt to merge into itself, should be successful, nothing should change
644 DALI_TEST_CHECK(map.Count() == 5);
645 DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
646 DALI_TEST_CHECK(map["world"].Get<int>() == 4);
647 DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
648 DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
649 DALI_TEST_CHECK(map[100].Get<int>() == 6);
654 int UtcDaliPropertyMapOstream01(void)
658 map.Insert("duration", 5.0f);
659 map.Insert(10, "DALi");
660 map.Insert("delay", 1.0f);
662 map.Insert("value", 100);
664 std::ostringstream oss;
667 tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
669 // string-value pairs first, then index-value pairs
670 DALI_TEST_EQUALS(oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION);
675 int UtcDaliPropertyMapOstream02(void)
677 Property::Map map, map2;
679 map2.Insert("duration", 5.0f);
680 map2.Insert("delay", 1.0f);
681 map2.Insert(10, "DALi");
682 map.Insert("timePeriod", map2);
684 map.Insert("value", 100);
686 std::ostringstream oss;
689 tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
691 // string-value pairs first, then index-value pairs
692 DALI_TEST_EQUALS(oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION);
697 int UtcDaliPropertyKeyConstructorP(void)
699 Property::Key key1("aKey");
700 DALI_TEST_EQUALS(key1.type, Property::Key::STRING, TEST_LOCATION);
701 DALI_TEST_EQUALS(key1.stringKey, "aKey", TEST_LOCATION);
702 DALI_TEST_EQUALS(key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION);
704 Property::Key key2(Actor::Property::COLOR);
705 DALI_TEST_EQUALS(key2.type, Property::Key::INDEX, TEST_LOCATION);
706 DALI_TEST_EQUALS(key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION);
710 int UtcDaliPropertyKeyEqualityOperatorP(void)
712 Property::Key key1("aKey");
713 Property::Key key2(113);
715 DALI_TEST_CHECK(key1 == "aKey");
716 DALI_TEST_CHECK(!(key1 == "notTheKey"));
717 DALI_TEST_CHECK(!(key1 == 1));
719 DALI_TEST_CHECK(key2 == 113);
720 DALI_TEST_CHECK(!(key2 == 0));
721 DALI_TEST_CHECK(!(key2 == "One hundred and thirteen"));
723 DALI_TEST_CHECK(!(key1 == key2));
724 DALI_TEST_CHECK(key1 != key2);
726 Property::Key key1B("aKey");
727 Property::Key key2B(113);
729 DALI_TEST_CHECK(key1 == key1B);
730 DALI_TEST_CHECK(key2 == key2B);
735 int UtcDaliPropertyKeyInequalityOperatorP(void)
737 Property::Key key1("aKey");
738 Property::Key key2(113);
740 DALI_TEST_CHECK(key1 != "notTheKey");
741 DALI_TEST_CHECK(key1 != 1);
743 DALI_TEST_CHECK(key2 != 0);
744 DALI_TEST_CHECK(key2 != "One hundred and thirteen");
746 DALI_TEST_CHECK(key1 != key2);
751 int UtcDaliPropertyKeyOutputStream(void)
753 Property::Key key1("aKey");
754 Property::Key key2(113);
756 std::ostringstream oss;
758 DALI_TEST_EQUALS(oss.str(), "aKey", TEST_LOCATION);
760 std::ostringstream oss2;
762 DALI_TEST_EQUALS(oss2.str(), "113", TEST_LOCATION);
767 int UtcDaliPropertyMapInitializerListConstructor(void)
769 auto map = Property::Map{
770 {"number mapped to string", 1},
771 {10, "string mapped to number"},
772 {"string mapped", "to string"},
776 DALI_TEST_CHECK(!map.Empty()); // Should not be empty
777 DALI_TEST_EQUALS(4, map.Count(), TEST_LOCATION); // Should have four items
779 DALI_TEST_EQUALS(1, map["number mapped to string"].Get<int>(), TEST_LOCATION);
780 DALI_TEST_EQUALS("string mapped to number", map[10].Get<std::string>(), TEST_LOCATION);
781 DALI_TEST_EQUALS("to string", map["string mapped"].Get<std::string>(), TEST_LOCATION);
782 DALI_TEST_EQUALS(3, map[100].Get<int>(), TEST_LOCATION);
787 int UtcDaliPropertyMapNestedInitializerListConstructor(void)
789 auto map = Property::Map{
792 {3, {{3, {{3, 3}}}}}};
794 DALI_TEST_CHECK(!map.Empty());
795 DALI_TEST_EQUALS(3, map.Count(), TEST_LOCATION);
799 DALI_TEST_EQUALS(1, map[1].Get<int>(), TEST_LOCATION);
804 auto& value1 = map[2];
805 DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
807 auto& map2 = *(value1.GetMap());
808 DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
811 DALI_TEST_EQUALS(2, map2[2].Get<int>(), TEST_LOCATION);
814 // Check the third item
816 auto& value1 = map[3];
817 DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
819 auto& map2 = *(value1.GetMap());
820 DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
822 auto& value2 = map2[3];
823 DALI_TEST_EQUALS(Property::MAP, value2.GetType(), TEST_LOCATION);
825 auto& map3 = *(value2.GetMap());
826 DALI_TEST_EQUALS(1, map3.Count(), TEST_LOCATION);
829 DALI_TEST_EQUALS(3, map3[3].Get<int>(), TEST_LOCATION);