Fix Variant double instantiation in VariantTypeChanger::change_and_reset
This commit is contained in:
aurpine
@@ -861,7 +861,7 @@ struct VariantInitializer {
|
||||
template <typename T>
|
||||
struct VariantInitializer<T, std::enable_if_t<VariantInternalAccessor<T>::is_local>> {
|
||||
static _FORCE_INLINE_ void init(Variant *v) {
|
||||
memnew_placement(&VariantInternalAccessor<T>::get(v), T);
|
||||
memnew_placement(&VariantInternalAccessor<T>::get(v), T());
|
||||
VariantInternal::set_type(*v, GetTypeInfo<T>::VARIANT_TYPE);
|
||||
}
|
||||
};
|
||||
@@ -969,9 +969,9 @@ struct VariantTypeChanger {
|
||||
if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer
|
||||
VariantInternal::clear(v);
|
||||
VariantInitializer<T>::init(v);
|
||||
} else {
|
||||
VariantDefaultInitializer<T>::init(v);
|
||||
}
|
||||
|
||||
VariantDefaultInitializer<T>::init(v);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -0,0 +1,648 @@
|
||||
/**************************************************************************/
|
||||
/* 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
|
||||
Reference in New Issue
Block a user