summaryrefslogtreecommitdiff
path: root/tests/core/variant
diff options
context:
space:
mode:
Diffstat (limited to 'tests/core/variant')
-rw-r--r--tests/core/variant/test_array.h521
-rw-r--r--tests/core/variant/test_dictionary.h523
-rw-r--r--tests/core/variant/test_variant.h978
3 files changed, 2022 insertions, 0 deletions
diff --git a/tests/core/variant/test_array.h b/tests/core/variant/test_array.h
new file mode 100644
index 0000000000..6093048307
--- /dev/null
+++ b/tests/core/variant/test_array.h
@@ -0,0 +1,521 @@
+/*************************************************************************/
+/* test_array.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef TEST_ARRAY_H
+#define TEST_ARRAY_H
+
+#include "core/variant/array.h"
+#include "tests/test_macros.h"
+#include "tests/test_tools.h"
+
+namespace TestArray {
+
+static inline Array build_array() {
+ return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+ Array a = build_array(Fargs...);
+ a.push_front(item);
+ return a;
+}
+static inline Dictionary build_dictionary() {
+ return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+ Dictionary d = build_dictionary(Fargs...);
+ d[key] = item;
+ return d;
+}
+
+TEST_CASE("[Array] size(), clear(), and is_empty()") {
+ Array arr;
+ CHECK(arr.size() == 0);
+ CHECK(arr.is_empty());
+ arr.push_back(1);
+ CHECK(arr.size() == 1);
+ arr.clear();
+ CHECK(arr.is_empty());
+ CHECK(arr.size() == 0);
+}
+
+TEST_CASE("[Array] Assignment and comparison operators") {
+ Array arr1;
+ Array arr2;
+ arr1.push_back(1);
+ CHECK(arr1 != arr2);
+ CHECK(arr1 > arr2);
+ CHECK(arr1 >= arr2);
+ arr2.push_back(2);
+ CHECK(arr1 != arr2);
+ CHECK(arr1 < arr2);
+ CHECK(arr1 <= arr2);
+ CHECK(arr2 > arr1);
+ CHECK(arr2 >= arr1);
+ Array arr3 = arr2;
+ CHECK(arr3 == arr2);
+}
+
+TEST_CASE("[Array] append_array()") {
+ Array arr1;
+ Array arr2;
+ arr1.push_back(1);
+ arr1.append_array(arr2);
+ CHECK(arr1.size() == 1);
+ arr2.push_back(2);
+ arr1.append_array(arr2);
+ CHECK(arr1.size() == 2);
+ CHECK(int(arr1[0]) == 1);
+ CHECK(int(arr1[1]) == 2);
+}
+
+TEST_CASE("[Array] resize(), insert(), and erase()") {
+ Array arr;
+ arr.resize(2);
+ CHECK(arr.size() == 2);
+ arr.insert(0, 1);
+ CHECK(int(arr[0]) == 1);
+ arr.insert(0, 2);
+ CHECK(int(arr[0]) == 2);
+ arr.erase(2);
+ CHECK(int(arr[0]) == 1);
+}
+
+TEST_CASE("[Array] front() and back()") {
+ Array arr;
+ arr.push_back(1);
+ CHECK(int(arr.front()) == 1);
+ CHECK(int(arr.back()) == 1);
+ arr.push_back(3);
+ CHECK(int(arr.front()) == 1);
+ CHECK(int(arr.back()) == 3);
+}
+
+TEST_CASE("[Array] has() and count()") {
+ Array arr;
+ arr.push_back(1);
+ arr.push_back(1);
+ CHECK(arr.has(1));
+ CHECK(!arr.has(2));
+ CHECK(arr.count(1) == 2);
+ CHECK(arr.count(2) == 0);
+}
+
+TEST_CASE("[Array] remove_at()") {
+ Array arr;
+ arr.push_back(1);
+ arr.push_back(2);
+ arr.remove_at(0);
+ CHECK(arr.size() == 1);
+ CHECK(int(arr[0]) == 2);
+ arr.remove_at(0);
+ CHECK(arr.size() == 0);
+
+ // The array is now empty; try to use `remove_at()` again.
+ // Normally, this prints an error message so we silence it.
+ ERR_PRINT_OFF;
+ arr.remove_at(0);
+ ERR_PRINT_ON;
+
+ CHECK(arr.size() == 0);
+}
+
+TEST_CASE("[Array] get()") {
+ Array arr;
+ arr.push_back(1);
+ CHECK(int(arr.get(0)) == 1);
+}
+
+TEST_CASE("[Array] sort()") {
+ Array arr;
+
+ arr.push_back(3);
+ arr.push_back(4);
+ arr.push_back(2);
+ arr.push_back(1);
+ arr.sort();
+ int val = 1;
+ for (int i = 0; i < arr.size(); i++) {
+ CHECK(int(arr[i]) == val);
+ val++;
+ }
+}
+
+TEST_CASE("[Array] push_front(), pop_front(), pop_back()") {
+ Array arr;
+ arr.push_front(1);
+ arr.push_front(2);
+ CHECK(int(arr[0]) == 2);
+ arr.pop_front();
+ CHECK(int(arr[0]) == 1);
+ CHECK(arr.size() == 1);
+ arr.push_front(2);
+ arr.push_front(3);
+ arr.pop_back();
+ CHECK(int(arr[1]) == 2);
+ CHECK(arr.size() == 2);
+}
+
+TEST_CASE("[Array] pop_at()") {
+ ErrorDetector ed;
+
+ Array arr;
+ arr.push_back(2);
+ arr.push_back(4);
+ arr.push_back(6);
+ arr.push_back(8);
+ arr.push_back(10);
+
+ REQUIRE(int(arr.pop_at(2)) == 6);
+ REQUIRE(arr.size() == 4);
+ CHECK(int(arr[0]) == 2);
+ CHECK(int(arr[1]) == 4);
+ CHECK(int(arr[2]) == 8);
+ CHECK(int(arr[3]) == 10);
+
+ REQUIRE(int(arr.pop_at(2)) == 8);
+ REQUIRE(arr.size() == 3);
+ CHECK(int(arr[0]) == 2);
+ CHECK(int(arr[1]) == 4);
+ CHECK(int(arr[2]) == 10);
+
+ // Negative index.
+ REQUIRE(int(arr.pop_at(-1)) == 10);
+ REQUIRE(arr.size() == 2);
+ CHECK(int(arr[0]) == 2);
+ CHECK(int(arr[1]) == 4);
+
+ // Invalid pop.
+ ed.clear();
+ ERR_PRINT_OFF;
+ const Variant ret = arr.pop_at(-15);
+ ERR_PRINT_ON;
+ REQUIRE(ret.is_null());
+ CHECK(ed.has_error);
+
+ REQUIRE(int(arr.pop_at(0)) == 2);
+ REQUIRE(arr.size() == 1);
+ CHECK(int(arr[0]) == 4);
+
+ REQUIRE(int(arr.pop_at(0)) == 4);
+ REQUIRE(arr.is_empty());
+
+ // Pop from empty array.
+ ed.clear();
+ REQUIRE(arr.pop_at(24).is_null());
+ CHECK_FALSE(ed.has_error);
+}
+
+TEST_CASE("[Array] max() and min()") {
+ Array arr;
+ arr.push_back(3);
+ arr.push_front(4);
+ arr.push_back(5);
+ arr.push_back(2);
+ int max = int(arr.max());
+ int min = int(arr.min());
+ CHECK(max == 5);
+ CHECK(min == 2);
+}
+
+TEST_CASE("[Array] slice()") {
+ Array array;
+ array.push_back(0);
+ array.push_back(1);
+ array.push_back(2);
+ array.push_back(3);
+ array.push_back(4);
+
+ Array slice0 = array.slice(0, 0);
+ CHECK(slice0.size() == 0);
+
+ Array slice1 = array.slice(1, 3);
+ CHECK(slice1.size() == 2);
+ CHECK(slice1[0] == Variant(1));
+ CHECK(slice1[1] == Variant(2));
+
+ Array slice2 = array.slice(1, -1);
+ CHECK(slice2.size() == 3);
+ CHECK(slice2[0] == Variant(1));
+ CHECK(slice2[1] == Variant(2));
+ CHECK(slice2[2] == Variant(3));
+
+ Array slice3 = array.slice(3);
+ CHECK(slice3.size() == 2);
+ CHECK(slice3[0] == Variant(3));
+ CHECK(slice3[1] == Variant(4));
+
+ Array slice4 = array.slice(2, -2);
+ CHECK(slice4.size() == 1);
+ CHECK(slice4[0] == Variant(2));
+
+ Array slice5 = array.slice(-2);
+ CHECK(slice5.size() == 2);
+ CHECK(slice5[0] == Variant(3));
+ CHECK(slice5[1] == Variant(4));
+
+ Array slice6 = array.slice(2, 42);
+ CHECK(slice6.size() == 3);
+ CHECK(slice6[0] == Variant(2));
+ CHECK(slice6[1] == Variant(3));
+ CHECK(slice6[2] == Variant(4));
+
+ Array slice7 = array.slice(4, 0, -2);
+ CHECK(slice7.size() == 2);
+ CHECK(slice7[0] == Variant(4));
+ CHECK(slice7[1] == Variant(2));
+
+ ERR_PRINT_OFF;
+ Array slice8 = array.slice(4, 1);
+ CHECK(slice8.size() == 0);
+
+ Array slice9 = array.slice(3, -4);
+ CHECK(slice9.size() == 0);
+ ERR_PRINT_ON;
+}
+
+TEST_CASE("[Array] Duplicate array") {
+ // a = [1, [2, 2], {3: 3}]
+ Array a = build_array(1, build_array(2, 2), build_dictionary(3, 3));
+
+ // Deep copy
+ Array deep_a = a.duplicate(true);
+ CHECK_MESSAGE(deep_a.id() != a.id(), "Should create a new array");
+ CHECK_MESSAGE(Array(deep_a[1]).id() != Array(a[1]).id(), "Should clone nested array");
+ CHECK_MESSAGE(Dictionary(deep_a[2]).id() != Dictionary(a[2]).id(), "Should clone nested dictionary");
+ CHECK_EQ(deep_a, a);
+ deep_a.push_back(1);
+ CHECK_NE(deep_a, a);
+ deep_a.pop_back();
+ Array(deep_a[1]).push_back(1);
+ CHECK_NE(deep_a, a);
+ Array(deep_a[1]).pop_back();
+ CHECK_EQ(deep_a, a);
+
+ // Shallow copy
+ Array shallow_a = a.duplicate(false);
+ CHECK_MESSAGE(shallow_a.id() != a.id(), "Should create a new array");
+ CHECK_MESSAGE(Array(shallow_a[1]).id() == Array(a[1]).id(), "Should keep nested array");
+ CHECK_MESSAGE(Dictionary(shallow_a[2]).id() == Dictionary(a[2]).id(), "Should keep nested dictionary");
+ CHECK_EQ(shallow_a, a);
+ Array(shallow_a).push_back(1);
+ CHECK_NE(shallow_a, a);
+}
+
+TEST_CASE("[Array] Duplicate recursive array") {
+ // Self recursive
+ Array a;
+ a.push_back(a);
+
+ Array a_shallow = a.duplicate(false);
+ CHECK_EQ(a, a_shallow);
+
+ // Deep copy of recursive array endup with recursion limit and return
+ // an invalid result (multiple nested arrays), the point is we should
+ // not end up with a segfault and an error log should be printed
+ ERR_PRINT_OFF;
+ a.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Array a1;
+ Array a2;
+ a2.push_back(a1);
+ a1.push_back(a2);
+
+ Array a1_shallow = a1.duplicate(false);
+ CHECK_EQ(a1, a1_shallow);
+
+ // Same deep copy issue as above
+ ERR_PRINT_OFF;
+ a1.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Array teardown will leak memory
+ a.clear();
+ a1.clear();
+ a2.clear();
+}
+
+TEST_CASE("[Array] Hash array") {
+ // a = [1, [2, 2], {3: 3}]
+ Array a = build_array(1, build_array(2, 2), build_dictionary(3, 3));
+ uint32_t original_hash = a.hash();
+
+ a.push_back(1);
+ CHECK_NE(a.hash(), original_hash);
+
+ a.pop_back();
+ CHECK_EQ(a.hash(), original_hash);
+
+ Array(a[1]).push_back(1);
+ CHECK_NE(a.hash(), original_hash);
+ Array(a[1]).pop_back();
+ CHECK_EQ(a.hash(), original_hash);
+
+ (Dictionary(a[2]))[1] = 1;
+ CHECK_NE(a.hash(), original_hash);
+ Dictionary(a[2]).erase(1);
+ CHECK_EQ(a.hash(), original_hash);
+
+ Array a2 = a.duplicate(true);
+ CHECK_EQ(a2.hash(), a.hash());
+}
+
+TEST_CASE("[Array] Hash recursive array") {
+ Array a1;
+ a1.push_back(a1);
+
+ Array a2;
+ a2.push_back(a2);
+
+ // Hash should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(a1.hash(), a2.hash());
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Array teardown will leak memory
+ a1.clear();
+ a2.clear();
+}
+
+TEST_CASE("[Array] Empty comparison") {
+ Array a1;
+ Array a2;
+
+ // test both operator== and operator!=
+ CHECK_EQ(a1, a2);
+ CHECK_FALSE(a1 != a2);
+}
+
+TEST_CASE("[Array] Flat comparison") {
+ Array a1 = build_array(1);
+ Array a2 = build_array(1);
+ Array other_a = build_array(2);
+
+ // test both operator== and operator!=
+ CHECK_EQ(a1, a1); // compare self
+ CHECK_FALSE(a1 != a1);
+ CHECK_EQ(a1, a2); // different equivalent arrays
+ CHECK_FALSE(a1 != a2);
+ CHECK_NE(a1, other_a); // different arrays with different content
+ CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Nested array comparison") {
+ // a1 = [[[1], 2], 3]
+ Array a1 = build_array(build_array(build_array(1), 2), 3);
+
+ Array a2 = a1.duplicate(true);
+
+ // other_a = [[[1, 0], 2], 3]
+ Array other_a = build_array(build_array(build_array(1, 0), 2), 3);
+
+ // test both operator== and operator!=
+ CHECK_EQ(a1, a1); // compare self
+ CHECK_FALSE(a1 != a1);
+ CHECK_EQ(a1, a2); // different equivalent arrays
+ CHECK_FALSE(a1 != a2);
+ CHECK_NE(a1, other_a); // different arrays with different content
+ CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Nested dictionary comparison") {
+ // a1 = [{1: 2}, 3]
+ Array a1 = build_array(build_dictionary(1, 2), 3);
+
+ Array a2 = a1.duplicate(true);
+
+ // other_a = [{1: 0}, 3]
+ Array other_a = build_array(build_dictionary(1, 0), 3);
+
+ // test both operator== and operator!=
+ CHECK_EQ(a1, a1); // compare self
+ CHECK_FALSE(a1 != a1);
+ CHECK_EQ(a1, a2); // different equivalent arrays
+ CHECK_FALSE(a1 != a2);
+ CHECK_NE(a1, other_a); // different arrays with different content
+ CHECK_FALSE(a1 == other_a);
+}
+
+TEST_CASE("[Array] Recursive comparison") {
+ Array a1;
+ a1.push_back(a1);
+
+ Array a2;
+ a2.push_back(a2);
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(a1, a2);
+ CHECK_FALSE(a1 != a2);
+ ERR_PRINT_ON;
+
+ a1.push_back(1);
+ a2.push_back(1);
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(a1, a2);
+ CHECK_FALSE(a1 != a2);
+ ERR_PRINT_ON;
+
+ a1.push_back(1);
+ a2.push_back(2);
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_NE(a1, a2);
+ CHECK_FALSE(a1 == a2);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Array tearndown will leak memory
+ a1.clear();
+ a2.clear();
+}
+
+TEST_CASE("[Array] Recursive self comparison") {
+ Array a1;
+ Array a2;
+ a2.push_back(a1);
+ a1.push_back(a2);
+
+ CHECK_EQ(a1, a1);
+ CHECK_FALSE(a1 != a1);
+
+ // Break the recursivity otherwise Array tearndown will leak memory
+ a1.clear();
+ a2.clear();
+}
+
+} // namespace TestArray
+
+#endif // TEST_ARRAY_H
diff --git a/tests/core/variant/test_dictionary.h b/tests/core/variant/test_dictionary.h
new file mode 100644
index 0000000000..c98434d42c
--- /dev/null
+++ b/tests/core/variant/test_dictionary.h
@@ -0,0 +1,523 @@
+/*************************************************************************/
+/* test_dictionary.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef TEST_DICTIONARY_H
+#define TEST_DICTIONARY_H
+
+#include "core/variant/dictionary.h"
+#include "tests/test_macros.h"
+
+namespace TestDictionary {
+
+static inline Array build_array() {
+ return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+ Array a = build_array(Fargs...);
+ a.push_front(item);
+ return a;
+}
+static inline Dictionary build_dictionary() {
+ return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+ Dictionary d = build_dictionary(Fargs...);
+ d[key] = item;
+ return d;
+}
+
+TEST_CASE("[Dictionary] Assignment using bracket notation ([])") {
+ Dictionary map;
+ map["Hello"] = 0;
+ CHECK(int(map["Hello"]) == 0);
+ map["Hello"] = 3;
+ CHECK(int(map["Hello"]) == 3);
+ map["World!"] = 4;
+ CHECK(int(map["World!"]) == 4);
+
+ // Test non-string keys, since keys can be of any Variant type.
+ map[12345] = -5;
+ CHECK(int(map[12345]) == -5);
+ map[false] = 128;
+ CHECK(int(map[false]) == 128);
+ map[Vector2(10, 20)] = 30;
+ CHECK(int(map[Vector2(10, 20)]) == 30);
+ map[0] = 400;
+ CHECK(int(map[0]) == 400);
+ // Check that assigning 0 doesn't overwrite the value for `false`.
+ CHECK(int(map[false]) == 128);
+}
+
+TEST_CASE("[Dictionary] get_key_lists()") {
+ Dictionary map;
+ List<Variant> keys;
+ List<Variant> *ptr = &keys;
+ map.get_key_list(ptr);
+ CHECK(keys.is_empty());
+ map[1] = 3;
+ map.get_key_list(ptr);
+ CHECK(keys.size() == 1);
+ CHECK(int(keys[0]) == 1);
+ map[2] = 4;
+ map.get_key_list(ptr);
+ CHECK(keys.size() == 3);
+}
+
+TEST_CASE("[Dictionary] get_key_at_index()") {
+ Dictionary map;
+ map[4] = 3;
+ Variant val = map.get_key_at_index(0);
+ CHECK(int(val) == 4);
+ map[3] = 1;
+ val = map.get_key_at_index(0);
+ CHECK(int(val) == 4);
+ val = map.get_key_at_index(1);
+ CHECK(int(val) == 3);
+}
+
+TEST_CASE("[Dictionary] getptr()") {
+ Dictionary map;
+ map[1] = 3;
+ Variant *key = map.getptr(1);
+ CHECK(int(*key) == 3);
+ key = map.getptr(2);
+ CHECK(key == nullptr);
+}
+
+TEST_CASE("[Dictionary] get_valid()") {
+ Dictionary map;
+ map[1] = 3;
+ Variant val = map.get_valid(1);
+ CHECK(int(val) == 3);
+}
+TEST_CASE("[Dictionary] get()") {
+ Dictionary map;
+ map[1] = 3;
+ Variant val = map.get(1, -1);
+ CHECK(int(val) == 3);
+}
+
+TEST_CASE("[Dictionary] size(), empty() and clear()") {
+ Dictionary map;
+ CHECK(map.size() == 0);
+ CHECK(map.is_empty());
+ map[1] = 3;
+ CHECK(map.size() == 1);
+ CHECK(!map.is_empty());
+ map.clear();
+ CHECK(map.size() == 0);
+ CHECK(map.is_empty());
+}
+
+TEST_CASE("[Dictionary] has() and has_all()") {
+ Dictionary map;
+ CHECK(map.has(1) == false);
+ map[1] = 3;
+ CHECK(map.has(1));
+ Array keys;
+ keys.push_back(1);
+ CHECK(map.has_all(keys));
+ keys.push_back(2);
+ CHECK(map.has_all(keys) == false);
+}
+
+TEST_CASE("[Dictionary] keys() and values()") {
+ Dictionary map;
+ Array keys = map.keys();
+ Array values = map.values();
+ CHECK(keys.is_empty());
+ CHECK(values.is_empty());
+ map[1] = 3;
+ keys = map.keys();
+ values = map.values();
+ CHECK(int(keys[0]) == 1);
+ CHECK(int(values[0]) == 3);
+}
+
+TEST_CASE("[Dictionary] Duplicate dictionary") {
+ // d = {1: {1: 1}, {2: 2}: [2], [3]: 3}
+ Dictionary k2 = build_dictionary(2, 2);
+ Array k3 = build_array(3);
+ Dictionary d = build_dictionary(1, build_dictionary(1, 1), k2, build_array(2), k3, 3);
+
+ // Deep copy
+ Dictionary deep_d = d.duplicate(true);
+ CHECK_MESSAGE(deep_d.id() != d.id(), "Should create a new dictionary");
+ CHECK_MESSAGE(Dictionary(deep_d[1]).id() != Dictionary(d[1]).id(), "Should clone nested dictionary");
+ CHECK_MESSAGE(Array(deep_d[k2]).id() != Array(d[k2]).id(), "Should clone nested array");
+ CHECK_EQ(deep_d, d);
+ deep_d[0] = 0;
+ CHECK_NE(deep_d, d);
+ deep_d.erase(0);
+ Dictionary(deep_d[1]).operator[](0) = 0;
+ CHECK_NE(deep_d, d);
+ Dictionary(deep_d[1]).erase(0);
+ CHECK_EQ(deep_d, d);
+ // Keys should also be copied
+ k2[0] = 0;
+ CHECK_NE(deep_d, d);
+ k2.erase(0);
+ CHECK_EQ(deep_d, d);
+ k3.push_back(0);
+ CHECK_NE(deep_d, d);
+ k3.pop_back();
+ CHECK_EQ(deep_d, d);
+
+ // Shallow copy
+ Dictionary shallow_d = d.duplicate(false);
+ CHECK_MESSAGE(shallow_d.id() != d.id(), "Should create a new array");
+ CHECK_MESSAGE(Dictionary(shallow_d[1]).id() == Dictionary(d[1]).id(), "Should keep nested dictionary");
+ CHECK_MESSAGE(Array(shallow_d[k2]).id() == Array(d[k2]).id(), "Should keep nested array");
+ CHECK_EQ(shallow_d, d);
+ shallow_d[0] = 0;
+ CHECK_NE(shallow_d, d);
+ shallow_d.erase(0);
+#if 0 // TODO: recursion in dict key currently is buggy
+ // Keys should also be shallowed
+ k2[0] = 0;
+ CHECK_EQ(shallow_d, d);
+ k2.erase(0);
+ k3.push_back(0);
+ CHECK_EQ(shallow_d, d);
+#endif
+}
+
+TEST_CASE("[Dictionary] Duplicate recursive dictionary") {
+ // Self recursive
+ Dictionary d;
+ d[1] = d;
+
+ Dictionary d_shallow = d.duplicate(false);
+ CHECK_EQ(d, d_shallow);
+
+ // Deep copy of recursive dictionary endup with recursion limit and return
+ // an invalid result (multiple nested dictionaries), the point is we should
+ // not end up with a segfault and an error log should be printed
+ ERR_PRINT_OFF;
+ d.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Dictionary d1;
+ Dictionary d2;
+ d1[2] = d2;
+ d2[1] = d1;
+
+ Dictionary d1_shallow = d1.duplicate(false);
+ CHECK_EQ(d1, d1_shallow);
+
+ // Same deep copy issue as above
+ ERR_PRINT_OFF;
+ d1.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d.clear();
+ d1.clear();
+ d2.clear();
+}
+
+#if 0 // TODO: duplicate recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Duplicate recursive dictionary on keys") {
+ // Self recursive
+ Dictionary d;
+ d[d] = d;
+
+ Dictionary d_shallow = d.duplicate(false);
+ CHECK_EQ(d, d_shallow);
+
+ // Deep copy of recursive dictionary endup with recursion limit and return
+ // an invalid result (multiple nested dictionaries), the point is we should
+ // not end up with a segfault and an error log should be printed
+ ERR_PRINT_OFF;
+ d.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Dictionary d1;
+ Dictionary d2;
+ d1[d2] = d2;
+ d2[d1] = d1;
+
+ Dictionary d1_shallow = d1.duplicate(false);
+ CHECK_EQ(d1, d1_shallow);
+
+ // Same deep copy issue as above
+ ERR_PRINT_OFF;
+ d1.duplicate(true);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d.clear();
+ d1.clear();
+ d2.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Hash dictionary") {
+ // d = {1: {1: 1}, {2: 2}: [2], [3]: 3}
+ Dictionary k2 = build_dictionary(2, 2);
+ Array k3 = build_array(3);
+ Dictionary d = build_dictionary(1, build_dictionary(1, 1), k2, build_array(2), k3, 3);
+ uint32_t original_hash = d.hash();
+
+ // Modify dict change the hash
+ d[0] = 0;
+ CHECK_NE(d.hash(), original_hash);
+ d.erase(0);
+ CHECK_EQ(d.hash(), original_hash);
+
+ // Modify nested item change the hash
+ Dictionary(d[1]).operator[](0) = 0;
+ CHECK_NE(d.hash(), original_hash);
+ Dictionary(d[1]).erase(0);
+ Array(d[k2]).push_back(0);
+ CHECK_NE(d.hash(), original_hash);
+ Array(d[k2]).pop_back();
+
+ // Modify a key change the hash
+ k2[0] = 0;
+ CHECK_NE(d.hash(), original_hash);
+ k2.erase(0);
+ CHECK_EQ(d.hash(), original_hash);
+ k3.push_back(0);
+ CHECK_NE(d.hash(), original_hash);
+ k3.pop_back();
+ CHECK_EQ(d.hash(), original_hash);
+
+ // Duplication doesn't change the hash
+ Dictionary d2 = d.duplicate(true);
+ CHECK_EQ(d2.hash(), original_hash);
+}
+
+TEST_CASE("[Dictionary] Hash recursive dictionary") {
+ Dictionary d;
+ d[1] = d;
+
+ // Hash should reach recursion limit, we just make sure this doesn't blow up
+ ERR_PRINT_OFF;
+ d.hash();
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Hash recursive dictionary on keys") {
+ Dictionary d;
+ d[d] = 1;
+
+ // Hash should reach recursion limit, we just make sure this doesn't blow up
+ ERR_PRINT_OFF;
+ d.hash();
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Empty comparison") {
+ Dictionary d1;
+ Dictionary d2;
+
+ // test both operator== and operator!=
+ CHECK_EQ(d1, d2);
+ CHECK_FALSE(d1 != d2);
+}
+
+TEST_CASE("[Dictionary] Flat comparison") {
+ Dictionary d1 = build_dictionary(1, 1);
+ Dictionary d2 = build_dictionary(1, 1);
+ Dictionary other_d = build_dictionary(2, 1);
+
+ // test both operator== and operator!=
+ CHECK_EQ(d1, d1); // compare self
+ CHECK_FALSE(d1 != d1);
+ CHECK_EQ(d1, d2); // different equivalent arrays
+ CHECK_FALSE(d1 != d2);
+ CHECK_NE(d1, other_d); // different arrays with different content
+ CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Nested dictionary comparison") {
+ // d1 = {1: {2: {3: 4}}}
+ Dictionary d1 = build_dictionary(1, build_dictionary(2, build_dictionary(3, 4)));
+
+ Dictionary d2 = d1.duplicate(true);
+
+ // other_d = {1: {2: {3: 0}}}
+ Dictionary other_d = build_dictionary(1, build_dictionary(2, build_dictionary(3, 0)));
+
+ // test both operator== and operator!=
+ CHECK_EQ(d1, d1); // compare self
+ CHECK_FALSE(d1 != d1);
+ CHECK_EQ(d1, d2); // different equivalent arrays
+ CHECK_FALSE(d1 != d2);
+ CHECK_NE(d1, other_d); // different arrays with different content
+ CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Nested array comparison") {
+ // d1 = {1: [2, 3]}
+ Dictionary d1 = build_dictionary(1, build_array(2, 3));
+
+ Dictionary d2 = d1.duplicate(true);
+
+ // other_d = {1: [2, 0]}
+ Dictionary other_d = build_dictionary(1, build_array(2, 0));
+
+ // test both operator== and operator!=
+ CHECK_EQ(d1, d1); // compare self
+ CHECK_FALSE(d1 != d1);
+ CHECK_EQ(d1, d2); // different equivalent arrays
+ CHECK_FALSE(d1 != d2);
+ CHECK_NE(d1, other_d); // different arrays with different content
+ CHECK_FALSE(d1 == other_d);
+}
+
+TEST_CASE("[Dictionary] Recursive comparison") {
+ Dictionary d1;
+ d1[1] = d1;
+
+ Dictionary d2;
+ d2[1] = d2;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(d1, d2);
+ CHECK_FALSE(d1 != d2);
+ ERR_PRINT_ON;
+
+ d1[2] = 2;
+ d2[2] = 2;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(d1, d2);
+ CHECK_FALSE(d1 != d2);
+ ERR_PRINT_ON;
+
+ d1[3] = 3;
+ d2[3] = 0;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_NE(d1, d2);
+ CHECK_FALSE(d1 == d2);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d1.clear();
+ d2.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Dictionary] Recursive comparison on keys") {
+ Dictionary d1;
+ // Hash computation should reach recursion limit
+ ERR_PRINT_OFF;
+ d1[d1] = 1;
+ ERR_PRINT_ON;
+
+ Dictionary d2;
+ // Hash computation should reach recursion limit
+ ERR_PRINT_OFF;
+ d2[d2] = 1;
+ ERR_PRINT_ON;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(d1, d2);
+ CHECK_FALSE(d1 != d2);
+ ERR_PRINT_ON;
+
+ d1[2] = 2;
+ d2[2] = 2;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_EQ(d1, d2);
+ CHECK_FALSE(d1 != d2);
+ ERR_PRINT_ON;
+
+ d1[3] = 3;
+ d2[3] = 0;
+
+ // Comparison should reach recursion limit
+ ERR_PRINT_OFF;
+ CHECK_NE(d1, d2);
+ CHECK_FALSE(d1 == d2);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d1.clear();
+ d2.clear();
+}
+#endif
+
+TEST_CASE("[Dictionary] Recursive self comparison") {
+ Dictionary d1;
+ Dictionary d2;
+ d1[1] = d2;
+ d2[1] = d1;
+
+ CHECK_EQ(d1, d1);
+ CHECK_FALSE(d1 != d1);
+
+ // Break the recursivity otherwise Dictionary teardown will leak memory
+ d1.clear();
+ d2.clear();
+}
+
+TEST_CASE("[Dictionary] Order and find") {
+ Dictionary d;
+ d[4] = "four";
+ d[8] = "eight";
+ d[12] = "twelve";
+ d["4"] = "four";
+
+ Array keys;
+ keys.append(4);
+ keys.append(8);
+ keys.append(12);
+ keys.append("4");
+
+ CHECK_EQ(d.keys(), keys);
+ CHECK_EQ(d.find_key("four"), Variant(4));
+ CHECK_EQ(d.find_key("does not exist"), Variant());
+}
+
+} // namespace TestDictionary
+
+#endif // TEST_DICTIONARY_H
diff --git a/tests/core/variant/test_variant.h b/tests/core/variant/test_variant.h
new file mode 100644
index 0000000000..d6799928b4
--- /dev/null
+++ b/tests/core/variant/test_variant.h
@@ -0,0 +1,978 @@
+/*************************************************************************/
+/* test_variant.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef TEST_VARIANT_H
+#define TEST_VARIANT_H
+
+#include "core/variant/variant.h"
+#include "core/variant/variant_parser.h"
+
+#include "tests/test_macros.h"
+
+namespace TestVariant {
+
+static inline Array build_array() {
+ return Array();
+}
+template <typename... Targs>
+static inline Array build_array(Variant item, Targs... Fargs) {
+ Array a = build_array(Fargs...);
+ a.push_front(item);
+ return a;
+}
+static inline Dictionary build_dictionary() {
+ return Dictionary();
+}
+template <typename... Targs>
+static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fargs) {
+ Dictionary d = build_dictionary(Fargs...);
+ d[key] = item;
+ return d;
+}
+
+TEST_CASE("[Variant] Writer and parser integer") {
+ int64_t a32 = 2147483648; // 2^31, so out of bounds for 32-bit signed int [-2^31, +2^31-1].
+ String a32_str;
+ VariantWriter::write_to_string(a32, a32_str);
+
+ CHECK_MESSAGE(a32_str != "-2147483648", "Should not wrap around");
+
+ int64_t b64 = 9223372036854775807; // 2^63-1, upper bound for signed 64-bit int.
+ String b64_str;
+ VariantWriter::write_to_string(b64, b64_str);
+
+ CHECK_MESSAGE(b64_str == "9223372036854775807", "Should not wrap around.");
+
+ VariantParser::StreamString ss;
+ String errs;
+ int line;
+ Variant b64_parsed;
+ int64_t b64_int_parsed;
+
+ ss.s = b64_str;
+ VariantParser::parse(&ss, b64_parsed, errs, line);
+ b64_int_parsed = b64_parsed;
+
+ CHECK_MESSAGE(b64_int_parsed == 9223372036854775807, "Should parse back.");
+
+ ss.s = "9223372036854775808"; // Overflowed by one.
+ VariantParser::parse(&ss, b64_parsed, errs, line);
+ b64_int_parsed = b64_parsed;
+
+ CHECK_MESSAGE(b64_int_parsed == 9223372036854775807, "The result should be clamped to max value.");
+
+ ss.s = "1e100"; // Googol! Scientific notation.
+ VariantParser::parse(&ss, b64_parsed, errs, line);
+ b64_int_parsed = b64_parsed;
+
+ CHECK_MESSAGE(b64_int_parsed == 9223372036854775807, "The result should be clamped to max value.");
+}
+
+TEST_CASE("[Variant] Writer and parser Variant::FLOAT") {
+ // Variant::FLOAT is always 64-bit (C++ double).
+ // This is the maximum non-infinity double-precision float.
+ double a64 = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0;
+ String a64_str;
+ VariantWriter::write_to_string(a64, a64_str);
+
+ CHECK_MESSAGE(a64_str == "1.79769e+308", "Writes in scientific notation.");
+ CHECK_MESSAGE(a64_str != "inf", "Should not overflow.");
+ CHECK_MESSAGE(a64_str != "nan", "The result should be defined.");
+
+ String errs;
+ int line;
+ Variant variant_parsed;
+ double float_parsed;
+
+ VariantParser::StreamString bss;
+ bss.s = a64_str;
+ VariantParser::parse(&bss, variant_parsed, errs, line);
+ float_parsed = variant_parsed;
+ // Loses precision, but that's alright.
+ CHECK_MESSAGE(float_parsed == 1.79769e+308, "Should parse back.");
+
+ // Approximation of Googol with a double-precision float.
+ VariantParser::StreamString css;
+ css.s = "1.0e+100";
+ VariantParser::parse(&css, variant_parsed, errs, line);
+ float_parsed = variant_parsed;
+ CHECK_MESSAGE(float_parsed == 1.0e+100, "Should match the double literal.");
+}
+
+TEST_CASE("[Variant] Assignment To Bool from Int,Float,String,Vec2,Vec2i,Vec3,Vec3i and Color") {
+ Variant int_v = 0;
+ Variant bool_v = true;
+ int_v = bool_v; // int_v is now a bool
+ CHECK(int_v == Variant(true));
+ bool_v = false;
+ int_v = bool_v;
+ CHECK(int_v.get_type() == Variant::BOOL);
+
+ Variant float_v = 0.0f;
+ bool_v = true;
+ float_v = bool_v;
+ CHECK(float_v == Variant(true));
+ bool_v = false;
+ float_v = bool_v;
+ CHECK(float_v.get_type() == Variant::BOOL);
+
+ Variant string_v = "";
+ bool_v = true;
+ string_v = bool_v;
+ CHECK(string_v == Variant(true));
+ bool_v = false;
+ string_v = bool_v;
+ CHECK(string_v.get_type() == Variant::BOOL);
+
+ Variant vec2_v = Vector2(0, 0);
+ bool_v = true;
+ vec2_v = bool_v;
+ CHECK(vec2_v == Variant(true));
+ bool_v = false;
+ vec2_v = bool_v;
+ CHECK(vec2_v.get_type() == Variant::BOOL);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ bool_v = true;
+ vec2i_v = bool_v;
+ CHECK(vec2i_v == Variant(true));
+ bool_v = false;
+ vec2i_v = bool_v;
+ CHECK(vec2i_v.get_type() == Variant::BOOL);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ bool_v = true;
+ vec3_v = bool_v;
+ CHECK(vec3_v == Variant(true));
+ bool_v = false;
+ vec3_v = bool_v;
+ CHECK(vec3_v.get_type() == Variant::BOOL);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ bool_v = true;
+ vec3i_v = bool_v;
+ CHECK(vec3i_v == Variant(true));
+ bool_v = false;
+ vec3i_v = bool_v;
+ CHECK(vec3i_v.get_type() == Variant::BOOL);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ bool_v = true;
+ col_v = bool_v;
+ CHECK(col_v == Variant(true));
+ bool_v = false;
+ col_v = bool_v;
+ CHECK(col_v.get_type() == Variant::BOOL);
+}
+
+TEST_CASE("[Variant] Assignment To Int from Bool,Float,String,Vec2,Vec2i,Vec3,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant int_v = 2;
+ bool_v = int_v; // Now bool_v is int
+ CHECK(bool_v == Variant(2));
+ int_v = -3;
+ bool_v = int_v;
+ CHECK(bool_v.get_type() == Variant::INT);
+
+ Variant float_v = 0.0f;
+ int_v = 2;
+ float_v = int_v;
+ CHECK(float_v == Variant(2));
+ int_v = -3;
+ float_v = int_v;
+ CHECK(float_v.get_type() == Variant::INT);
+
+ Variant string_v = "";
+ int_v = 2;
+ string_v = int_v;
+ CHECK(string_v == Variant(2));
+ int_v = -3;
+ string_v = int_v;
+ CHECK(string_v.get_type() == Variant::INT);
+
+ Variant vec2_v = Vector2(0, 0);
+ int_v = 2;
+ vec2_v = int_v;
+ CHECK(vec2_v == Variant(2));
+ int_v = -3;
+ vec2_v = int_v;
+ CHECK(vec2_v.get_type() == Variant::INT);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ int_v = 2;
+ vec2i_v = int_v;
+ CHECK(vec2i_v == Variant(2));
+ int_v = -3;
+ vec2i_v = int_v;
+ CHECK(vec2i_v.get_type() == Variant::INT);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ int_v = 2;
+ vec3_v = int_v;
+ CHECK(vec3_v == Variant(2));
+ int_v = -3;
+ vec3_v = int_v;
+ CHECK(vec3_v.get_type() == Variant::INT);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ int_v = 2;
+ vec3i_v = int_v;
+ CHECK(vec3i_v == Variant(2));
+ int_v = -3;
+ vec3i_v = int_v;
+ CHECK(vec3i_v.get_type() == Variant::INT);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ int_v = 2;
+ col_v = int_v;
+ CHECK(col_v == Variant(2));
+ int_v = -3;
+ col_v = int_v;
+ CHECK(col_v.get_type() == Variant::INT);
+}
+
+TEST_CASE("[Variant] Assignment To Float from Bool,Int,String,Vec2,Vec2i,Vec3,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant float_v = 1.5f;
+ bool_v = float_v; // Now bool_v is float
+ CHECK(bool_v == Variant(1.5f));
+ float_v = -4.6f;
+ bool_v = float_v;
+ CHECK(bool_v.get_type() == Variant::FLOAT);
+
+ Variant int_v = 1;
+ float_v = 1.5f;
+ int_v = float_v;
+ CHECK(int_v == Variant(1.5f));
+ float_v = -4.6f;
+ int_v = float_v;
+ CHECK(int_v.get_type() == Variant::FLOAT);
+
+ Variant string_v = "";
+ float_v = 1.5f;
+ string_v = float_v;
+ CHECK(string_v == Variant(1.5f));
+ float_v = -4.6f;
+ string_v = float_v;
+ CHECK(string_v.get_type() == Variant::FLOAT);
+
+ Variant vec2_v = Vector2(0, 0);
+ float_v = 1.5f;
+ vec2_v = float_v;
+ CHECK(vec2_v == Variant(1.5f));
+ float_v = -4.6f;
+ vec2_v = float_v;
+ CHECK(vec2_v.get_type() == Variant::FLOAT);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ float_v = 1.5f;
+ vec2i_v = float_v;
+ CHECK(vec2i_v == Variant(1.5f));
+ float_v = -4.6f;
+ vec2i_v = float_v;
+ CHECK(vec2i_v.get_type() == Variant::FLOAT);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ float_v = 1.5f;
+ vec3_v = float_v;
+ CHECK(vec3_v == Variant(1.5f));
+ float_v = -4.6f;
+ vec3_v = float_v;
+ CHECK(vec3_v.get_type() == Variant::FLOAT);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ float_v = 1.5f;
+ vec3i_v = float_v;
+ CHECK(vec3i_v == Variant(1.5f));
+ float_v = -4.6f;
+ vec3i_v = float_v;
+ CHECK(vec3i_v.get_type() == Variant::FLOAT);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ float_v = 1.5f;
+ col_v = float_v;
+ CHECK(col_v == Variant(1.5f));
+ float_v = -4.6f;
+ col_v = float_v;
+ CHECK(col_v.get_type() == Variant::FLOAT);
+}
+
+TEST_CASE("[Variant] Assignment To String from Bool,Int,Float,Vec2,Vec2i,Vec3,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant string_v = "Hello";
+ bool_v = string_v; // Now bool_v is string
+ CHECK(bool_v == Variant("Hello"));
+ string_v = "Hello there";
+ bool_v = string_v;
+ CHECK(bool_v.get_type() == Variant::STRING);
+
+ Variant int_v = 0;
+ string_v = "Hello";
+ int_v = string_v;
+ CHECK(int_v == Variant("Hello"));
+ string_v = "Hello there";
+ int_v = string_v;
+ CHECK(int_v.get_type() == Variant::STRING);
+
+ Variant float_v = 0.0f;
+ string_v = "Hello";
+ float_v = string_v;
+ CHECK(float_v == Variant("Hello"));
+ string_v = "Hello there";
+ float_v = string_v;
+ CHECK(float_v.get_type() == Variant::STRING);
+
+ Variant vec2_v = Vector2(0, 0);
+ string_v = "Hello";
+ vec2_v = string_v;
+ CHECK(vec2_v == Variant("Hello"));
+ string_v = "Hello there";
+ vec2_v = string_v;
+ CHECK(vec2_v.get_type() == Variant::STRING);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ string_v = "Hello";
+ vec2i_v = string_v;
+ CHECK(vec2i_v == Variant("Hello"));
+ string_v = "Hello there";
+ vec2i_v = string_v;
+ CHECK(vec2i_v.get_type() == Variant::STRING);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ string_v = "Hello";
+ vec3_v = string_v;
+ CHECK(vec3_v == Variant("Hello"));
+ string_v = "Hello there";
+ vec3_v = string_v;
+ CHECK(vec3_v.get_type() == Variant::STRING);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ string_v = "Hello";
+ vec3i_v = string_v;
+ CHECK(vec3i_v == Variant("Hello"));
+ string_v = "Hello there";
+ vec3i_v = string_v;
+ CHECK(vec3i_v.get_type() == Variant::STRING);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ string_v = "Hello";
+ col_v = string_v;
+ CHECK(col_v == Variant("Hello"));
+ string_v = "Hello there";
+ col_v = string_v;
+ CHECK(col_v.get_type() == Variant::STRING);
+}
+
+TEST_CASE("[Variant] Assignment To Vec2 from Bool,Int,Float,String,Vec2i,Vec3,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant vec2_v = Vector2(2.2f, 3.5f);
+ bool_v = vec2_v; // Now bool_v is Vector2
+ CHECK(bool_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ bool_v = vec2_v;
+ CHECK(bool_v.get_type() == Variant::VECTOR2);
+
+ Variant int_v = 0;
+ vec2_v = Vector2(2.2f, 3.5f);
+ int_v = vec2_v;
+ CHECK(int_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ int_v = vec2_v;
+ CHECK(int_v.get_type() == Variant::VECTOR2);
+
+ Variant float_v = 0.0f;
+ vec2_v = Vector2(2.2f, 3.5f);
+ float_v = vec2_v;
+ CHECK(float_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ float_v = vec2_v;
+ CHECK(float_v.get_type() == Variant::VECTOR2);
+
+ Variant string_v = "";
+ vec2_v = Vector2(2.2f, 3.5f);
+ string_v = vec2_v;
+ CHECK(string_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ string_v = vec2_v;
+ CHECK(string_v.get_type() == Variant::VECTOR2);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ vec2_v = Vector2(2.2f, 3.5f);
+ vec2i_v = vec2_v;
+ CHECK(vec2i_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ vec2i_v = vec2_v;
+ CHECK(vec2i_v.get_type() == Variant::VECTOR2);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ vec2_v = Vector2(2.2f, 3.5f);
+ vec3_v = vec2_v;
+ CHECK(vec3_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ vec3_v = vec2_v;
+ CHECK(vec3_v.get_type() == Variant::VECTOR2);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ vec2_v = Vector2(2.2f, 3.5f);
+ vec3i_v = vec2_v;
+ CHECK(vec3i_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ vec3i_v = vec2_v;
+ CHECK(vec3i_v.get_type() == Variant::VECTOR2);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ vec2_v = Vector2(2.2f, 3.5f);
+ col_v = vec2_v;
+ CHECK(col_v == Variant(Vector2(2.2f, 3.5f)));
+ vec2_v = Vector2(-5.4f, -7.9f);
+ col_v = vec2_v;
+ CHECK(col_v.get_type() == Variant::VECTOR2);
+}
+
+TEST_CASE("[Variant] Assignment To Vec2i from Bool,Int,Float,String,Vec2,Vec3,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant vec2i_v = Vector2i(2, 3);
+ bool_v = vec2i_v; // Now bool_v is Vector2i
+ CHECK(bool_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ bool_v = vec2i_v;
+ CHECK(bool_v.get_type() == Variant::VECTOR2I);
+
+ Variant int_v = 0;
+ vec2i_v = Vector2i(2, 3);
+ int_v = vec2i_v;
+ CHECK(int_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ int_v = vec2i_v;
+ CHECK(int_v.get_type() == Variant::VECTOR2I);
+
+ Variant float_v = 0.0f;
+ vec2i_v = Vector2i(2, 3);
+ float_v = vec2i_v;
+ CHECK(float_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ float_v = vec2i_v;
+ CHECK(float_v.get_type() == Variant::VECTOR2I);
+
+ Variant string_v = "";
+ vec2i_v = Vector2i(2, 3);
+ string_v = vec2i_v;
+ CHECK(string_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ string_v = vec2i_v;
+ CHECK(string_v.get_type() == Variant::VECTOR2I);
+
+ Variant vec2_v = Vector2(0, 0);
+ vec2i_v = Vector2i(2, 3);
+ vec2_v = vec2i_v;
+ CHECK(vec2_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ vec2_v = vec2i_v;
+ CHECK(vec2i_v.get_type() == Variant::VECTOR2I);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ vec2i_v = Vector2i(2, 3);
+ vec3_v = vec2i_v;
+ CHECK(vec3_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ vec3_v = vec2i_v;
+ CHECK(vec3_v.get_type() == Variant::VECTOR2I);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ vec2i_v = Vector2i(2, 3);
+ vec3i_v = vec2i_v;
+ CHECK(vec3i_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ vec3i_v = vec2i_v;
+ CHECK(vec3i_v.get_type() == Variant::VECTOR2I);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ vec2i_v = Vector2i(2, 3);
+ col_v = vec2i_v;
+ CHECK(col_v == Variant(Vector2i(2, 3)));
+ vec2i_v = Vector2i(-5, -7);
+ col_v = vec2i_v;
+ CHECK(col_v.get_type() == Variant::VECTOR2I);
+}
+
+TEST_CASE("[Variant] Assignment To Vec3 from Bool,Int,Float,String,Vec2,Vec2i,Vec3i and Color") {
+ Variant bool_v = false;
+ Variant vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ bool_v = vec3_v; // Now bool_v is Vector3
+ CHECK(bool_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ bool_v = vec3_v;
+ CHECK(bool_v.get_type() == Variant::VECTOR3);
+
+ Variant int_v = 0;
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ int_v = vec3_v;
+ CHECK(int_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ int_v = vec3_v;
+ CHECK(int_v.get_type() == Variant::VECTOR3);
+
+ Variant float_v = 0.0f;
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ float_v = vec3_v;
+ CHECK(float_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ float_v = vec3_v;
+ CHECK(float_v.get_type() == Variant::VECTOR3);
+
+ Variant string_v = "";
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ string_v = vec3_v;
+ CHECK(string_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ string_v = vec3_v;
+ CHECK(string_v.get_type() == Variant::VECTOR3);
+
+ Variant vec2_v = Vector2(0, 0);
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ vec2_v = vec3_v;
+ CHECK(vec2_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ vec2_v = vec3_v;
+ CHECK(vec2_v.get_type() == Variant::VECTOR3);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ vec2i_v = vec3_v;
+ CHECK(vec2i_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ vec2i_v = vec3_v;
+ CHECK(vec2i_v.get_type() == Variant::VECTOR3);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ vec3i_v = vec3_v;
+ CHECK(vec3i_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ vec3i_v = vec3_v;
+ CHECK(vec3i_v.get_type() == Variant::VECTOR3);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ vec3_v = Vector3(2.2f, 3.5f, 5.3f);
+ col_v = vec3_v;
+ CHECK(col_v == Variant(Vector3(2.2f, 3.5f, 5.3f)));
+ vec3_v = Vector3(-5.4f, -7.9f, -2.1f);
+ col_v = vec3_v;
+ CHECK(col_v.get_type() == Variant::VECTOR3);
+}
+
+TEST_CASE("[Variant] Assignment To Vec3i from Bool,Int,Float,String,Vec2,Vec2i,Vec3 and Color") {
+ Variant bool_v = false;
+ Variant vec3i_v = Vector3i(2, 3, 5);
+ bool_v = vec3i_v; // Now bool_v is Vector3i
+ CHECK(bool_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ bool_v = vec3i_v;
+ CHECK(bool_v.get_type() == Variant::VECTOR3I);
+
+ Variant int_v = 0;
+ vec3i_v = Vector3i(2, 3, 5);
+ int_v = vec3i_v;
+ CHECK(int_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ int_v = vec3i_v;
+ CHECK(int_v.get_type() == Variant::VECTOR3I);
+
+ Variant float_v = 0.0f;
+ vec3i_v = Vector3i(2, 3, 5);
+ float_v = vec3i_v;
+ CHECK(float_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ float_v = vec3i_v;
+ CHECK(float_v.get_type() == Variant::VECTOR3I);
+
+ Variant string_v = "";
+ vec3i_v = Vector3i(2, 3, 5);
+ string_v = vec3i_v;
+ CHECK(string_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ string_v = vec3i_v;
+ CHECK(string_v.get_type() == Variant::VECTOR3I);
+
+ Variant vec2_v = Vector2(0, 0);
+ vec3i_v = Vector3i(2, 3, 5);
+ vec2_v = vec3i_v;
+ CHECK(vec2_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ vec2_v = vec3i_v;
+ CHECK(vec2_v.get_type() == Variant::VECTOR3I);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ vec3i_v = Vector3i(2, 3, 5);
+ vec2i_v = vec3i_v;
+ CHECK(vec2i_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ vec2i_v = vec3i_v;
+ CHECK(vec2i_v.get_type() == Variant::VECTOR3I);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ vec3i_v = Vector3i(2, 3, 5);
+ vec3_v = vec3i_v;
+ CHECK(vec3_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ vec3_v = vec3i_v;
+ CHECK(vec3_v.get_type() == Variant::VECTOR3I);
+
+ Variant col_v = Color(0.5f, 0.2f, 0.75f);
+ vec3i_v = Vector3i(2, 3, 5);
+ col_v = vec3i_v;
+ CHECK(col_v == Variant(Vector3i(2, 3, 5)));
+ vec3i_v = Vector3i(-5, -7, -2);
+ col_v = vec3i_v;
+ CHECK(col_v.get_type() == Variant::VECTOR3I);
+}
+
+TEST_CASE("[Variant] Assignment To Color from Bool,Int,Float,String,Vec2,Vec2i,Vec3 and Vec3i") {
+ Variant bool_v = false;
+ Variant col_v = Color(0.25f, 0.4f, 0.78f);
+ bool_v = col_v; // Now bool_v is Color
+ CHECK(bool_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ bool_v = col_v;
+ CHECK(bool_v.get_type() == Variant::COLOR);
+
+ Variant int_v = 0;
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ int_v = col_v;
+ CHECK(int_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ int_v = col_v;
+ CHECK(int_v.get_type() == Variant::COLOR);
+
+ Variant float_v = 0.0f;
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ float_v = col_v;
+ CHECK(float_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ float_v = col_v;
+ CHECK(float_v.get_type() == Variant::COLOR);
+
+ Variant string_v = "";
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ string_v = col_v;
+ CHECK(string_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ string_v = col_v;
+ CHECK(string_v.get_type() == Variant::COLOR);
+
+ Variant vec2_v = Vector2(0, 0);
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ vec2_v = col_v;
+ CHECK(vec2_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ vec2_v = col_v;
+ CHECK(vec2_v.get_type() == Variant::COLOR);
+
+ Variant vec2i_v = Vector2i(0, 0);
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ vec2i_v = col_v;
+ CHECK(vec2i_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ vec2i_v = col_v;
+ CHECK(vec2i_v.get_type() == Variant::COLOR);
+
+ Variant vec3_v = Vector3(0, 0, 0);
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ vec3_v = col_v;
+ CHECK(vec3_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ vec3_v = col_v;
+ CHECK(vec3_v.get_type() == Variant::COLOR);
+
+ Variant vec3i_v = Vector3i(0, 0, 0);
+ col_v = Color(0.25f, 0.4f, 0.78f);
+ vec3i_v = col_v;
+ CHECK(vec3i_v == Variant(Color(0.25f, 0.4f, 0.78f)));
+ col_v = Color(0.33f, 0.75f, 0.21f);
+ vec3i_v = col_v;
+ CHECK(vec3i_v.get_type() == Variant::COLOR);
+}
+
+TEST_CASE("[Variant] Writer and parser array") {
+ Array a = build_array(1, String("hello"), build_array(Variant()));
+ String a_str;
+ VariantWriter::write_to_string(a, a_str);
+
+ CHECK_EQ(a_str, "[1, \"hello\", [null]]");
+
+ VariantParser::StreamString ss;
+ String errs;
+ int line;
+ Variant a_parsed;
+
+ ss.s = a_str;
+ VariantParser::parse(&ss, a_parsed, errs, line);
+
+ CHECK_MESSAGE(a_parsed == Variant(a), "Should parse back.");
+}
+
+TEST_CASE("[Variant] Writer recursive array") {
+ // There is no way to accurately represent a recursive array,
+ // the only thing we can do is make sure the writer doesn't blow up
+
+ // Self recursive
+ Array a;
+ a.push_back(a);
+
+ // Writer should it recursion limit while visiting the array
+ ERR_PRINT_OFF;
+ String a_str;
+ VariantWriter::write_to_string(a, a_str);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Array a1;
+ Array a2;
+ a1.push_back(a2);
+ a2.push_back(a1);
+
+ // Writer should it recursion limit while visiting the array
+ ERR_PRINT_OFF;
+ String a1_str;
+ VariantWriter::write_to_string(a1, a1_str);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary tearndown will leak memory
+ a.clear();
+ a1.clear();
+ a2.clear();
+}
+
+TEST_CASE("[Variant] Writer and parser dictionary") {
+ // d = {{1: 2}: 3, 4: "hello", 5: {null: []}}
+ Dictionary d = build_dictionary(build_dictionary(1, 2), 3, 4, String("hello"), 5, build_dictionary(Variant(), build_array()));
+ String d_str;
+ VariantWriter::write_to_string(d, d_str);
+
+ CHECK_EQ(d_str, "{\n4: \"hello\",\n5: {\nnull: []\n},\n{\n1: 2\n}: 3\n}");
+
+ VariantParser::StreamString ss;
+ String errs;
+ int line;
+ Variant d_parsed;
+
+ ss.s = d_str;
+ VariantParser::parse(&ss, d_parsed, errs, line);
+
+ CHECK_MESSAGE(d_parsed == Variant(d), "Should parse back.");
+}
+
+TEST_CASE("[Variant] Writer recursive dictionary") {
+ // There is no way to accurately represent a recursive dictionary,
+ // the only thing we can do is make sure the writer doesn't blow up
+
+ // Self recursive
+ Dictionary d;
+ d[1] = d;
+
+ // Writer should it recursion limit while visiting the dictionary
+ ERR_PRINT_OFF;
+ String d_str;
+ VariantWriter::write_to_string(d, d_str);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Dictionary d1;
+ Dictionary d2;
+ d1[2] = d2;
+ d2[1] = d1;
+
+ // Writer should it recursion limit while visiting the dictionary
+ ERR_PRINT_OFF;
+ String d1_str;
+ VariantWriter::write_to_string(d1, d1_str);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary tearndown will leak memory
+ d.clear();
+ d1.clear();
+ d2.clear();
+}
+
+#if 0 // TODO: recursion in dict key is currently buggy
+TEST_CASE("[Variant] Writer recursive dictionary on keys") {
+ // There is no way to accurately represent a recursive dictionary,
+ // the only thing we can do is make sure the writer doesn't blow up
+
+ // Self recursive
+ Dictionary d;
+ d[d] = 1;
+
+ // Writer should it recursion limit while visiting the dictionary
+ ERR_PRINT_OFF;
+ String d_str;
+ VariantWriter::write_to_string(d, d_str);
+ ERR_PRINT_ON;
+
+ // Nested recursive
+ Dictionary d1;
+ Dictionary d2;
+ d1[d2] = 2;
+ d2[d1] = 1;
+
+ // Writer should it recursion limit while visiting the dictionary
+ ERR_PRINT_OFF;
+ String d1_str;
+ VariantWriter::write_to_string(d1, d1_str);
+ ERR_PRINT_ON;
+
+ // Break the recursivity otherwise Dictionary tearndown will leak memory
+ d.clear();
+ d1.clear();
+ d2.clear();
+}
+#endif
+
+TEST_CASE("[Variant] Basic comparison") {
+ CHECK_EQ(Variant(1), Variant(1));
+ CHECK_FALSE(Variant(1) != Variant(1));
+ CHECK_NE(Variant(1), Variant(2));
+ CHECK_EQ(Variant(String("foo")), Variant(String("foo")));
+ CHECK_NE(Variant(String("foo")), Variant(String("bar")));
+ // Check "empty" version of different types are not equivalents
+ CHECK_NE(Variant(0), Variant());
+ CHECK_NE(Variant(String()), Variant());
+ CHECK_NE(Variant(Array()), Variant());
+ CHECK_NE(Variant(Dictionary()), Variant());
+}
+
+TEST_CASE("[Variant] Nested array comparison") {
+ Array a1 = build_array(1, build_array(2, 3));
+ Array a2 = build_array(1, build_array(2, 3));
+ Array a_other = build_array(1, build_array(2, 4));
+ Variant v_a1 = a1;
+ Variant v_a1_ref2 = a1;
+ Variant v_a2 = a2;
+ Variant v_a_other = a_other;
+
+ // test both operator== and operator!=
+ CHECK_EQ(v_a1, v_a1);
+ CHECK_FALSE(v_a1 != v_a1);
+ CHECK_EQ(v_a1, v_a1_ref2);
+ CHECK_FALSE(v_a1 != v_a1_ref2);
+ CHECK_EQ(v_a1, v_a2);
+ CHECK_FALSE(v_a1 != v_a2);
+ CHECK_NE(v_a1, v_a_other);
+ CHECK_FALSE(v_a1 == v_a_other);
+}
+
+TEST_CASE("[Variant] Nested dictionary comparison") {
+ Dictionary d1 = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 4));
+ Dictionary d2 = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 4));
+ Dictionary d_other_key = build_dictionary(build_dictionary(1, 0), build_dictionary(3, 4));
+ Dictionary d_other_val = build_dictionary(build_dictionary(1, 2), build_dictionary(3, 0));
+ Variant v_d1 = d1;
+ Variant v_d1_ref2 = d1;
+ Variant v_d2 = d2;
+ Variant v_d_other_key = d_other_key;
+ Variant v_d_other_val = d_other_val;
+
+ // test both operator== and operator!=
+ CHECK_EQ(v_d1, v_d1);
+ CHECK_FALSE(v_d1 != v_d1);
+ CHECK_EQ(v_d1, v_d1_ref2);
+ CHECK_FALSE(v_d1 != v_d1_ref2);
+ CHECK_EQ(v_d1, v_d2);
+ CHECK_FALSE(v_d1 != v_d2);
+ CHECK_NE(v_d1, v_d_other_key);
+ CHECK_FALSE(v_d1 == v_d_other_key);
+ CHECK_NE(v_d1, v_d_other_val);
+ CHECK_FALSE(v_d1 == v_d_other_val);
+}
+
+struct ArgumentData {
+ Variant::Type type;
+ String name;
+ bool has_defval = false;
+ Variant defval;
+ int position;
+};
+
+struct MethodData {
+ StringName name;
+ Variant::Type return_type;
+ List<ArgumentData> arguments;
+ bool is_virtual = false;
+ bool is_vararg = false;
+};
+
+TEST_CASE("[Variant] Utility functions") {
+ List<MethodData> functions;
+
+ List<StringName> function_names;
+ Variant::get_utility_function_list(&function_names);
+ function_names.sort_custom<StringName::AlphCompare>();
+
+ for (const StringName &E : function_names) {
+ MethodData md;
+ md.name = E;
+
+ // Utility function's return type.
+ if (Variant::has_utility_function_return_value(E)) {
+ md.return_type = Variant::get_utility_function_return_type(E);
+ }
+
+ // Utility function's arguments.
+ if (Variant::is_utility_function_vararg(E)) {
+ md.is_vararg = true;
+ } else {
+ for (int i = 0; i < Variant::get_utility_function_argument_count(E); i++) {
+ ArgumentData arg;
+ arg.type = Variant::get_utility_function_argument_type(E, i);
+ arg.name = Variant::get_utility_function_argument_name(E, i);
+ arg.position = i;
+
+ md.arguments.push_back(arg);
+ }
+ }
+
+ functions.push_back(md);
+ }
+
+ SUBCASE("[Variant] Validate utility functions") {
+ for (const MethodData &E : functions) {
+ for (const ArgumentData &F : E.arguments) {
+ const ArgumentData &arg = F;
+
+ TEST_COND((arg.name.is_empty() || arg.name.begins_with("_unnamed_arg")),
+ vformat("Unnamed argument in position %d of function '%s'.", arg.position, E.name));
+ }
+ }
+ }
+}
+
+} // namespace TestVariant
+
+#endif // TEST_VARIANT_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-28 05:14:12 +0000