feat: updated engine version to 4.4-rc1
This commit is contained in:
Sara
parent
ee00efde1f
commit
21ba8e33af
5459 changed files with 1128836 additions and 198305 deletions
|
|
@ -1,8 +1,5 @@
|
|||
GDTEST_OK
|
||||
>> WARNING
|
||||
>> Line: 20
|
||||
>> UNSAFE_VOID_RETURN
|
||||
>> The method "return_side_effect()" returns "void" but it's trying to return a call to "side_effect()" that can't be ensured to also be "void".
|
||||
~~ WARNING at line 20: (UNSAFE_VOID_RETURN) The method "return_side_effect()" returns "void" but it's trying to return a call to "side_effect()" that can't be ensured to also be "void".
|
||||
hello
|
||||
effect
|
||||
effect
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
GDTEST_OK
|
||||
>> WARNING
|
||||
>> Line: 6
|
||||
>> UNSAFE_METHOD_ACCESS
|
||||
>> The method "free()" is not present on the inferred type "Variant" (but may be present on a subtype).
|
||||
~~ WARNING at line 6: (UNSAFE_METHOD_ACCESS) The method "free()" is not present on the inferred type "Variant" (but may be present on a subtype).
|
||||
Ok
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
GDTEST_OK
|
||||
0
|
||||
0.0
|
||||
|
|
|
|||
|
|
@ -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.0')
|
||||
Utils.check(typeof(const_float_plus) == TYPE_FLOAT)
|
||||
Utils.check(str(const_float_plus) == '34.0')
|
||||
Utils.check(typeof(const_float_cast) == TYPE_FLOAT)
|
||||
Utils.check(str(const_float_cast) == '76.0')
|
||||
|
||||
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.0]')
|
||||
Utils.check(typeof(const_packed_ints[0]) == TYPE_FLOAT)
|
||||
Utils.check(str(const_packed_ints[0]) == '52.0')
|
||||
|
||||
print('ok')
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
GDTEST_OK
|
||||
4
|
||||
4.0
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -0,0 +1,28 @@
|
|||
extends Node
|
||||
|
||||
@export var test_type_1 := TYPE_BOOL
|
||||
@export var test_type_2 := Variant.Type.TYPE_BOOL
|
||||
@export var test_type_3: Variant.Type
|
||||
|
||||
@export var test_side_1 := SIDE_RIGHT
|
||||
@export var test_side_2 := Side.SIDE_RIGHT
|
||||
@export var test_side_3: Side
|
||||
|
||||
@export var test_axis_1 := Vector3.AXIS_Y
|
||||
@export var test_axis_2 := Vector3.Axis.AXIS_Y
|
||||
@export var test_axis_3: Vector3.Axis
|
||||
|
||||
@export var test_mode_1 := Node.PROCESS_MODE_ALWAYS
|
||||
@export var test_mode_2 := Node.ProcessMode.PROCESS_MODE_ALWAYS
|
||||
@export var test_mode_3: Node.ProcessMode
|
||||
|
||||
func test():
|
||||
for property in get_property_list():
|
||||
if str(property.name).begins_with("test_"):
|
||||
Utils.print_property_extended_info(property, self)
|
||||
|
||||
func test_no_exec():
|
||||
# GH-99309
|
||||
var sprite: Sprite3D = $Sprite3D
|
||||
sprite.axis = Vector3.AXIS_Y # No warning.
|
||||
sprite.set_axis(Vector3.AXIS_Y) # No warning.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
GDTEST_OK
|
||||
var test_type_1: Variant.Type = 1
|
||||
hint=ENUM hint_string="Type Nil:0,Type Bool:1,Type Int:2,Type Float:3,Type String:4,Type Vector 2:5,Type Vector 2i:6,Type Rect 2:7,Type Rect 2i:8,Type Vector 3:9,Type Vector 3i:10,Type Transform 2d:11,Type Vector 4:12,Type Vector 4i:13,Type Plane:14,Type Quaternion:15,Type Aabb:16,Type Basis:17,Type Transform 3d:18,Type Projection:19,Type Color:20,Type String Name:21,Type Node Path:22,Type Rid:23,Type Object:24,Type Callable:25,Type Signal:26,Type Dictionary:27,Type Array:28,Type Packed Byte Array:29,Type Packed Int 32 Array:30,Type Packed Int 64 Array:31,Type Packed Float 32 Array:32,Type Packed Float 64 Array:33,Type Packed String Array:34,Type Packed Vector 2 Array:35,Type Packed Vector 3 Array:36,Type Packed Color Array:37,Type Packed Vector 4 Array:38,Type Max:39" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Variant.Type"
|
||||
var test_type_2: Variant.Type = 1
|
||||
hint=ENUM hint_string="Type Nil:0,Type Bool:1,Type Int:2,Type Float:3,Type String:4,Type Vector 2:5,Type Vector 2i:6,Type Rect 2:7,Type Rect 2i:8,Type Vector 3:9,Type Vector 3i:10,Type Transform 2d:11,Type Vector 4:12,Type Vector 4i:13,Type Plane:14,Type Quaternion:15,Type Aabb:16,Type Basis:17,Type Transform 3d:18,Type Projection:19,Type Color:20,Type String Name:21,Type Node Path:22,Type Rid:23,Type Object:24,Type Callable:25,Type Signal:26,Type Dictionary:27,Type Array:28,Type Packed Byte Array:29,Type Packed Int 32 Array:30,Type Packed Int 64 Array:31,Type Packed Float 32 Array:32,Type Packed Float 64 Array:33,Type Packed String Array:34,Type Packed Vector 2 Array:35,Type Packed Vector 3 Array:36,Type Packed Color Array:37,Type Packed Vector 4 Array:38,Type Max:39" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Variant.Type"
|
||||
var test_type_3: Variant.Type = 0
|
||||
hint=ENUM hint_string="Type Nil:0,Type Bool:1,Type Int:2,Type Float:3,Type String:4,Type Vector 2:5,Type Vector 2i:6,Type Rect 2:7,Type Rect 2i:8,Type Vector 3:9,Type Vector 3i:10,Type Transform 2d:11,Type Vector 4:12,Type Vector 4i:13,Type Plane:14,Type Quaternion:15,Type Aabb:16,Type Basis:17,Type Transform 3d:18,Type Projection:19,Type Color:20,Type String Name:21,Type Node Path:22,Type Rid:23,Type Object:24,Type Callable:25,Type Signal:26,Type Dictionary:27,Type Array:28,Type Packed Byte Array:29,Type Packed Int 32 Array:30,Type Packed Int 64 Array:31,Type Packed Float 32 Array:32,Type Packed Float 64 Array:33,Type Packed String Array:34,Type Packed Vector 2 Array:35,Type Packed Vector 3 Array:36,Type Packed Color Array:37,Type Packed Vector 4 Array:38,Type Max:39" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Variant.Type"
|
||||
var test_side_1: Side = 2
|
||||
hint=ENUM hint_string="Side Left:0,Side Top:1,Side Right:2,Side Bottom:3" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Side"
|
||||
var test_side_2: Side = 2
|
||||
hint=ENUM hint_string="Side Left:0,Side Top:1,Side Right:2,Side Bottom:3" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Side"
|
||||
var test_side_3: Side = 0
|
||||
hint=ENUM hint_string="Side Left:0,Side Top:1,Side Right:2,Side Bottom:3" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Side"
|
||||
var test_axis_1: Vector3.Axis = 1
|
||||
hint=ENUM hint_string="Axis X:0,Axis Y:1,Axis Z:2" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Vector3.Axis"
|
||||
var test_axis_2: Vector3.Axis = 1
|
||||
hint=ENUM hint_string="Axis X:0,Axis Y:1,Axis Z:2" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Vector3.Axis"
|
||||
var test_axis_3: Vector3.Axis = 0
|
||||
hint=ENUM hint_string="Axis X:0,Axis Y:1,Axis Z:2" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Vector3.Axis"
|
||||
var test_mode_1: Node.ProcessMode = 3
|
||||
hint=ENUM hint_string="Process Mode Inherit:0,Process Mode Pausable:1,Process Mode When Paused:2,Process Mode Always:3,Process Mode Disabled:4" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Node.ProcessMode"
|
||||
var test_mode_2: Node.ProcessMode = 3
|
||||
hint=ENUM hint_string="Process Mode Inherit:0,Process Mode Pausable:1,Process Mode When Paused:2,Process Mode Always:3,Process Mode Disabled:4" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Node.ProcessMode"
|
||||
var test_mode_3: Node.ProcessMode = 0
|
||||
hint=ENUM hint_string="Process Mode Inherit:0,Process Mode Pausable:1,Process Mode When Paused:2,Process Mode Always:3,Process Mode Disabled:4" usage=DEFAULT|SCRIPT_VARIABLE|CLASS_IS_ENUM class_name=&"Node.ProcessMode"
|
||||
|
|
@ -13,7 +13,7 @@ func param_inferred(param := variant()) -> void: print(param)
|
|||
func return_untyped(): return variant()
|
||||
func return_typed() -> Variant: return variant()
|
||||
|
||||
@warning_ignore("unused_variable", "inference_on_variant")
|
||||
@warning_ignore_start("unused_variable", "inference_on_variant")
|
||||
func test() -> void:
|
||||
var weak = variant()
|
||||
var typed: Variant = variant()
|
||||
|
|
@ -32,4 +32,4 @@ func test() -> void:
|
|||
if typed != null: pass
|
||||
if typed is Node: pass
|
||||
|
||||
print('ok')
|
||||
print("ok")
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
|
|
|
|||
|
|
@ -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')
|
||||
print("ok")
|
||||
|
|
|
|||
|
|
@ -10,206 +10,203 @@ 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")
|
||||
@warning_ignore_start('unsafe_method_access', '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.0, 430.0, 263.0, 518.0]')
|
||||
Utils.check(str(untyped_basic) == '[705.0, 430.0, 263.0, 518.0]')
|
||||
Utils.check(str(inferred_basic) == '[705.0, 430.0, 263.0, 518.0]')
|
||||
Utils.check(str(typed_basic) == '[705.0, 430.0, 263.0, 518.0]')
|
||||
|
||||
|
||||
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.0, 170.0, 954.0, 693.0]')
|
||||
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.0]')
|
||||
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.0]')
|
||||
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.0]')
|
||||
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.0]')
|
||||
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.0, 498.0]')
|
||||
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.0]')
|
||||
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.0]')
|
||||
Utils.check(str(untyped_basic) == '[999.0]')
|
||||
Utils.check(str(destination_floats) == '[999.0]')
|
||||
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.0]')
|
||||
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)
|
||||
var typed_scripts = Array(typed_natives, TYPE_OBJECT, 'RefCounted', A)
|
||||
Utils.check(typed_scripts[0] == a)
|
||||
|
||||
|
||||
print('ok')
|
||||
|
|
|
|||
|
|
@ -0,0 +1,20 @@
|
|||
func print_untyped(dictionary = { 0: 1 }) -> void:
|
||||
print(dictionary)
|
||||
print(dictionary.get_typed_key_builtin())
|
||||
print(dictionary.get_typed_value_builtin())
|
||||
|
||||
func print_inferred(dictionary := { 2: 3 }) -> void:
|
||||
print(dictionary)
|
||||
print(dictionary.get_typed_key_builtin())
|
||||
print(dictionary.get_typed_value_builtin())
|
||||
|
||||
func print_typed(dictionary: Dictionary[int, int] = { 4: 5 }) -> void:
|
||||
print(dictionary)
|
||||
print(dictionary.get_typed_key_builtin())
|
||||
print(dictionary.get_typed_value_builtin())
|
||||
|
||||
func test():
|
||||
print_untyped()
|
||||
print_inferred()
|
||||
print_typed()
|
||||
print('ok')
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
GDTEST_OK
|
||||
{ 0: 1 }
|
||||
0
|
||||
0
|
||||
{ 2: 3 }
|
||||
0
|
||||
0
|
||||
{ 4: 5 }
|
||||
2
|
||||
2
|
||||
ok
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
func test():
|
||||
var dict := { 0: 0 }
|
||||
dict[0] = 1
|
||||
print(dict[0])
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
GDTEST_OK
|
||||
1
|
||||
|
|
@ -0,0 +1,212 @@
|
|||
class A: pass
|
||||
class B extends A: pass
|
||||
|
||||
enum E { E0 = 391, E1 = 193 }
|
||||
|
||||
func floats_identity(floats: Dictionary[float, float]): return floats
|
||||
|
||||
class Members:
|
||||
var one: Dictionary[int, int] = { 104: 401 }
|
||||
var two: Dictionary[int, int] = one
|
||||
|
||||
func check_passing() -> bool:
|
||||
Utils.check(str(one) == '{ 104: 401 }')
|
||||
Utils.check(str(two) == '{ 104: 401 }')
|
||||
two[582] = 285
|
||||
Utils.check(str(one) == '{ 104: 401, 582: 285 }')
|
||||
Utils.check(str(two) == '{ 104: 401, 582: 285 }')
|
||||
two = { 486: 684 }
|
||||
Utils.check(str(one) == '{ 104: 401, 582: 285 }')
|
||||
Utils.check(str(two) == '{ 486: 684 }')
|
||||
return true
|
||||
|
||||
|
||||
@warning_ignore_start("unsafe_method_access", "return_value_discarded")
|
||||
func test():
|
||||
var untyped_basic = { 459: 954 }
|
||||
Utils.check(str(untyped_basic) == '{ 459: 954 }')
|
||||
Utils.check(untyped_basic.get_typed_key_builtin() == TYPE_NIL)
|
||||
Utils.check(untyped_basic.get_typed_value_builtin() == TYPE_NIL)
|
||||
|
||||
var inferred_basic := { 366: 663 }
|
||||
Utils.check(str(inferred_basic) == '{ 366: 663 }')
|
||||
Utils.check(inferred_basic.get_typed_key_builtin() == TYPE_NIL)
|
||||
Utils.check(inferred_basic.get_typed_value_builtin() == TYPE_NIL)
|
||||
|
||||
var typed_basic: Dictionary = { 521: 125 }
|
||||
Utils.check(str(typed_basic) == '{ 521: 125 }')
|
||||
Utils.check(typed_basic.get_typed_key_builtin() == TYPE_NIL)
|
||||
Utils.check(typed_basic.get_typed_value_builtin() == TYPE_NIL)
|
||||
|
||||
|
||||
var empty_floats: Dictionary[float, float] = {}
|
||||
Utils.check(str(empty_floats) == '{ }')
|
||||
Utils.check(empty_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(empty_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
untyped_basic = empty_floats
|
||||
Utils.check(untyped_basic.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(untyped_basic.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
inferred_basic = empty_floats
|
||||
Utils.check(inferred_basic.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(inferred_basic.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
typed_basic = empty_floats
|
||||
Utils.check(typed_basic.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(typed_basic.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
empty_floats[705.0] = 507.0
|
||||
untyped_basic[430.0] = 34.0
|
||||
inferred_basic[263.0] = 362.0
|
||||
typed_basic[518.0] = 815.0
|
||||
Utils.check(str(empty_floats) == '{ 705.0: 507.0, 430.0: 34.0, 263.0: 362.0, 518.0: 815.0 }')
|
||||
Utils.check(str(untyped_basic) == '{ 705.0: 507.0, 430.0: 34.0, 263.0: 362.0, 518.0: 815.0 }')
|
||||
Utils.check(str(inferred_basic) == '{ 705.0: 507.0, 430.0: 34.0, 263.0: 362.0, 518.0: 815.0 }')
|
||||
Utils.check(str(typed_basic) == '{ 705.0: 507.0, 430.0: 34.0, 263.0: 362.0, 518.0: 815.0 }')
|
||||
|
||||
|
||||
const constant_float := 950.0
|
||||
const constant_int := 170
|
||||
var typed_float := 954.0
|
||||
var filled_floats: Dictionary[float, float] = { constant_float: constant_int, typed_float: empty_floats[430.0] + empty_floats[263.0] }
|
||||
Utils.check(str(filled_floats) == '{ 950.0: 170.0, 954.0: 396.0 }')
|
||||
Utils.check(filled_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(filled_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
var casted_floats := { empty_floats[263.0] * 2: empty_floats[263.0] / 2 } as Dictionary[float, float]
|
||||
Utils.check(str(casted_floats) == '{ 724.0: 181.0 }')
|
||||
Utils.check(casted_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(casted_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
var returned_floats = (func () -> Dictionary[float, float]: return { 554: 455 }).call()
|
||||
Utils.check(str(returned_floats) == '{ 554.0: 455.0 }')
|
||||
Utils.check(returned_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(returned_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
var passed_floats = floats_identity({ 663.0 if randf() > 0.5 else 663.0: 366.0 if randf() <= 0.5 else 366.0 })
|
||||
Utils.check(str(passed_floats) == '{ 663.0: 366.0 }')
|
||||
Utils.check(passed_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(passed_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
var default_floats = (func (floats: Dictionary[float, float] = { 364.0: 463.0 }): return floats).call()
|
||||
Utils.check(str(default_floats) == '{ 364.0: 463.0 }')
|
||||
Utils.check(default_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(default_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
var typed_int := 556
|
||||
var converted_floats: Dictionary[float, float] = { typed_int: typed_int }
|
||||
converted_floats[498.0] = 894
|
||||
Utils.check(str(converted_floats) == '{ 556.0: 556.0, 498.0: 894.0 }')
|
||||
Utils.check(converted_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(converted_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
|
||||
const constant_basic = { 228: 822 }
|
||||
Utils.check(str(constant_basic) == '{ 228: 822 }')
|
||||
Utils.check(constant_basic.get_typed_key_builtin() == TYPE_NIL)
|
||||
Utils.check(constant_basic.get_typed_value_builtin() == TYPE_NIL)
|
||||
|
||||
const constant_floats: Dictionary[float, float] = { constant_float - constant_basic[228] - constant_int: constant_float + constant_basic[228] + constant_int }
|
||||
Utils.check(str(constant_floats) == '{ -42.0: 1942.0 }')
|
||||
Utils.check(constant_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(constant_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
|
||||
var source_floats: Dictionary[float, float] = { 999.74: 47.999 }
|
||||
untyped_basic = source_floats
|
||||
var destination_floats: Dictionary[float, float] = untyped_basic
|
||||
destination_floats[999.74] -= 0.999
|
||||
Utils.check(str(source_floats) == '{ 999.74: 47.0 }')
|
||||
Utils.check(str(untyped_basic) == '{ 999.74: 47.0 }')
|
||||
Utils.check(str(destination_floats) == '{ 999.74: 47.0 }')
|
||||
Utils.check(destination_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(destination_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
|
||||
var duplicated_floats := empty_floats.duplicate()
|
||||
duplicated_floats.erase(705.0)
|
||||
duplicated_floats.erase(430.0)
|
||||
duplicated_floats.erase(518.0)
|
||||
duplicated_floats[263.0] *= 3
|
||||
Utils.check(str(duplicated_floats) == '{ 263.0: 1086.0 }')
|
||||
Utils.check(duplicated_floats.get_typed_key_builtin() == TYPE_FLOAT)
|
||||
Utils.check(duplicated_floats.get_typed_value_builtin() == TYPE_FLOAT)
|
||||
|
||||
|
||||
var b_objects: Dictionary[int, B] = { 0: B.new(), 1: B.new() as A, 2: null }
|
||||
Utils.check(b_objects.size() == 3)
|
||||
Utils.check(b_objects.get_typed_value_builtin() == TYPE_OBJECT)
|
||||
Utils.check(b_objects.get_typed_value_script() == B)
|
||||
|
||||
var a_objects: Dictionary[int, A] = { 0: A.new(), 1: B.new(), 2: null, 3: b_objects[0] }
|
||||
Utils.check(a_objects.size() == 4)
|
||||
Utils.check(a_objects.get_typed_value_builtin() == TYPE_OBJECT)
|
||||
Utils.check(a_objects.get_typed_value_script() == A)
|
||||
|
||||
var a_passed = (func check_a_passing(p_objects: Dictionary[int, A]): return p_objects.size()).call(a_objects)
|
||||
Utils.check(a_passed == 4)
|
||||
|
||||
var b_passed = (func check_b_passing(basic: Dictionary): return basic[0] != null).call(b_objects)
|
||||
Utils.check(b_passed == true)
|
||||
|
||||
|
||||
var empty_strings: Dictionary[String, String] = {}
|
||||
var empty_bools: Dictionary[bool, bool] = {}
|
||||
var empty_basic_one := {}
|
||||
var empty_basic_two := {}
|
||||
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: Dictionary[int, int] = { 527: 725 }
|
||||
var assign_target: Dictionary[int, int] = {}
|
||||
assign_target.assign(assign_source)
|
||||
Utils.check(str(assign_source) == '{ 527: 725 }')
|
||||
Utils.check(str(assign_target) == '{ 527: 725 }')
|
||||
assign_source[657] = 756
|
||||
Utils.check(str(assign_source) == '{ 527: 725, 657: 756 }')
|
||||
Utils.check(str(assign_target) == '{ 527: 725 }')
|
||||
|
||||
|
||||
var defaults_passed = (func check_defaults_passing(one: Dictionary[int, int] = {}, two := one):
|
||||
one[887] = 788
|
||||
two[198] = 891
|
||||
Utils.check(str(one) == '{ 887: 788, 198: 891 }')
|
||||
Utils.check(str(two) == '{ 887: 788, 198: 891 }')
|
||||
two = {130: 31}
|
||||
Utils.check(str(one) == '{ 887: 788, 198: 891 }')
|
||||
Utils.check(str(two) == '{ 130: 31 }')
|
||||
return true
|
||||
).call()
|
||||
Utils.check(defaults_passed == true)
|
||||
|
||||
|
||||
var members := Members.new()
|
||||
var members_passed := members.check_passing()
|
||||
Utils.check(members_passed == true)
|
||||
|
||||
|
||||
var typed_enums: Dictionary[E, E] = {}
|
||||
typed_enums[E.E0] = E.E1
|
||||
Utils.check(str(typed_enums) == '{ 391: 193 }')
|
||||
Utils.check(typed_enums.get_typed_key_builtin() == TYPE_INT)
|
||||
Utils.check(typed_enums.get_typed_value_builtin() == TYPE_INT)
|
||||
|
||||
const const_enums: Dictionary[E, E] = {}
|
||||
Utils.check(const_enums.get_typed_key_builtin() == TYPE_INT)
|
||||
Utils.check(const_enums.get_typed_key_class_name() == &'')
|
||||
Utils.check(const_enums.get_typed_value_builtin() == TYPE_INT)
|
||||
Utils.check(const_enums.get_typed_value_class_name() == &'')
|
||||
|
||||
|
||||
var a := A.new()
|
||||
var b := B.new()
|
||||
var typed_natives: Dictionary[RefCounted, RefCounted] = { a: b }
|
||||
var typed_scripts = Dictionary(typed_natives, TYPE_OBJECT, "RefCounted", A, TYPE_OBJECT, "RefCounted", B)
|
||||
Utils.check(typed_scripts[a] == b)
|
||||
|
||||
|
||||
print('ok')
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
GDTEST_OK
|
||||
ok
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
class Inner:
|
||||
var prop = "Inner"
|
||||
|
||||
var dict: Dictionary[int, Inner] = { 0: Inner.new() }
|
||||
|
||||
|
||||
func test():
|
||||
var element: Inner = dict[0]
|
||||
print(element.prop)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
GDTEST_OK
|
||||
Inner
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
signal ok()
|
||||
|
||||
@warning_ignore("return_value_discarded")
|
||||
@warning_ignore_start("return_value_discarded")
|
||||
func test():
|
||||
ok.connect(func(): print('ok'))
|
||||
emit_signal(&'ok')
|
||||
ok.connect(func(): print("ok"))
|
||||
emit_signal(&"ok")
|
||||
|
|
|
|||
|
|
@ -1,29 +1,9 @@
|
|||
GDTEST_OK
|
||||
>> WARNING
|
||||
>> Line: 3
|
||||
>> CONFUSABLE_IDENTIFIER
|
||||
>> The identifier "my_vАr" has misleading characters and might be confused with something else.
|
||||
>> WARNING
|
||||
>> Line: 8
|
||||
>> NARROWING_CONVERSION
|
||||
>> Narrowing conversion (float is converted to int and loses precision).
|
||||
>> WARNING
|
||||
>> Line: 19
|
||||
>> NARROWING_CONVERSION
|
||||
>> Narrowing conversion (float is converted to int and loses precision).
|
||||
>> WARNING
|
||||
>> Line: 24
|
||||
>> NARROWING_CONVERSION
|
||||
>> Narrowing conversion (float is converted to int and loses precision).
|
||||
>> WARNING
|
||||
>> Line: 27
|
||||
>> CONFUSABLE_IDENTIFIER
|
||||
>> The identifier "_my_vАr" has misleading characters and might be confused with something else.
|
||||
>> WARNING
|
||||
>> Line: 31
|
||||
>> NARROWING_CONVERSION
|
||||
>> Narrowing conversion (float is converted to int and loses precision).
|
||||
>> WARNING
|
||||
>> Line: 35
|
||||
>> NARROWING_CONVERSION
|
||||
>> Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 3: (CONFUSABLE_IDENTIFIER) The identifier "my_vАr" has misleading characters and might be confused with something else.
|
||||
~~ WARNING at line 8: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 14: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 19: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 24: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 27: (CONFUSABLE_IDENTIFIER) The identifier "_my_vАr" has misleading characters and might be confused with something else.
|
||||
~~ WARNING at line 31: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
~~ WARNING at line 35: (NARROWING_CONVERSION) Narrowing conversion (float is converted to int and loses precision).
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue