GDScript: Replace `assert()` with `Utils.check()` in tests

10 files changed, 209 insertions, 215 deletions

diff --git a/modules/gdscript/tests/scripts/analyzer/features/assymetric_assignment_good.gd b/modules/gdscript/tests/scripts/analyzer/features/assymetric_assignment_good.gd
index efd8ad6edb..60bcde4b8c 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/assymetric_assignment_good.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/assymetric_assignment_good.gd
@@ -3,14 +3,13 @@ const const_color: Color = 'red'
 func func_color(arg_color: Color = 'blue') -> bool:
 	return arg_color == Color.BLUE
 
-@warning_ignore("assert_always_true")
 func test():
-	assert(const_color == Color.RED)
+	Utils.check(const_color == Color.RED)
 
-	assert(func_color() == true)
-	assert(func_color('blue') == true)
+	Utils.check(func_color() == true)
+	Utils.check(func_color('blue') == true)
 
 	var var_color: Color = 'green'
-	assert(var_color == Color.GREEN)
+	Utils.check(var_color == Color.GREEN)
 
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/const_conversions.gd b/modules/gdscript/tests/scripts/analyzer/features/const_conversions.gd
index bed9dd0e96..5318d11f33 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/const_conversions.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/const_conversions.gd
@@ -5,20 +5,19 @@ const const_float_cast: float = 76 as float
 const const_packed_empty: PackedFloat64Array = []
 const const_packed_ints: PackedFloat64Array = [52]
 
-@warning_ignore("assert_always_true")
 func test():
-	assert(typeof(const_float_int) == TYPE_FLOAT)
-	assert(str(const_float_int) == '19')
-	assert(typeof(const_float_plus) == TYPE_FLOAT)
-	assert(str(const_float_plus) == '34')
-	assert(typeof(const_float_cast) == TYPE_FLOAT)
-	assert(str(const_float_cast) == '76')
+	Utils.check(typeof(const_float_int) == TYPE_FLOAT)
+	Utils.check(str(const_float_int) == '19')
+	Utils.check(typeof(const_float_plus) == TYPE_FLOAT)
+	Utils.check(str(const_float_plus) == '34')
+	Utils.check(typeof(const_float_cast) == TYPE_FLOAT)
+	Utils.check(str(const_float_cast) == '76')
 
-	assert(typeof(const_packed_empty) == TYPE_PACKED_FLOAT64_ARRAY)
-	assert(str(const_packed_empty) == '[]')
-	assert(typeof(const_packed_ints) == TYPE_PACKED_FLOAT64_ARRAY)
-	assert(str(const_packed_ints) == '[52]')
-	assert(typeof(const_packed_ints[0]) == TYPE_FLOAT)
-	assert(str(const_packed_ints[0]) == '52')
+	Utils.check(typeof(const_packed_empty) == TYPE_PACKED_FLOAT64_ARRAY)
+	Utils.check(str(const_packed_empty) == '[]')
+	Utils.check(typeof(const_packed_ints) == TYPE_PACKED_FLOAT64_ARRAY)
+	Utils.check(str(const_packed_ints) == '[52]')
+	Utils.check(typeof(const_packed_ints[0]) == TYPE_FLOAT)
+	Utils.check(str(const_packed_ints[0]) == '52')
 
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/enums_in_range_call.gd b/modules/gdscript/tests/scripts/analyzer/features/enums_in_range_call.gd
index d2d9d04508..a569488d3c 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/enums_in_range_call.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/enums_in_range_call.gd
@@ -5,5 +5,5 @@ func test():
 	for value in range(E.E0, E.E3):
 		var inferable := value
 		total += inferable
-	assert(total == 0 + 1 + 2)
+	Utils.check(total == 0 + 1 + 2)
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/export_enum_as_dictionary.gd b/modules/gdscript/tests/scripts/analyzer/features/export_enum_as_dictionary.gd
index 39f490c4b3..ec89226328 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/export_enum_as_dictionary.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/export_enum_as_dictionary.gd
@@ -2,8 +2,6 @@ class_name TestExportEnumAsDictionary
 
 enum MyEnum {A, B, C}
 
-const Utils = preload("../../utils.notest.gd")
-
 @export var test_1 = MyEnum
 @export var test_2 = MyEnum.A
 @export var test_3 := MyEnum
