diff --git a/core/variant/variant_internal.h b/core/variant/variant_internal.h
index 37fdd8f554..bbd1887fd4 100644
--- a/core/variant/variant_internal.h
+++ b/core/variant/variant_internal.h
@@ -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);
 	}
 };
 
diff --git a/tests/core/variant/test_variant_initialization.cpp b/tests/core/variant/test_variant_initialization.cpp
new file mode 100644
index 0000000000..f30d4dfcd2
--- /dev/null
+++ b/tests/core/variant/test_variant_initialization.cpp
@@ -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