GdUnit initial commit Beta 0.9.0

Author: MikeSchulze

.gitignore

@@ -0,0 +1,20 @@
+# Project-specific ignores
+.history
+
+# Godot-specific ignores
+.import/
+*.png.import
+*.jpg.import
+*.svg.import
+
+# Mono-specific ignores
+.mono/
+data_*/
+mono_crash.*.json
+
+# System/tool-specific ignores
+.directory
+*~
+
+# temporary generated files
+addons/gdUnit3/GdUnitRunner.cfg

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Mike Schulze
+
+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.

README.md

@@ -0,0 +1,5 @@
+# GdUnit3 - Godot Unit Test Framework ![Godot v3.2](https://img.shields.io/badge/Godot-v3.2-%23478cbf?logo=godot-engine&logoColor=white)
+
+
+WIKI
+https://github.com/MikeSchulze/gdUnitWiki/wiki

addons/GdCommons/DateTime/src/LocalTime.gd

@@ -0,0 +1,91 @@
+# This class provides Date/Time functionallity to Godot
+class_name LocalTime
+extends Resource
+
+const SCRIPT_PATH = "res://addons/GdCommons/DateTime/src/LocalTime.gd"
+
+const SECONDS_PER_MINUTE:int = 60
+const MINUTES_PER_HOUR:int = 60
+const HOURS_PER_DAY:int = 24
+const MILLIS_PER_SECOND:int = 1000
+const MILLIS_PER_MINUTE:int = MILLIS_PER_SECOND * SECONDS_PER_MINUTE
+const MILLIS_PER_HOUR:int   = MILLIS_PER_MINUTE * MINUTES_PER_HOUR
+
+var _time:int
+var _hour:int
+var _minute:int
+var _second:int
+var _millisecond:int
+
+
+static func _create(time_ms:int):
+	var _instance = load(SCRIPT_PATH)
+	return _instance.new(time_ms)
+
+static func now() -> LocalTime:
+	var time := OS.get_system_time_msecs()
+	return _create(time)
+	#return local_time(time.get("hour"), time.get("minute"), time.get("second"), 0)
+
+static func of_unix_time(time_ms:int) -> LocalTime:
+	return _create(time_ms)
+	
+static func local_time(hours:int, minutes:int, seconds:int, millis:int) -> LocalTime:
+	return _create(MILLIS_PER_HOUR * hours\
+	 + MILLIS_PER_MINUTE * minutes\
+	 + MILLIS_PER_SECOND * seconds\
+	 + millis)
+
+func elapsed_since() -> String:
+	return elapsed(OS.get_system_time_msecs() - _time)
+
+func elapsed_since_ms() -> int:
+	return OS.get_system_time_msecs() - _time
+	
+func plus( time_unit, value:int) -> LocalTime:
+	var addValue:int = 0
+	match time_unit:
+		TimeUnit.MILLIS:
+			addValue = value
+		TimeUnit.SECOND:
+			addValue = value * MILLIS_PER_SECOND
+		TimeUnit.MINUTE:
+			addValue = value * MILLIS_PER_MINUTE
+		TimeUnit.HOUR:
+			addValue = value * MILLIS_PER_HOUR
+	
+	_init(_time + addValue)
+	return self
+
+static func elapsed(time_ms:int) -> String:
+	var local_time = _create(time_ms)
+	if local_time._hour > 0:
+		return "%dh %dmin %ds %dms" % [local_time._hour, local_time._minute, local_time._second, local_time._millisecond]
+	if local_time._minute > 0:
+		return "%dmin %ds %dms" % [local_time._minute, local_time._second, local_time._millisecond]
+	if local_time._second > 0:
+		return "%ds %dms" % [local_time._second, local_time._millisecond]
+	return "%dms" % local_time._millisecond
+
+# create from epoch timestamp in ms
+func _init(time:int):
+	_time = time
+	_hour  =  (time / MILLIS_PER_HOUR) % 24
+	_minute =  (time / MILLIS_PER_MINUTE) % 60
+	_second =  (time / MILLIS_PER_SECOND) % 60
+	_millisecond = time % 1000
+
+func hour() -> int:
+	return _hour
+
+func minute() -> int:
+	return _minute
+
+func second() -> int:
+	return _second
+
+func millis() -> int:
+	return _millisecond
+
+func _to_string() -> String:
+	return "%02d:%02d:%02d.%03d" % [_hour, _minute, _second, _millisecond]

