aurpine
649 lines
22 KiB
C++
649 lines
22 KiB
C++
/**************************************************************************/
|
|
/* test_variant_initialization.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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. */
|
|
/**************************************************************************/
|
|
|
|
#include "tests/test_macros.h"
|
|
|
|
TEST_FORCE_LINK(test_variant_initialization)
|
|
|
|
#include "core/variant/variant_internal.h"
|
|
|
|
namespace TestVariantInitialization {
|
|
|
|
TEST_CASE("[VariantInitialization] change_and_reset") {
|
|
// Garbage data
|
|
Variant *p = new Variant();
|
|
std::memset((void *)p, -1, sizeof(Variant));
|
|
VariantInternal::set_type(*p, Variant::Type::NIL);
|
|
|
|
SUBCASE("bool") {
|
|
VariantTypeChanger<bool>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BOOL);
|
|
CHECK(*p == Variant(false));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<bool>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BOOL);
|
|
CHECK(*p == Variant(false));
|
|
|
|
*p = Variant(1);
|
|
VariantTypeChanger<bool>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BOOL);
|
|
CHECK(*p == Variant(false));
|
|
}
|
|
|
|
SUBCASE("int") {
|
|
VariantTypeChanger<int64_t>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::INT);
|
|
CHECK(*p == Variant(0));
|
|
|
|
*p = Variant(1);
|
|
VariantTypeChanger<int64_t>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::INT);
|
|
CHECK(*p == Variant(0));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<int64_t>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::INT);
|
|
CHECK(*p == Variant(0));
|
|
}
|
|
|
|
SUBCASE("float") {
|
|
VariantTypeChanger<double>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::FLOAT);
|
|
CHECK(*p == Variant(0.));
|
|
|
|
*p = Variant(1.0);
|
|
VariantTypeChanger<double>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::FLOAT);
|
|
CHECK(*p == Variant(0.));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<double>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::FLOAT);
|
|
CHECK(*p == Variant(0.));
|
|
}
|
|
|
|
SUBCASE("String") {
|
|
VariantTypeChanger<String>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING);
|
|
CHECK(*p == Variant(""));
|
|
|
|
*p = Variant(1.0);
|
|
VariantTypeChanger<String>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING);
|
|
CHECK(*p == Variant(""));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<String>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING);
|
|
CHECK(*p == Variant(""));
|
|
}
|
|
|
|
SUBCASE("Vector2") {
|
|
VariantTypeChanger<Vector2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2);
|
|
CHECK(*p == Variant(Vector2()));
|
|
|
|
*p = Variant(Vector2(1., 1.));
|
|
VariantTypeChanger<Vector2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2);
|
|
CHECK(*p == Variant(Vector2()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2);
|
|
CHECK(*p == Variant(Vector2()));
|
|
}
|
|
|
|
SUBCASE("Vector2i") {
|
|
VariantTypeChanger<Vector2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2I);
|
|
CHECK(*p == Variant(Vector2i()));
|
|
|
|
*p = Variant(Vector2i(1, 1));
|
|
VariantTypeChanger<Vector2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2I);
|
|
CHECK(*p == Variant(Vector2i()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR2I);
|
|
CHECK(*p == Variant(Vector2i()));
|
|
}
|
|
|
|
SUBCASE("Vector3") {
|
|
VariantTypeChanger<Vector3>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3);
|
|
CHECK(*p == Variant(Vector3()));
|
|
|
|
*p = Variant(Vector3(1., 1., 1.));
|
|
VariantTypeChanger<Vector3>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3);
|
|
CHECK(*p == Variant(Vector3()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector3>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3);
|
|
CHECK(*p == Variant(Vector3()));
|
|
}
|
|
|
|
SUBCASE("Vector3i") {
|
|
VariantTypeChanger<Vector3i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3I);
|
|
CHECK(*p == Variant(Vector3i()));
|
|
|
|
*p = Variant(Vector3i(1, 1, 1));
|
|
VariantTypeChanger<Vector3i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3I);
|
|
CHECK(*p == Variant(Vector3i()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector3i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR3I);
|
|
CHECK(*p == Variant(Vector3i()));
|
|
}
|
|
|
|
SUBCASE("Vector4") {
|
|
VariantTypeChanger<Vector4>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4);
|
|
CHECK(*p == Variant(Vector4()));
|
|
|
|
*p = Variant(Vector4(1., 1., 1., 1.));
|
|
VariantTypeChanger<Vector4>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4);
|
|
CHECK(*p == Variant(Vector4()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector4>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4);
|
|
CHECK(*p == Variant(Vector4()));
|
|
}
|
|
|
|
SUBCASE("Vector4i") {
|
|
VariantTypeChanger<Vector4i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4I);
|
|
CHECK(*p == Variant(Vector4i()));
|
|
|
|
*p = Variant(Vector4i(1, 1, 1, 1));
|
|
VariantTypeChanger<Vector4i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4I);
|
|
CHECK(*p == Variant(Vector4i()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Vector4i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::VECTOR4I);
|
|
CHECK(*p == Variant(Vector4i()));
|
|
}
|
|
|
|
SUBCASE("Rect2") {
|
|
VariantTypeChanger<Rect2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2);
|
|
CHECK(*p == Variant(Rect2()));
|
|
|
|
*p = Variant(Rect2(1., 1., 1., 1.));
|
|
VariantTypeChanger<Rect2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2);
|
|
CHECK(*p == Variant(Rect2()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Rect2>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2);
|
|
CHECK(*p == Variant(Rect2()));
|
|
}
|
|
|
|
SUBCASE("Rect2i") {
|
|
VariantTypeChanger<Rect2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2I);
|
|
CHECK(*p == Variant(Rect2i()));
|
|
|
|
*p = Variant(Rect2i(1, 1, 1, 1));
|
|
VariantTypeChanger<Rect2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2I);
|
|
CHECK(*p == Variant(Rect2i()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Rect2i>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RECT2I);
|
|
CHECK(*p == Variant(Rect2i()));
|
|
}
|
|
|
|
SUBCASE("Transform3D") {
|
|
VariantTypeChanger<Transform3D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM3D);
|
|
CHECK(*p == Variant(Transform3D()));
|
|
|
|
Transform3D t;
|
|
t.origin = Vector3(1, 1, 1);
|
|
*p = Variant(t);
|
|
VariantTypeChanger<Transform3D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM3D);
|
|
CHECK(*p == Variant(Transform3D()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Transform3D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM3D);
|
|
CHECK(*p == Variant(Transform3D()));
|
|
}
|
|
|
|
SUBCASE("Projection") {
|
|
VariantTypeChanger<Projection>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PROJECTION);
|
|
CHECK(*p == Variant(Projection()));
|
|
|
|
Projection pj;
|
|
pj.columns[0].x = 1;
|
|
*p = Variant(pj);
|
|
VariantTypeChanger<Projection>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PROJECTION);
|
|
CHECK(*p == Variant(Projection()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Projection>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PROJECTION);
|
|
CHECK(*p == Variant(Projection()));
|
|
}
|
|
|
|
SUBCASE("Transform2D") {
|
|
VariantTypeChanger<Transform2D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM2D);
|
|
CHECK(*p == Variant(Transform2D()));
|
|
|
|
Transform2D t;
|
|
t *= 2;
|
|
*p = Variant(t);
|
|
VariantTypeChanger<Transform2D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM2D);
|
|
CHECK(*p == Variant(Transform2D()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Transform2D>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::TRANSFORM2D);
|
|
CHECK(*p == Variant(Transform2D()));
|
|
}
|
|
|
|
SUBCASE("Quaternion") {
|
|
VariantTypeChanger<Quaternion>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::QUATERNION);
|
|
CHECK(*p == Variant(Quaternion()));
|
|
|
|
*p = Variant(Quaternion(1., 2., 3., 4.));
|
|
VariantTypeChanger<Quaternion>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::QUATERNION);
|
|
CHECK(*p == Variant(Quaternion()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Quaternion>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::QUATERNION);
|
|
CHECK(*p == Variant(Quaternion()));
|
|
}
|
|
|
|
SUBCASE("Plane") {
|
|
VariantTypeChanger<Plane>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PLANE);
|
|
CHECK(*p == Variant(Plane()));
|
|
|
|
*p = Variant(Plane(Vector3(), 1.));
|
|
VariantTypeChanger<Plane>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PLANE);
|
|
CHECK(*p == Variant(Plane()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Plane>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PLANE);
|
|
CHECK(*p == Variant(Plane()));
|
|
}
|
|
|
|
SUBCASE("Basis") {
|
|
VariantTypeChanger<Basis>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BASIS);
|
|
CHECK(*p == Variant(Basis()));
|
|
|
|
*p = Variant(Basis::from_scale(Vector3::UP));
|
|
VariantTypeChanger<Basis>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BASIS);
|
|
CHECK(*p == Variant(Basis()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Basis>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::BASIS);
|
|
CHECK(*p == Variant(Basis()));
|
|
}
|
|
|
|
SUBCASE("AABB") {
|
|
VariantTypeChanger<AABB>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::AABB);
|
|
CHECK(*p == Variant(AABB()));
|
|
|
|
*p = Variant(AABB(Vector3::UP, Vector3::RIGHT));
|
|
VariantTypeChanger<AABB>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::AABB);
|
|
CHECK(*p == Variant(AABB()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<AABB>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::AABB);
|
|
CHECK(*p == Variant(AABB()));
|
|
}
|
|
|
|
SUBCASE("Color") {
|
|
VariantTypeChanger<Color>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::COLOR);
|
|
CHECK(*p == Variant(Color()));
|
|
|
|
*p = Variant(Color::from_hsv(0.5, 0.5, 0.5));
|
|
VariantTypeChanger<Color>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::COLOR);
|
|
CHECK(*p == Variant(Color()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Color>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::COLOR);
|
|
CHECK(*p == Variant(Color()));
|
|
}
|
|
|
|
SUBCASE("StringName") {
|
|
VariantTypeChanger<StringName>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING_NAME);
|
|
CHECK(*p == Variant(StringName()));
|
|
|
|
*p = Variant(StringName("abc"));
|
|
VariantTypeChanger<StringName>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING_NAME);
|
|
CHECK(*p == Variant(StringName()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<StringName>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::STRING_NAME);
|
|
CHECK(*p == Variant(StringName()));
|
|
}
|
|
|
|
SUBCASE("NodePath") {
|
|
VariantTypeChanger<NodePath>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::NODE_PATH);
|
|
CHECK(*p == Variant(NodePath()));
|
|
|
|
*p = Variant(NodePath("abc"));
|
|
VariantTypeChanger<NodePath>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::NODE_PATH);
|
|
CHECK(*p == Variant(NodePath()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<NodePath>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::NODE_PATH);
|
|
CHECK(*p == Variant(NodePath()));
|
|
}
|
|
|
|
SUBCASE("RID") {
|
|
VariantTypeChanger<RID>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RID);
|
|
CHECK(*p == Variant(RID()));
|
|
|
|
*p = Variant(RID::from_uint64(123ull));
|
|
VariantTypeChanger<RID>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RID);
|
|
CHECK(*p == Variant(RID()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<RID>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::RID);
|
|
CHECK(*p == Variant(RID()));
|
|
}
|
|
|
|
SUBCASE("Callable") {
|
|
VariantTypeChanger<Callable>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::CALLABLE);
|
|
CHECK(*p == Variant(Callable()));
|
|
|
|
Object o;
|
|
*p = Variant(Callable(&o, "abc"));
|
|
VariantTypeChanger<Callable>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::CALLABLE);
|
|
CHECK(*p == Variant(Callable()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Callable>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::CALLABLE);
|
|
CHECK(*p == Variant(Callable()));
|
|
}
|
|
|
|
SUBCASE("Signal") {
|
|
VariantTypeChanger<Signal>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::SIGNAL);
|
|
CHECK(*p == Variant(Signal()));
|
|
|
|
Object o;
|
|
*p = Variant(Signal(&o, "abc"));
|
|
VariantTypeChanger<Signal>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::SIGNAL);
|
|
CHECK(*p == Variant(Signal()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Signal>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::SIGNAL);
|
|
CHECK(*p == Variant(Signal()));
|
|
}
|
|
|
|
SUBCASE("Dictionary") {
|
|
VariantTypeChanger<Dictionary>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::DICTIONARY);
|
|
CHECK(*p == Variant(Dictionary()));
|
|
|
|
*p = Variant(Dictionary{ KeyValue{ Variant(1), Variant(2) } });
|
|
VariantTypeChanger<Dictionary>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::DICTIONARY);
|
|
CHECK(*p == Variant(Dictionary()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Dictionary>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::DICTIONARY);
|
|
CHECK(*p == Variant(Dictionary()));
|
|
}
|
|
|
|
SUBCASE("Array") {
|
|
VariantTypeChanger<Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::ARRAY);
|
|
CHECK(*p == Variant(Array()));
|
|
|
|
*p = Variant(Array{ Variant(1) });
|
|
VariantTypeChanger<Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::ARRAY);
|
|
CHECK(*p == Variant(Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::ARRAY);
|
|
CHECK(*p == Variant(Array()));
|
|
}
|
|
|
|
SUBCASE("PackedByteArray") {
|
|
VariantTypeChanger<PackedByteArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_BYTE_ARRAY);
|
|
CHECK(*p == Variant(PackedByteArray()));
|
|
|
|
*p = Variant(PackedByteArray{ 1, 2 });
|
|
VariantTypeChanger<PackedByteArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_BYTE_ARRAY);
|
|
CHECK(*p == Variant(PackedByteArray()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedByteArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_BYTE_ARRAY);
|
|
CHECK(*p == Variant(PackedByteArray()));
|
|
}
|
|
|
|
SUBCASE("PackedInt32Array") {
|
|
VariantTypeChanger<PackedInt32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT32_ARRAY);
|
|
CHECK(*p == Variant(PackedInt32Array()));
|
|
|
|
*p = Variant(PackedInt32Array{ 1, 2 });
|
|
VariantTypeChanger<PackedInt32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT32_ARRAY);
|
|
CHECK(*p == Variant(PackedInt32Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedInt32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT32_ARRAY);
|
|
CHECK(*p == Variant(PackedInt32Array()));
|
|
}
|
|
|
|
SUBCASE("PackedInt64Array") {
|
|
VariantTypeChanger<PackedInt64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT64_ARRAY);
|
|
CHECK(*p == Variant(PackedInt64Array()));
|
|
|
|
*p = Variant(PackedInt64Array{ 1, 2 });
|
|
VariantTypeChanger<PackedInt64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT64_ARRAY);
|
|
CHECK(*p == Variant(PackedInt64Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedInt64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_INT64_ARRAY);
|
|
CHECK(*p == Variant(PackedInt64Array()));
|
|
}
|
|
|
|
SUBCASE("PackedFloat32Array") {
|
|
VariantTypeChanger<PackedFloat32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT32_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat32Array()));
|
|
|
|
*p = Variant(PackedFloat32Array{ 1, 2 });
|
|
VariantTypeChanger<PackedFloat32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT32_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat32Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedFloat32Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT32_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat32Array()));
|
|
}
|
|
|
|
SUBCASE("PackedFloat64Array") {
|
|
VariantTypeChanger<PackedFloat64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT64_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat64Array()));
|
|
|
|
*p = Variant(PackedFloat64Array{ 1, 2 });
|
|
VariantTypeChanger<PackedFloat64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT64_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat64Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedFloat64Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_FLOAT64_ARRAY);
|
|
CHECK(*p == Variant(PackedFloat64Array()));
|
|
}
|
|
|
|
SUBCASE("PackedStringArray") {
|
|
VariantTypeChanger<PackedStringArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_STRING_ARRAY);
|
|
CHECK(*p == Variant(PackedStringArray()));
|
|
|
|
*p = Variant(PackedStringArray{ "1", "2" });
|
|
VariantTypeChanger<PackedStringArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_STRING_ARRAY);
|
|
CHECK(*p == Variant(PackedStringArray()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedStringArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_STRING_ARRAY);
|
|
CHECK(*p == Variant(PackedStringArray()));
|
|
}
|
|
|
|
SUBCASE("PackedVector2Array") {
|
|
VariantTypeChanger<PackedVector2Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR2_ARRAY);
|
|
CHECK(*p == Variant(PackedVector2Array()));
|
|
|
|
*p = Variant(PackedVector2Array{ Vector2::UP, Vector2::RIGHT });
|
|
VariantTypeChanger<PackedVector2Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR2_ARRAY);
|
|
CHECK(*p == Variant(PackedVector2Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedVector2Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR2_ARRAY);
|
|
CHECK(*p == Variant(PackedVector2Array()));
|
|
}
|
|
|
|
SUBCASE("PackedVector3Array") {
|
|
VariantTypeChanger<PackedVector3Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR3_ARRAY);
|
|
CHECK(*p == Variant(PackedVector3Array()));
|
|
|
|
*p = Variant(PackedVector3Array{ Vector3::UP, Vector3::RIGHT });
|
|
VariantTypeChanger<PackedVector3Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR3_ARRAY);
|
|
CHECK(*p == Variant(PackedVector3Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedVector3Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR3_ARRAY);
|
|
CHECK(*p == Variant(PackedVector3Array()));
|
|
}
|
|
|
|
SUBCASE("PackedColorArray") {
|
|
VariantTypeChanger<PackedColorArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_COLOR_ARRAY);
|
|
CHECK(*p == Variant(PackedColorArray()));
|
|
|
|
*p = Variant(PackedColorArray{ Color::from_hsv(0., .1, .2) });
|
|
VariantTypeChanger<PackedColorArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_COLOR_ARRAY);
|
|
CHECK(*p == Variant(PackedColorArray()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedColorArray>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_COLOR_ARRAY);
|
|
CHECK(*p == Variant(PackedColorArray()));
|
|
}
|
|
|
|
SUBCASE("PackedVector4Array") {
|
|
VariantTypeChanger<PackedVector4Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR4_ARRAY);
|
|
CHECK(*p == Variant(PackedVector4Array()));
|
|
|
|
*p = Variant(PackedVector4Array{ Vector4(1, 2, 3, 4) });
|
|
VariantTypeChanger<PackedVector4Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR4_ARRAY);
|
|
CHECK(*p == Variant(PackedVector4Array()));
|
|
|
|
*p = Variant(true);
|
|
VariantTypeChanger<PackedVector4Array>::change_and_reset(p);
|
|
CHECK(p->get_type() == Variant::Type::PACKED_VECTOR4_ARRAY);
|
|
CHECK(*p == Variant(PackedVector4Array()));
|
|
}
|
|
|
|
delete p;
|
|
}
|
|
|
|
} // namespace TestVariantInitialization
|