diff --git a/modules/gdscript/tests/scripts/analyzer/features/for_range_usage.gd b/modules/gdscript/tests/scripts/analyzer/features/for_range_usage.gd
index 4a7f10f1ee..9ce0782d5c 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/for_range_usage.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/for_range_usage.gd
@@ -3,5 +3,5 @@ func test():
 	var result := ''
 	for i in range(array.size(), 0, -1):
 		result += str(array[i - 1])
-	assert(result == '963')
+	Utils.check(result == '963')
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/function_match_parent_signature_with_extra_parameters.gd b/modules/gdscript/tests/scripts/analyzer/features/function_match_parent_signature_with_extra_parameters.gd
index d678f3acfc..e0cbdacb38 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/function_match_parent_signature_with_extra_parameters.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/function_match_parent_signature_with_extra_parameters.gd
@@ -2,11 +2,11 @@ func test():
 	var instance := Parent.new()
 	var result := instance.my_function(1)
 	print(result)
-	assert(result == 1)
+	Utils.check(result == 1)
 	instance = Child.new()
 	result = instance.my_function(2)
 	print(result)
-	assert(result == 0)
+	Utils.check(result == 0)
 
 class Parent:
 	func my_function(par1: int) -> int:
diff --git a/modules/gdscript/tests/scripts/analyzer/features/return_conversions.gd b/modules/gdscript/tests/scripts/analyzer/features/return_conversions.gd
index 0b1576e66e..cbe8e9da34 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/return_conversions.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/return_conversions.gd
@@ -8,27 +8,27 @@ func convert_var_array_to_packed() -> PackedStringArray: var array := ['79']; re
 
 func test():
 	var converted_literal_int := convert_literal_int_to_float()
-	assert(typeof(converted_literal_int) == TYPE_FLOAT)
-	assert(converted_literal_int == 76.0)
+	Utils.check(typeof(converted_literal_int) == TYPE_FLOAT)
+	Utils.check(converted_literal_int == 76.0)
 
 	var converted_arg_int := convert_arg_int_to_float(36)
-	assert(typeof(converted_arg_int) == TYPE_FLOAT)
-	assert(converted_arg_int == 36.0)
+	Utils.check(typeof(converted_arg_int) == TYPE_FLOAT)
+	Utils.check(converted_arg_int == 36.0)
 
 	var converted_var_int := convert_var_int_to_float()
-	assert(typeof(converted_var_int) == TYPE_FLOAT)
-	assert(converted_var_int == 59.0)
+	Utils.check(typeof(converted_var_int) == TYPE_FLOAT)
+	Utils.check(converted_var_int == 59.0)
 
 	var converted_literal_array := convert_literal_array_to_packed()
-	assert(typeof(converted_literal_array) == TYPE_PACKED_STRING_ARRAY)
-	assert(str(converted_literal_array) == '["46"]')
+	Utils.check(typeof(converted_literal_array) == TYPE_PACKED_STRING_ARRAY)
+	Utils.check(str(converted_literal_array) == '["46"]')
 
 	var converted_arg_array := convert_arg_array_to_packed(['91'])
-	assert(typeof(converted_arg_array) == TYPE_PACKED_STRING_ARRAY)
-	assert(str(converted_arg_array) == '["91"]')
+	Utils.check(typeof(converted_arg_array) == TYPE_PACKED_STRING_ARRAY)
+	Utils.check(str(converted_arg_array) == '["91"]')
 
 	var converted_var_array := convert_var_array_to_packed()
-	assert(typeof(converted_var_array) == TYPE_PACKED_STRING_ARRAY)
-	assert(str(converted_var_array) == '["79"]')
+	Utils.check(typeof(converted_var_array) == TYPE_PACKED_STRING_ARRAY)
+	Utils.check(str(converted_var_array) == '["79"]')
 
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/ternary_hard_infer.gd b/modules/gdscript/tests/scripts/analyzer/features/ternary_hard_infer.gd
index 44ca5f4dd0..d49acaacd3 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/ternary_hard_infer.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/ternary_hard_infer.gd
@@ -2,7 +2,7 @@ func test():
 	var left_hard_int := 1
 	var right_hard_int := 2
 	var result_hard_int := left_hard_int if true else right_hard_int