addons/GdCommons/DateTime/src/TimeUnit.gd

@@ -0,0 +1,12 @@
+class_name TimeUnit
+extends Resource
+
+enum {
+	MILLIS = 1,
+	SECOND = 2,
+	MINUTE = 3,
+	HOUR   = 4,
+	DAY    = 5,
+	MONTH  = 6,
+	YEAR   = 7
+}

addons/GdCommons/DateTime/test/LocalTimeTest.gd

@@ -0,0 +1,64 @@
+# GdUnit generated TestSuite
+class_name LocalTimeTest
+extends GdUnitTestSuite
+
+# TestSuite generated from
+const __source = 'res://addons/DateTime/src/LocalTime.gd'
+
+
+func test_time_constants():
+	assert_int(LocalTime.MILLIS_PER_HOUR).is_equal(1000*60*60)
+	assert_int(LocalTime.MILLIS_PER_MINUTE).is_equal(1000*60)
+	assert_int(LocalTime.MILLIS_PER_SECOND).is_equal(1000)
+	assert_int(LocalTime.HOURS_PER_DAY).is_equal(24)
+	assert_int(LocalTime.MINUTES_PER_HOUR).is_equal(60)
+	assert_int(LocalTime.SECONDS_PER_MINUTE).is_equal(60)
+
+func test_now():
+	var current = OS.get_time(true)
+	var local_time := LocalTime.now()
+	assert_int(local_time.hour()).is_equal(current.get("hour"))
+	assert_int(local_time.minute()).is_equal(current.get("minute"))
+	assert_int(local_time.second()).is_equal(current.get("second"))
+	#  OS.get_time() does not provide milliseconds
+	#assert_that(local_time.millis()).is_equal(current.get("mili"))
+
+func test_of_unix_time():
+	var time = OS.get_unix_time()
+	var local_time := LocalTime.of_unix_time(time)
+	assert_int(local_time.hour()).is_equal((time / LocalTime.MILLIS_PER_HOUR) % 24)
+	assert_int(local_time.minute()).is_equal((time / LocalTime.MILLIS_PER_MINUTE) % 60)
+	assert_int(local_time.second()).is_equal((time / LocalTime.MILLIS_PER_SECOND) % 60)
+	assert_int(local_time.millis()).is_equal(time % 1000)
+
+func test_to_string():
+	assert_str(LocalTime.local_time(10, 12, 22, 333)._to_string()).is_equal("10:12:22.333")
+	assert_str(LocalTime.local_time(23, 59, 59, 999)._to_string()).is_equal("23:59:59.999")
+	assert_str(LocalTime.local_time( 0, 0, 0, 000)._to_string()).is_equal("00:00:00.000")
+	assert_str(LocalTime.local_time( 2, 4, 3, 10)._to_string()).is_equal("02:04:03.010")
+
+func test_plus_seconds():
+	var time := LocalTime.local_time(10, 12, 22, 333)
+	assert_str(time.plus(TimeUnit.SECOND, 10)._to_string()).is_equal("10:12:32.333")
+	assert_str(time.plus(TimeUnit.SECOND, 27)._to_string()).is_equal("10:12:59.333")
+	assert_str(time.plus(TimeUnit.SECOND, 1)._to_string()).is_equal("10:13:00.333")
+	
+	# test overflow 
+	var time2 := LocalTime.local_time(10, 59, 59, 333)
+	var start_time = time2._time
+	for iteration in 10000:
+		
+		var t = LocalTime.of_unix_time(start_time)
+		var seconds:int = rand_range(0, 1000)
+		t.plus(TimeUnit.SECOND, seconds)
+		var expected :=  LocalTime.of_unix_time(start_time + (seconds * LocalTime.MILLIS_PER_SECOND))
+		assert_str(t._to_string()).is_equal(expected._to_string())
+
+func test_elapsed():
+	assert_str(LocalTime.elapsed(10)).is_equal("10ms")
+	assert_str(LocalTime.elapsed(201)).is_equal("201ms")
+	assert_str(LocalTime.elapsed(999)).is_equal("999ms")
+	assert_str(LocalTime.elapsed(1000)).is_equal("1s 0ms")
+	assert_str(LocalTime.elapsed(2000)).is_equal("2s 0ms")
+	assert_str(LocalTime.elapsed(3040)).is_equal("3s 40ms")
+	assert_str(LocalTime.elapsed(LocalTime.MILLIS_PER_MINUTE * 6 + 3040)).is_equal("6min 3s 40ms")

