Sara/going
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: modules moved and engine moved to submodule

Browse source
This commit is contained in:
Jan van der Weide 2025-04-12 18:40:44 +02:00
parent dfb5e645cd
commit c33d2130cc
5136 changed files with 225275 additions and 64485 deletions
Download patch file Download diff file Expand all files Collapse all files

80
engine/tests/core/variant/test_array.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_ARRAY_H
#define TEST_ARRAY_H
#pragma once
#include "core/variant/array.h"
#include "tests/test_macros.h"
@ -56,6 +55,26 @@ static inline Dictionary build_dictionary(Variant key, Variant item, Targs... Fa
return d;
}
TEST_CASE("[Array] initializer list") {
Array arr = { 0, 1, "test", true, { 0.0, 1.0 } };
CHECK(arr.size() == 5);
CHECK(arr[0] == Variant(0));
CHECK(arr[1] == Variant(1));
CHECK(arr[2] == Variant("test"));
CHECK(arr[3] == Variant(true));
CHECK(arr[4] == Variant({ 0.0, 1.0 }));
arr = { "reassign" };
CHECK(arr.size() == 1);
CHECK(arr[0] == Variant("reassign"));
TypedArray<int> typed_arr = { 0, 1, 2 };
CHECK(typed_arr.size() == 3);
CHECK(typed_arr[0] == Variant(0));
CHECK(typed_arr[1] == Variant(1));
CHECK(typed_arr[2] == Variant(2));
}
TEST_CASE("[Array] size(), clear(), and is_empty()") {
Array arr;
CHECK(arr.size() == 0);
@ -107,6 +126,12 @@ TEST_CASE("[Array] resize(), insert(), and erase()") {
CHECK(int(arr[0]) == 2);
arr.erase(2);
CHECK(int(arr[0]) == 1);
// Negative index on insert.
CHECK(arr.size() == 3);
arr.insert(-1, 3);
CHECK(int(arr[2]) == 3);
CHECK(arr.size() == 4);
}
TEST_CASE("[Array] front() and back()") {
@ -120,9 +145,7 @@ TEST_CASE("[Array] front() and back()") {
}
TEST_CASE("[Array] has() and count()") {
Array arr;
arr.push_back(1);
arr.push_back(1);
Array arr = { 1, 1 };
CHECK(arr.has(1));
CHECK(!arr.has(2));
CHECK(arr.count(1) == 2);
@ -130,15 +153,22 @@ TEST_CASE("[Array] has() and count()") {
}
TEST_CASE("[Array] remove_at()") {
Array arr;
arr.push_back(1);
arr.push_back(2);
Array arr = { 1, 2 };
arr.remove_at(0);
CHECK(arr.size() == 1);
CHECK(int(arr[0]) == 2);
arr.remove_at(0);
CHECK(arr.size() == 0);
// Negative index.
arr.push_back(3);
arr.push_back(4);
arr.remove_at(-1);
CHECK(arr.size() == 1);
CHECK(int(arr[0]) == 3);
arr.remove_at(-1);
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;
@ -149,18 +179,12 @@ TEST_CASE("[Array] remove_at()") {
}
TEST_CASE("[Array] get()") {
Array arr;
arr.push_back(1);
Array arr = { 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);
Array arr = { 3, 4, 2, 1 };
arr.sort();
int val = 1;
for (int i = 0; i < arr.size(); i++) {
@ -187,12 +211,7 @@ TEST_CASE("[Array] push_front(), pop_front(), pop_back()") {
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);
Array arr = { 2, 4, 6, 8, 10 };
REQUIRE(int(arr.pop_at(2)) == 6);
REQUIRE(arr.size() == 4);
@ -247,13 +266,7 @@ TEST_CASE("[Array] max() and min()") {
}
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.push_back(5);
Array array = { 0, 1, 2, 3, 4, 5 };
Array slice0 = array.slice(0, 0);
CHECK(slice0.size() == 0);
@ -598,11 +611,8 @@ TEST_CASE("[Array] Iteration and modification") {
}
TEST_CASE("[Array] Typed copying") {
TypedArray<int> a1;
a1.push_back(1);
TypedArray<double> a2;
a2.push_back(1.0);
TypedArray<int> a1 = { 1 };
TypedArray<double> a2 = { 1.0 };
Array a3 = a1;
TypedArray<int> a4 = a3;
@ -653,5 +663,3 @@ TEST_CASE("[Array] Test rfind_custom") {
}
} // namespace TestArray
#endif // TEST_ARRAY_H

11
engine/tests/core/variant/test_callable.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_CALLABLE_H
#define TEST_CALLABLE_H
#pragma once
#include "core/object/class_db.h"
#include "core/object/object.h"
@ -155,11 +154,7 @@ public:
}
static String get_output(const Callable &p_callable) {
Array effective_args;
effective_args.push_back(7);
effective_args.push_back(8);
effective_args.push_back(9);
Array effective_args = { 7, 8, 9 };
effective_args.resize(3 - p_callable.get_unbound_arguments_count());
effective_args.append_array(p_callable.get_bound_arguments());
@ -200,5 +195,3 @@ TEST_CASE("[Callable] Bound and unbound argument count") {
}
} // namespace TestCallable
#endif // TEST_CALLABLE_H

67
engine/tests/core/variant/test_dictionary.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_DICTIONARY_H
#define TEST_DICTIONARY_H
#pragma once
#include "core/variant/typed_dictionary.h"
#include "tests/test_macros.h"
@ -116,19 +115,18 @@ TEST_CASE("[Dictionary] List init") {
CHECK_EQ(tdict[5.0], Variant(2.0));
}
TEST_CASE("[Dictionary] get_key_lists()") {
TEST_CASE("[Dictionary] get_key_list()") {
Dictionary map;
List<Variant> keys;
List<Variant> *ptr = &keys;
map.get_key_list(ptr);
LocalVector<Variant> keys;
keys = map.get_key_list();
CHECK(keys.is_empty());
map[1] = 3;
map.get_key_list(ptr);
keys = map.get_key_list();
CHECK(keys.size() == 1);
CHECK(int(keys.front()->get()) == 1);
CHECK(int(keys[0]) == 1);
map[2] = 4;
map.get_key_list(ptr);
CHECK(keys.size() == 3);
keys = map.get_key_list();
CHECK(keys.size() == 2);
}
TEST_CASE("[Dictionary] get_key_at_index()") {
@ -546,11 +544,7 @@ TEST_CASE("[Dictionary] Order and find") {
d[12] = "twelve";
d["4"] = "four";
Array keys;
keys.append(4);
keys.append(8);
keys.append(12);
keys.append("4");
Array keys = { 4, 8, 12, "4" };
CHECK_EQ(d.keys(), keys);
CHECK_EQ(d.find_key("four"), Variant(4));
@ -594,6 +588,45 @@ TEST_CASE("[Dictionary] Typed copying") {
d6.clear();
}
} // namespace TestDictionary
TEST_CASE("[Dictionary] Iteration") {
Dictionary a1 = build_dictionary(1, 2, 3, 4, 5, 6);
Dictionary a2 = build_dictionary(1, 2, 3, 4, 5, 6);
#endif // TEST_DICTIONARY_H
int idx = 0;
for (const KeyValue<Variant, Variant> &kv : (const Dictionary &)a1) {
CHECK_EQ(int(a2[kv.key]), int(kv.value));
idx++;
}
CHECK_EQ(idx, a1.size());
a1.clear();
a2.clear();
}
TEST_CASE("[Dictionary] Object value init") {
Object *a = memnew(Object);
Object *b = memnew(Object);
TypedDictionary<double, Object *> tdict = {
{ 0.0, a },
{ 5.0, b },
};
CHECK_EQ(tdict[0.0], Variant(a));
CHECK_EQ(tdict[5.0], Variant(b));
memdelete(a);
memdelete(b);
}
TEST_CASE("[Dictionary] RefCounted value init") {
Ref<RefCounted> a = memnew(RefCounted);
Ref<RefCounted> b = memnew(RefCounted);
TypedDictionary<double, Ref<RefCounted>> tdict = {
{ 0.0, a },
{ 5.0, b },
};
CHECK_EQ(tdict[0.0], Variant(a));
CHECK_EQ(tdict[5.0], Variant(b));
}
} // namespace TestDictionary

23
engine/tests/core/variant/test_variant.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_VARIANT_H
#define TEST_VARIANT_H
#pragma once
#include "core/variant/variant.h"
#include "core/variant/variant_parser.h"
@ -1737,6 +1736,24 @@ TEST_CASE("[Variant] Assignment To Color from Bool,Int,Float,String,Vec2,Vec2i,V
CHECK(object_v.get_type() == Variant::COLOR);
}
TEST_CASE("[Variant] array initializer list") {
Variant arr_v = { 0, 1, "test", true, { 0.0, 1.0 } };
CHECK(arr_v.get_type() == Variant::ARRAY);
Array arr = (Array)arr_v;
CHECK(arr.size() == 5);
CHECK(arr[0] == Variant(0));
CHECK(arr[1] == Variant(1));
CHECK(arr[2] == Variant("test"));
CHECK(arr[3] == Variant(true));
CHECK(arr[4] == Variant({ 0.0, 1.0 }));
PackedInt32Array packed_arr = { 2, 1, 0 };
CHECK(packed_arr.size() == 3);
CHECK(packed_arr[0] == 2);
CHECK(packed_arr[1] == 1);
CHECK(packed_arr[2] == 0);
}
TEST_CASE("[Variant] Writer and parser array") {
Array a = build_array(1, String("hello"), build_array(Variant()));
String a_str;
@ -2217,5 +2234,3 @@ TEST_CASE("[Variant] Operator NOT") {
}
} // namespace TestVariant
#endif // TEST_VARIANT_H

16
engine/tests/core/variant/test_variant_utility.h
View file

@ -28,8 +28,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef TEST_VARIANT_UTILITY_H
#define TEST_VARIANT_UTILITY_H
#pragma once
#include "core/variant/variant_utility.h"
@ -93,15 +92,8 @@ TEST_CASE("[VariantUtility] Type conversion") {
}
{
Array arr;
arr.push_back(1.2);
arr.push_back(3.4);
arr.push_back(5.6);
PackedFloat64Array packed;
packed.push_back(1.2);
packed.push_back(3.4);
packed.push_back(5.6);
Array arr = { 1.2, 3.4, 5.6 };
PackedFloat64Array packed = { 1.2, 3.4, 5.6 };
converted = VariantUtilityFunctions::type_convert(arr, Variant::Type::PACKED_FLOAT64_ARRAY);
CHECK(converted.get_type() == Variant::Type::PACKED_FLOAT64_ARRAY);
@ -137,5 +129,3 @@ TEST_CASE("[VariantUtility] Type conversion") {
}
} // namespace TestVariantUtility
#endif // TEST_VARIANT_UTILITY_H