-	assert(result_hard_int == 1)
+	Utils.check(result_hard_int == 1)
 
 	@warning_ignore("inference_on_variant")
 	var left_hard_variant := 1 as Variant
@@ -10,6 +10,6 @@ func test():
 	var right_hard_variant := 2.0 as Variant
 	@warning_ignore("inference_on_variant")
 	var result_hard_variant := left_hard_variant if true else right_hard_variant
-	assert(result_hard_variant == 1)
+	Utils.check(result_hard_variant == 1)
 
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/type_test_usage.gd b/modules/gdscript/tests/scripts/analyzer/features/type_test_usage.gd
index 12dc0b93df..ee30f01dfb 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/type_test_usage.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/type_test_usage.gd
@@ -4,124 +4,123 @@ class A extends RefCounted:
 class B extends A:
 	pass
 
-@warning_ignore("assert_always_true")
 func test():
 	var builtin: Variant = 3
-	assert((builtin is Variant) == true)
-	assert((builtin is int) == true)
-	assert(is_instance_of(builtin, TYPE_INT) == true)
-	assert((builtin is float) == false)
-	assert(is_instance_of(builtin, TYPE_FLOAT) == false)
+	Utils.check((builtin is Variant) == true)
+	Utils.check((builtin is int) == true)
+	Utils.check(is_instance_of(builtin, TYPE_INT) == true)
+	Utils.check((builtin is float) == false)
+	Utils.check(is_instance_of(builtin, TYPE_FLOAT) == false)
 
 	const const_builtin: Variant = 3
-	assert((const_builtin is Variant) == true)
-	assert((const_builtin is int) == true)
-	assert(is_instance_of(const_builtin, TYPE_INT) == true)
-	assert((const_builtin is float) == false)
-	assert(is_instance_of(const_builtin, TYPE_FLOAT) == false)
+	Utils.check((const_builtin is Variant) == true)
+	Utils.check((const_builtin is int) == true)
+	Utils.check(is_instance_of(const_builtin, TYPE_INT) == true)
+	Utils.check((const_builtin is float) == false)
+	Utils.check(is_instance_of(const_builtin, TYPE_FLOAT) == false)
 
 	var int_array: Variant = [] as Array[int]
-	assert((int_array is Variant) == true)
-	assert((int_array is Array) == true)
-	assert(is_instance_of(int_array, TYPE_ARRAY) == true)
-	assert((int_array is Array[int]) == true)
-	assert((int_array is Array[float]) == false)
-	assert((int_array is int) == false)
-	assert(is_instance_of(int_array, TYPE_INT) == false)
+	Utils.check((int_array is Variant) == true)
+	Utils.check((int_array is Array) == true)
+	Utils.check(is_instance_of(int_array, TYPE_ARRAY) == true)
+	Utils.check((int_array is Array[int]) == true)
+	Utils.check((int_array is Array[float]) == false)
+	Utils.check((int_array is int) == false)
+	Utils.check(is_instance_of(int_array, TYPE_INT) == false)
 
 	var const_int_array: Variant = [] as Array[int]
-	assert((const_int_array is Variant) == true)
-	assert((const_int_array is Array) == true)
-	assert(is_instance_of(const_int_array, TYPE_ARRAY) == true)
-	assert((const_int_array is Array[int]) == true)
-	assert((const_int_array is Array[float]) == false)
-	assert((const_int_array is int) == false)
-	assert(is_instance_of(const_int_array, TYPE_INT) == false)
+	Utils.check((const_int_array is Variant) == true)
+	Utils.check((const_int_array is Array) == true)
+	Utils.check(is_instance_of(const_int_array, TYPE_ARRAY) == true)
+	Utils.check((const_int_array is Array[int]) == true)
+	Utils.check((const_int_array is Array[float]) == false)
+	Utils.check((const_int_array is int) == false)
+	Utils.check(is_instance_of(const_int_array, TYPE_INT) == false)
 
 	var b_array: Variant = [] as Array[B]