addons/GdCommons/utils/src/Result.gd

@@ -0,0 +1,94 @@
+class_name Result
+extends Reference
+
+enum {
+	SUCCESS,
+	WARN,
+	ERROR,
+	EMPTY
+}
+
+var _state
+var _warn_message := ""
+var _error_message := ""
+var _value = null
+
+static func __instance() -> Result:
+	return load("res://addons/GdCommons/utils/src/Result.gd").new() as Result
+
+static func success(value) -> Result:
+	assert(value != null, "The value must not be NULL")
+	var result := __instance()
+	result._value = value
+	result._state = SUCCESS
+	return result
+
+static func warn(warn_message :String, value = null) -> Result:
+	assert(not warn_message.empty(), "The message must not be empty")
+	var result := __instance()
+	result._value = value
+	result._warn_message = warn_message
+	result._state = WARN
+	return result
+
+static func error(error_message :String, error :int = 0) -> Result:
+	assert(not error_message.empty(), "The message must not be empty")
+	var result := __instance()
+	result._value = null
+	result._error_message = error_message
+	result._state = ERROR
+	return result
+
+static func empty() -> Result:
+	var result := __instance()
+	result._state = EMPTY
+	return result
+
+
+func is_success() -> bool:
+	return _state == SUCCESS
+
+func is_warn() -> bool:
+	return _state == WARN
+
+func is_error() -> bool:
+	return _state == ERROR
+
+func is_empty() -> bool:
+	return _state == EMPTY
+
+func value():
+	return _value
+	
+func or_else(value):
+	if not is_success():
+		return value
+	return value()
+
+func error_message() -> String:
+	return _error_message
+
+func warn_message() -> String:
+	return _warn_message
+	
+func _to_string() -> String:
+	return str(serialize(self))
+
+static func serialize(result :Result) -> Dictionary:
+	if result == null:
+		push_error("Can't serialize a Null object from type Result")
+	return {
+		"state" : result._state,
+		"value" : var2str(result._value),
+		"warn_msg" : result._warn_message,
+		"err_msg" : result._error_message
+	}
+
+static func deserialize(config :Dictionary) -> Result:
+	var result := __instance()
+	result._value = str2var(config.get("value", ""))
+	result._warn_message = config.get("warn_msg", null)
+	result._error_message = config.get("err_msg", null)
+	result._state = config.get("state")
+	return result
+	

addons/GdCommons/utils/test/ResultTest.gd

@@ -0,0 +1,34 @@
+# GdUnit generated TestSuite
+class_name ResultTest
+extends GdUnitTestSuite
+
+# TestSuite generated from
+const __source = 'res://addons/GdCommons/utils/src/Result.gd'
+
+
+func test_serde():
+	var value = {
+		"info" : "test",
+		"meta" : 42
+	}
+	var source := Result.success(value)
+	var serialized_result = Result.serialize(source)
+	var deserialised_result := Result.deserialize(serialized_result)
+	assert_object(deserialised_result)\
+		.is_instanceof(Result) \
+		.is_equal(source)
+
+func test_or_else_on_success():
+	var result := Result.success("some value")
+	assert_str(result.value()).is_equal("some value")
+	assert_str(result.or_else("other value")).is_equal("some value")
+
+func test_or_else_on_warning():
+	var result := Result.warn("some warning message")
+	assert_object(result.value()).is_null()
+	assert_str(result.or_else("other value")).is_equal("other value")
+
+func test_or_else_on_error():
+	var result := Result.error("some error message")
+	assert_object(result.value()).is_null()
+	assert_str(result.or_else("other value")).is_equal("other value")

addons/gdUnit3/plugin.cfg

@@ -0,0 +1,7 @@
+[plugin]
+
+name="gdUnit3"
+description="Unit Test Framework for Godot Scripts"
+author="Mike Schulze"
+version="0.9.0-Beta"
+script="plugin.gd"