Adding log.gd

addons/gdUnit4/src/matchers/AnyArgumentMatcher.gd

@@ -0,0 +1,11 @@
+class_name AnyArgumentMatcher
+extends GdUnitArgumentMatcher
+
+
+@warning_ignore("unused_parameter")
+func is_match(value) -> bool:
+	return true
+
+
+func _to_string() -> String:
+	return "any()"

addons/gdUnit4/src/matchers/AnyBuildInTypeArgumentMatcher.gd

@@ -0,0 +1,50 @@
+class_name AnyBuildInTypeArgumentMatcher
+extends GdUnitArgumentMatcher
+
+var _type : PackedInt32Array = []
+
+
+func _init(type :PackedInt32Array):
+	_type = type
+
+
+func is_match(value) -> bool:
+	return _type.has(typeof(value))
+
+
+func _to_string() -> String:
+	match _type[0]:
+		TYPE_BOOL: return "any_bool()"
+		TYPE_STRING, TYPE_STRING_NAME: return "any_string()"
+		TYPE_INT: return "any_int()"
+		TYPE_FLOAT: return "any_float()"
+		TYPE_COLOR: return "any_color()"
+		TYPE_VECTOR2: return "any_vector2()" if _type.size() == 1 else "any_vector()"
+		TYPE_VECTOR2I: return "any_vector2i()"
+		TYPE_VECTOR3: return "any_vector3()"
+		TYPE_VECTOR3I: return "any_vector3i()"
+		TYPE_VECTOR4: return "any_vector4()"
+		TYPE_VECTOR4I: return "any_vector4i()"
+		TYPE_RECT2: return "any_rect2()"
+		TYPE_RECT2I: return "any_rect2i()"
+		TYPE_PLANE: return "any_plane()"
+		TYPE_QUATERNION: return "any_quat()"
+		TYPE_AABB: return "any_aabb()"
+		TYPE_BASIS: return "any_basis()"
+		TYPE_TRANSFORM2D: return "any_transform_2d()"
+		TYPE_TRANSFORM3D: return "any_transform_3d()"
+		TYPE_NODE_PATH: return "any_node_path()"
+		TYPE_RID: return "any_rid()"
+		TYPE_OBJECT: return "any_object()"
+		TYPE_DICTIONARY: return "any_dictionary()"
+		TYPE_ARRAY: return "any_array()"
+		TYPE_PACKED_BYTE_ARRAY: return "any_packed_byte_array()"
+		TYPE_PACKED_INT32_ARRAY: return "any_packed_int32_array()"
+		TYPE_PACKED_INT64_ARRAY: return "any_packed_int64_array()"
+		TYPE_PACKED_FLOAT32_ARRAY: return "any_packed_float32_array()"
+		TYPE_PACKED_FLOAT64_ARRAY: return "any_packed_float64_array()"
+		TYPE_PACKED_STRING_ARRAY: return "any_packed_string_array()"
+		TYPE_PACKED_VECTOR2_ARRAY: return "any_packed_vector2_array()"
+		TYPE_PACKED_VECTOR3_ARRAY: return "any_packed_vector3_array()"
+		TYPE_PACKED_COLOR_ARRAY: return "any_packed_color_array()"
+		_: return "any()"

addons/gdUnit4/src/matchers/AnyClazzArgumentMatcher.gd

@@ -0,0 +1,30 @@
+class_name AnyClazzArgumentMatcher
+extends GdUnitArgumentMatcher
+
+var _clazz :Object
+
+
+func _init(clazz :Object) -> void:
+	_clazz = clazz
+
+
+func is_match(value :Variant) -> bool:
+	if typeof(value) != TYPE_OBJECT:
+		return false
+	if is_instance_valid(value) and GdObjects.is_script(_clazz):
+		return value.get_script() == _clazz
+	return is_instance_of(value, _clazz)
+
+
+func _to_string() -> String:
+	if (_clazz as Object).is_class("GDScriptNativeClass"):
+		var instance :Object = _clazz.new()
+		var clazz_name := instance.get_class()
+		if not instance is RefCounted:
+			instance.free()
+		return "any_class(<"+clazz_name+">)";
+	if _clazz is GDScript:
+		var result := GdObjects.extract_class_name(_clazz)
+		if result.is_success():
+			return "any_class(<"+ result.value() + ">)"
+	return "any_class()"

addons/gdUnit4/src/matchers/ChainedArgumentMatcher.gd

@@ -0,0 +1,22 @@
+class_name ChainedArgumentMatcher
+extends GdUnitArgumentMatcher
+
+var _matchers :Array
+
+
+func _init(matchers :Array):
+	_matchers = matchers
+
+
+func is_match(arguments :Variant) -> bool:
+	var arg_array := arguments as Array
+	if arg_array.size() != _matchers.size():
+		return false
+
+	for index in arg_array.size():
+		var arg :Variant = arg_array[index]
+		var matcher = _matchers[index] as GdUnitArgumentMatcher
+
+		if not matcher.is_match(arg):
+			return false
+	return true

addons/gdUnit4/src/matchers/EqualsArgumentMatcher.gd

@@ -0,0 +1,22 @@
+class_name EqualsArgumentMatcher
+extends GdUnitArgumentMatcher
+
+var _current
+var _auto_deep_check_mode
+
+
+func _init(current, auto_deep_check_mode := false):
+	_current = current
+	_auto_deep_check_mode = auto_deep_check_mode
+
+
+func is_match(value) -> bool:
+	var case_sensitive_check := true
+	return GdObjects.equals(_current, value, case_sensitive_check, compare_mode(value))
+
+
+func compare_mode(value) -> GdObjects.COMPARE_MODE:
+	if _auto_deep_check_mode and is_instance_valid(value):
+		# we do deep check on all InputEvent's
+		return GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST if value is InputEvent else GdObjects.COMPARE_MODE.OBJECT_REFERENCE
+	return GdObjects.COMPARE_MODE.OBJECT_REFERENCE

addons/gdUnit4/src/matchers/GdUnitArgumentMatcher.gd

@@ -0,0 +1,8 @@
+## The base class of all argument matchers
+class_name GdUnitArgumentMatcher
+extends RefCounted
+
+
+@warning_ignore("unused_parameter")
+func is_match(value :Variant) -> bool:
+	return true

addons/gdUnit4/src/matchers/GdUnitArgumentMatchers.gd

@@ -0,0 +1,32 @@
+class_name GdUnitArgumentMatchers
+extends RefCounted
+
+const TYPE_ANY = TYPE_MAX + 100
+
+
+static func to_matcher(arguments :Array[Variant], auto_deep_check_mode := false) -> ChainedArgumentMatcher:
+	var matchers :Array[Variant] = []
+	for arg in arguments:
+		# argument is already a matcher
+		if arg is GdUnitArgumentMatcher:
+			matchers.append(arg)
+		else:
+			# pass argument into equals matcher
+			matchers.append(EqualsArgumentMatcher.new(arg, auto_deep_check_mode))
+	return ChainedArgumentMatcher.new(matchers)
+
+
+static func any() -> GdUnitArgumentMatcher:
+	return  AnyArgumentMatcher.new()
+
+
+static func by_type(type :int) -> GdUnitArgumentMatcher:
+	return AnyBuildInTypeArgumentMatcher.new([type])
+
+
+static func by_types(types :PackedInt32Array) -> GdUnitArgumentMatcher:
+	return AnyBuildInTypeArgumentMatcher.new(types)
+
+
+static func any_class(clazz :Object) -> GdUnitArgumentMatcher:
+	return AnyClazzArgumentMatcher.new(clazz)