-	assert((b_array is Variant) == true)
-	assert((b_array is Array) == true)
-	assert(is_instance_of(b_array, TYPE_ARRAY) == true)
-	assert((b_array is Array[B]) == true)
-	assert((b_array is Array[A]) == false)
-	assert((b_array is Array[int]) == false)
-	assert((b_array is int) == false)
-	assert(is_instance_of(b_array, TYPE_INT) == false)
+	Utils.check((b_array is Variant) == true)
+	Utils.check((b_array is Array) == true)
+	Utils.check(is_instance_of(b_array, TYPE_ARRAY) == true)
+	Utils.check((b_array is Array[B]) == true)
+	Utils.check((b_array is Array[A]) == false)
+	Utils.check((b_array is Array[int]) == false)
+	Utils.check((b_array is int) == false)
+	Utils.check(is_instance_of(b_array, TYPE_INT) == false)
 
 	var const_b_array: Variant = [] as Array[B]
-	assert((const_b_array is Variant) == true)
-	assert((const_b_array is Array) == true)
-	assert(is_instance_of(const_b_array, TYPE_ARRAY) == true)
-	assert((const_b_array is Array[B]) == true)
-	assert((const_b_array is Array[A]) == false)
-	assert((const_b_array is Array[int]) == false)
-	assert((const_b_array is int) == false)
-	assert(is_instance_of(const_b_array, TYPE_INT) == false)
+	Utils.check((const_b_array is Variant) == true)
+	Utils.check((const_b_array is Array) == true)
+	Utils.check(is_instance_of(const_b_array, TYPE_ARRAY) == true)
+	Utils.check((const_b_array is Array[B]) == true)
+	Utils.check((const_b_array is Array[A]) == false)
+	Utils.check((const_b_array is Array[int]) == false)
+	Utils.check((const_b_array is int) == false)
+	Utils.check(is_instance_of(const_b_array, TYPE_INT) == false)
 
 	var native: Variant = RefCounted.new()
-	assert((native is Variant) == true)
-	assert((native is Object) == true)
-	assert(is_instance_of(native, TYPE_OBJECT) == true)
-	assert(is_instance_of(native, Object) == true)
-	assert((native is RefCounted) == true)
-	assert(is_instance_of(native, RefCounted) == true)
-	assert((native is Node) == false)
-	assert(is_instance_of(native, Node) == false)
-	assert((native is int) == false)
-	assert(is_instance_of(native, TYPE_INT) == false)
+	Utils.check((native is Variant) == true)
+	Utils.check((native is Object) == true)
+	Utils.check(is_instance_of(native, TYPE_OBJECT) == true)
+	Utils.check(is_instance_of(native, Object) == true)
+	Utils.check((native is RefCounted) == true)
+	Utils.check(is_instance_of(native, RefCounted) == true)
+	Utils.check((native is Node) == false)
+	Utils.check(is_instance_of(native, Node) == false)
+	Utils.check((native is int) == false)
+	Utils.check(is_instance_of(native, TYPE_INT) == false)
 
 	var a_script: Variant = A.new()
-	assert((a_script is Variant) == true)
-	assert((a_script is Object) == true)
-	assert(is_instance_of(a_script, TYPE_OBJECT) == true)
-	assert(is_instance_of(a_script, Object) == true)
-	assert((a_script is RefCounted) == true)
-	assert(is_instance_of(a_script, RefCounted) == true)
-	assert((a_script is A) == true)
-	assert(is_instance_of(a_script, A) == true)
-	assert((a_script is B) == false)
-	assert(is_instance_of(a_script, B) == false)
-	assert((a_script is Node) == false)
-	assert(is_instance_of(a_script, Node) == false)
-	assert((a_script is int) == false)
-	assert(is_instance_of(a_script, TYPE_INT) == false)
+	Utils.check((a_script is Variant) == true)
+	Utils.check((a_script is Object) == true)
+	Utils.check(is_instance_of(a_script, TYPE_OBJECT) == true)
+	Utils.check(is_instance_of(a_script, Object) == true)
+	Utils.check((a_script is RefCounted) == true)
+	Utils.check(is_instance_of(a_script, RefCounted) == true)
+	Utils.check((a_script is A) == true)
+	Utils.check(is_instance_of(a_script, A) == true)
+	Utils.check((a_script is B) == false)
+	Utils.check(is_instance_of(a_script, B) == false)
+	Utils.check((a_script is Node) == false)
+	Utils.check(is_instance_of(a_script, Node) == false)
+	Utils.check((a_script is int) == false)
+	Utils.check(is_instance_of(a_script, TYPE_INT) == false)
 
 	var b_script: Variant = B.new()
-	assert((b_script is Variant) == true)
-	assert((b_script is Object) == true)
-	assert(is_instance_of(b_script, TYPE_OBJECT) == true)
-	assert(is_instance_of(b_script, Object) == true)
-	assert((b_script is RefCounted) == true)
-	assert(is_instance_of(b_script, RefCounted) == true)
-	assert((b_script is A) == true)
-	assert(is_instance_of(b_script, A) == true)
-	assert((b_script is B) == true)
-	assert(is_instance_of(b_script, B) == true)
-	assert((b_script is Node) == false)
-	assert(is_instance_of(b_script, Node) == false)
-	assert((b_script is int) == false)
-	assert(is_instance_of(b_script, TYPE_INT) == false)
+	Utils.check((b_script is Variant) == true)
+	Utils.check((b_script is Object) == true)
+	Utils.check(is_instance_of(b_script, TYPE_OBJECT) == true)
+	Utils.check(is_instance_of(b_script, Object) == true)
+	Utils.check((b_script is RefCounted) == true)
+	Utils.check(is_instance_of(b_script, RefCounted) == true)
+	Utils.check((b_script is A) == true)
+	Utils.check(is_instance_of(b_script, A) == true)
+	Utils.check((b_script is B) == true)
+	Utils.check(is_instance_of(b_script, B) == true)
+	Utils.check((b_script is Node) == false)
+	Utils.check(is_instance_of(b_script, Node) == false)
+	Utils.check((b_script is int) == false)
+	Utils.check(is_instance_of(b_script, TYPE_INT) == false)
 
 	var var_null: Variant = null
-	assert((var_null is Variant) == true)
-	assert((var_null is int) == false)
-	assert(is_instance_of(var_null, TYPE_INT) == false)
-	assert((var_null is Object) == false)
-	assert(is_instance_of(var_null, TYPE_OBJECT) == false)
-	assert((var_null is RefCounted) == false)
-	assert(is_instance_of(var_null, RefCounted) == false)
-	assert((var_null is A) == false)
-	assert(is_instance_of(var_null, A) == false)
+	Utils.check((var_null is Variant) == true)
+	Utils.check((var_null is int) == false)
+	Utils.check(is_instance_of(var_null, TYPE_INT) == false)
+	Utils.check((var_null is Object) == false)
+	Utils.check(is_instance_of(var_null, TYPE_OBJECT) == false)
+	Utils.check((var_null is RefCounted) == false)
+	Utils.check(is_instance_of(var_null, RefCounted) == false)
+	Utils.check((var_null is A) == false)
+	Utils.check(is_instance_of(var_null, A) == false)
 
 	const const_null: Variant = null
-	assert((const_null is Variant) == true)
-	assert((const_null is int) == false)
-	assert(is_instance_of(const_null, TYPE_INT) == false)
-	assert((const_null is Object) == false)
-	assert(is_instance_of(const_null, TYPE_OBJECT) == false)
-	assert((const_null is RefCounted) == false)
-	assert(is_instance_of(const_null, RefCounted) == false)
-	assert((const_null is A) == false)
-	assert(is_instance_of(const_null, A) == false)
+	Utils.check((const_null is Variant) == true)
+	Utils.check((const_null is int) == false)
+	Utils.check(is_instance_of(const_null, TYPE_INT) == false)
+	Utils.check((const_null is Object) == false)
+	Utils.check(is_instance_of(const_null, TYPE_OBJECT) == false)
+	Utils.check((const_null is RefCounted) == false)
+	Utils.check(is_instance_of(const_null, RefCounted) == false)
+	Utils.check((const_null is A) == false)
+	Utils.check(is_instance_of(const_null, A) == false)
 
 	print('ok')
diff --git a/modules/gdscript/tests/scripts/analyzer/features/typed_array_usage.gd b/modules/gdscript/tests/scripts/analyzer/features/typed_array_usage.gd
index b000c82717..fe0274c27b 100644
--- a/modules/gdscript/tests/scripts/analyzer/features/typed_array_usage.gd
+++ b/modules/gdscript/tests/scripts/analyzer/features/typed_array_usage.gd
@@ -10,206 +10,205 @@ class Members:
 	var two: Array[int] = one
 
 	func check_passing() -> bool:
-		assert(str(one) == '[104]')
-		assert(str(two) == '[104]')
+		Utils.check(str(one) == '[104]')
+		Utils.check(str(two) == '[104]')
 		two.push_back(582)
-		assert(str(one) == '[104, 582]')
-		assert(str(two) == '[104, 582]')
+		Utils.check(str(one) == '[104, 582]')
+		Utils.check(str(two) == '[104, 582]')
 		two = [486]
-		assert(str(one) == '[104, 582]')
-		assert(str(two) == '[486]')
+		Utils.check(str(one) == '[104, 582]')
+		Utils.check(str(two) == '[486]')
 		return true
 
 
 @warning_ignore("unsafe_method_access")
-@warning_ignore("assert_always_true")
 @warning_ignore("return_value_discarded")
 func test():
 	var untyped_basic = [459]
-	assert(str(untyped_basic) == '[459]')
-	assert(untyped_basic.get_typed_builtin() == TYPE_NIL)
+	Utils.check(str(untyped_basic) == '[459]')
+	Utils.check(untyped_basic.get_typed_builtin() == TYPE_NIL)
 
 	var inferred_basic := [366]
-	assert(str(inferred_basic) == '[366]')
-	assert(inferred_basic.get_typed_builtin() == TYPE_NIL)
+	Utils.check(str(inferred_basic) == '[366]')
+	Utils.check(inferred_basic.get_typed_builtin() == TYPE_NIL)
 
 	var typed_basic: Array = [521]
-	assert(str(typed_basic) == '[521]')
-	assert(typed_basic.get_typed_builtin() == TYPE_NIL)
+	Utils.check(str(typed_basic) == '[521]')
+	Utils.check(typed_basic.get_typed_builtin() == TYPE_NIL)
 
 
 	var empty_floats: Array[float] = []
-	assert(str(empty_floats) == '[]')
-	assert(empty_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(empty_floats) == '[]')
+	Utils.check(empty_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	untyped_basic = empty_floats
-	assert(untyped_basic.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(untyped_basic.get_typed_builtin() == TYPE_FLOAT)
 
 	inferred_basic = empty_floats
-	assert(inferred_basic.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(inferred_basic.get_typed_builtin() == TYPE_FLOAT)
 
 	typed_basic = empty_floats
-	assert(typed_basic.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(typed_basic.get_typed_builtin() == TYPE_FLOAT)
 
 	empty_floats.push_back(705.0)
 	untyped_basic.push_back(430.0)
 	inferred_basic.push_back(263.0)
 	typed_basic.push_back(518.0)
-	assert(str(empty_floats) == '[705, 430, 263, 518]')
-	assert(str(untyped_basic) == '[705, 430, 263, 518]')
-	assert(str(inferred_basic) == '[705, 430, 263, 518]')
-	assert(str(typed_basic) == '[705, 430, 263, 518]')
+	Utils.check(str(empty_floats) == '[705, 430, 263, 518]')
+	Utils.check(str(untyped_basic) == '[705, 430, 263, 518]')
+	Utils.check(str(inferred_basic) == '[705, 430, 263, 518]')
+	Utils.check(str(typed_basic) == '[705, 430, 263, 518]')
 
 
 	const constant_float := 950.0
 	const constant_int := 170
 	var typed_float := 954.0
 	var filled_floats: Array[float] = [constant_float, constant_int, typed_float, empty_floats[1] + empty_floats[2]]
-	assert(str(filled_floats) == '[950, 170, 954, 693]')
-	assert(filled_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(filled_floats) == '[950, 170, 954, 693]')
+	Utils.check(filled_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	var casted_floats := [empty_floats[2] * 2] as Array[float]
-	assert(str(casted_floats) == '[526]')
-	assert(casted_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(casted_floats) == '[526]')
+	Utils.check(casted_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	var returned_floats = (func () -> Array[float]: return [554]).call()
-	assert(str(returned_floats) == '[554]')
-	assert(returned_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(returned_floats) == '[554]')
+	Utils.check(returned_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	var passed_floats = floats_identity([663.0 if randf() > 0.5 else 663.0])
-	assert(str(passed_floats) == '[663]')
-	assert(passed_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(passed_floats) == '[663]')
+	Utils.check(passed_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	var default_floats = (func (floats: Array[float] = [364.0]): return floats).call()
-	assert(str(default_floats) == '[364]')
-	assert(default_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(default_floats) == '[364]')
+	Utils.check(default_floats.get_typed_builtin() == TYPE_FLOAT)
 
 	var typed_int := 556
 	var converted_floats: Array[float] = [typed_int]
 	converted_floats.push_back(498)
-	assert(str(converted_floats) == '[556, 498]')
-	assert(converted_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(converted_floats) == '[556, 498]')
+	Utils.check(converted_floats.get_typed_builtin() == TYPE_FLOAT)
 
 
 	const constant_basic = [228]
-	assert(str(constant_basic) == '[228]')
-	assert(constant_basic.get_typed_builtin() == TYPE_NIL)
+	Utils.check(str(constant_basic) == '[228]')
+	Utils.check(constant_basic.get_typed_builtin() == TYPE_NIL)
 
 	const constant_floats: Array[float] = [constant_float - constant_basic[0] - constant_int]
-	assert(str(constant_floats) == '[552]')
-	assert(constant_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(constant_floats) == '[552]')
+	Utils.check(constant_floats.get_typed_builtin() == TYPE_FLOAT)
 
 
 	var source_floats: Array[float] = [999.74]
 	untyped_basic = source_floats
 	var destination_floats: Array[float] = untyped_basic
 	destination_floats[0] -= 0.74
-	assert(str(source_floats) == '[999]')
-	assert(str(untyped_basic) == '[999]')
-	assert(str(destination_floats) == '[999]')
-	assert(destination_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(source_floats) == '[999]')
+	Utils.check(str(untyped_basic) == '[999]')
+	Utils.check(str(destination_floats) == '[999]')
+	Utils.check(destination_floats.get_typed_builtin() == TYPE_FLOAT)
 
 
 	var duplicated_floats := empty_floats.duplicate().slice(2, 3)
 	duplicated_floats[0] *= 3
-	assert(str(duplicated_floats) == '[789]')
-	assert(duplicated_floats.get_typed_builtin() == TYPE_FLOAT)
+	Utils.check(str(duplicated_floats) == '[789]')
+	Utils.check(duplicated_floats.get_typed_builtin() == TYPE_FLOAT)
 
 
 	var b_objects: Array[B] = [B.new(), B.new() as A, null]
-	assert(b_objects.size() == 3)
-	assert(b_objects.get_typed_builtin() == TYPE_OBJECT)
-	assert(b_objects.get_typed_script() == B)
+	Utils.check(b_objects.size() == 3)
+	Utils.check(b_objects.get_typed_builtin() == TYPE_OBJECT)
+	Utils.check(b_objects.get_typed_script() == B)
 
 	var a_objects: Array[A] = [A.new(), B.new(), null, b_objects[0]]
-	assert(a_objects.size() == 4)
-	assert(a_objects.get_typed_builtin() == TYPE_OBJECT)
-	assert(a_objects.get_typed_script() == A)
+	Utils.check(a_objects.size() == 4)
+	Utils.check(a_objects.get_typed_builtin() == TYPE_OBJECT)
+	Utils.check(a_objects.get_typed_script() == A)
 
 	var a_passed = (func check_a_passing(p_objects: Array[A]): return p_objects.size()).call(a_objects)
-	assert(a_passed == 4)
+	Utils.check(a_passed == 4)
 
 	var b_passed = (func check_b_passing(basic: Array): return basic[0] != null).call(b_objects)
-	assert(b_passed == true)
+	Utils.check(b_passed == true)
 
 
 	var empty_strings: Array[String] = []
 	var empty_bools: Array[bool] = []
 	var empty_basic_one := []
 	var empty_basic_two := []
-	assert(empty_strings == empty_bools)
-	assert(empty_basic_one == empty_basic_two)
-	assert(empty_strings.hash() == empty_bools.hash())
-	assert(empty_basic_one.hash() == empty_basic_two.hash())
+	Utils.check(empty_strings == empty_bools)
+	Utils.check(empty_basic_one == empty_basic_two)
+	Utils.check(empty_strings.hash() == empty_bools.hash())
+	Utils.check(empty_basic_one.hash() == empty_basic_two.hash())
 
 
 	var assign_source: Array[int] = [527]
 	var assign_target: Array[int] = []
 	assign_target.assign(assign_source)
-	assert(str(assign_source) == '[527]')
-	assert(str(assign_target) == '[527]')
+	Utils.check(str(assign_source) == '[527]')
+	Utils.check(str(assign_target) == '[527]')
 	assign_source.push_back(657)
-	assert(str(assign_source) == '[527, 657]')
-	assert(str(assign_target) == '[527]')
+	Utils.check(str(assign_source) == '[527, 657]')
+	Utils.check(str(assign_target) == '[527]')
 
 
 	var defaults_passed = (func check_defaults_passing(one: Array[int] = [], two := one):
 		one.push_back(887)
 		two.push_back(198)
-		assert(str(one) == '[887, 198]')
-		assert(str(two) == '[887, 198]')
+		Utils.check(str(one) == '[887, 198]')
+		Utils.check(str(two) == '[887, 198]')
 		two = [130]
-		assert(str(one) == '[887, 198]')
-		assert(str(two) == '[130]')
+		Utils.check(str(one) == '[887, 198]')
+		Utils.check(str(two) == '[130]')
 		return true
 	).call()
-	assert(defaults_passed == true)
+	Utils.check(defaults_passed == true)
 
 
 	var members := Members.new()
 	var members_passed := members.check_passing()
-	assert(members_passed == true)
+	Utils.check(members_passed == true)
 
 
 	var resized_basic: Array = []
 	resized_basic.resize(1)
-	assert(typeof(resized_basic[0]) == TYPE_NIL)
-	assert(resized_basic[0] == null)
+	Utils.check(typeof(resized_basic[0]) == TYPE_NIL)
+	Utils.check(resized_basic[0] == null)
 
 	var resized_ints: Array[int] = []
 	resized_ints.resize(1)
-	assert(typeof(resized_ints[0]) == TYPE_INT)
-	assert(resized_ints[0] == 0)
+	Utils.check(typeof(resized_ints[0]) == TYPE_INT)
+	Utils.check(resized_ints[0] == 0)
 
 	var resized_arrays: Array[Array] = []
 	resized_arrays.resize(1)
-	assert(typeof(resized_arrays[0]) == TYPE_ARRAY)
+	Utils.check(typeof(resized_arrays[0]) == TYPE_ARRAY)
 	resized_arrays[0].resize(1)
 	resized_arrays[0][0] = 523
-	assert(str(resized_arrays) == '[[523]]')
+	Utils.check(str(resized_arrays) == '[[523]]')
 
 	var resized_objects: Array[Object] = []
 	resized_objects.resize(1)
-	assert(typeof(resized_objects[0]) == TYPE_NIL)
-	assert(resized_objects[0] == null)
+	Utils.check(typeof(resized_objects[0]) == TYPE_NIL)
+	Utils.check(resized_objects[0] == null)
 
 
 	var typed_enums: Array[E] = []
 	typed_enums.resize(1)
-	assert(str(typed_enums) == '[0]')
+	Utils.check(str(typed_enums) == '[0]')
 	typed_enums[0] = E.E0
-	assert(str(typed_enums) == '[391]')
-	assert(typed_enums.get_typed_builtin() == TYPE_INT)
+	Utils.check(str(typed_enums) == '[391]')
+	Utils.check(typed_enums.get_typed_builtin() == TYPE_INT)
 
 	const const_enums: Array[E] = []
-	assert(const_enums.get_typed_builtin() == TYPE_INT)
-	assert(const_enums.get_typed_class_name() == &'')
+	Utils.check(const_enums.get_typed_builtin() == TYPE_INT)
+	Utils.check(const_enums.get_typed_class_name() == &'')
 
 
 	var a := A.new()
 	var typed_natives: Array[RefCounted] = [a]
 	var typed_scripts = Array(typed_natives, TYPE_OBJECT, "RefCounted", A)
-	assert(typed_scripts[0] == a)
+	Utils.check(typed_scripts[0] == a)
 
 
 	print('ok')