Add GUT (CLI only) and remove gd-plug

Commit GUT directly to the git repo and remove gd-plug as it is no
longer required to install GUT.

Modify GUT to be used by command-line only.

For example:
```
cp test/.gutconfig.ci.json .gutconfig.json
godot --no-window -s addons/gut/gut_cmdln.gd
```

.gitattributes

@@ -16,7 +16,6 @@
 
 # Files to exclude from asset-lib download.
 /.github export-ignore
-/addons/gd-plug export-ignore
 /docs export-ignore
 /examples export-ignore
 /misc export-ignore
@@ -32,16 +31,14 @@
 /export_presets.cfg export-ignore
 /icon.png export-ignore
 /icon.png.import export-ignore
-/plug.gd export-ignore
 /project.godot export-ignore
 /.github export-ignore
 /.import export-ignore
 /test export-ignore
 /project.godot export-ignore
 /default_env.tres export-ignore
+/addons/gut export-ignore
 /.gutconfig.json export-ignore
 /README.md export-ignore
-/addons/gd-plug export-ignore
-/plug.gd export-ignore
 /LICENSE export-ignore
 /misc export-ignore

.github/workflows/main.yml

@@ -200,26 +200,6 @@ jobs:
           name: html5-gdnative-export-templates
           path: misc/export_templates/godot/bin/webassembly_gdnative_${{matrix.target}}.zip
 
-
-  install_plugins:
-    name: 'Install Plugins'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Setup Godot
-        uses: lihop/setup-godot@v1.0.0
-      - name: Install plugins
-        run: godot --no-window -s plug.gd install
-      - name: Upload install plugins for use by other jobs
-        uses: actions/upload-artifact@v2
-        with:
-          name: plugins
-          retention-days: 1 # Minimum.
-          path: |
-            addons
-            !addons/godot_xterm
- 
-
   html5_export:
     name: 'HTML5 Export'
     needs: [ build_docker, build_native, export_template ]
@@ -240,8 +220,6 @@ jobs:
       with:
         name: html5-gdnative-export-templates
         path: misc/export_templates/godot/bin
-    - name: Install plugins
-      run: godot --no-window -s plug.gd install
     - name: Create export directory
       run: mkdir -p docs/demo
     - name: Export html5
@@ -257,7 +235,7 @@ jobs:
 
   test:
     name: 'Test'
-    needs: [ install_plugins, build_docker, build_native ]
+    needs: [ build_docker, build_native ]
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -285,11 +263,6 @@ jobs:
         with:
           name: libgodot-xterm-release
           path: addons/godot_xterm/native/bin
-      - name: Install plugins
-        uses: actions/download-artifact@v2
-        with:
-          name: plugins
-          path: ./addons
       - name: Run tests
         if: ${{ matrix.godot_version != 'v3.2-stable' }}
         shell: bash

.gitignore

@@ -19,12 +19,6 @@ mono_crash.*
 .vscode
 .vs
 
-# Package-manager-specific ignores
-.plugged
-addons/*
-!addons/gd-plug
-!addons/godot_xterm
-
 # Test-specific ignores
 .gutconfig.json
 test/results.xml

addons/gut/GutScene.gd

@@ -0,0 +1,556 @@
+extends Panel
+
+onready var _script_list = $ScriptsList
+onready var _nav_container = $VBox/BottomPanel/VBox/HBox/Navigation
+onready var _nav = {
+	container = _nav_container,
+	prev = _nav_container.get_node("VBox/HBox/Previous"),
+	next = _nav_container.get_node("VBox/HBox/Next"),
+	run = _nav_container.get_node("VBox/HBox/Run"),
+	current_script = _nav_container.get_node("VBox/CurrentScript"),
+	run_single = _nav_container.get_node("VBox/HBox/RunSingleScript")
+}
+
+onready var _progress_container = $VBox/BottomPanel/VBox/HBox/Progress
+onready var _progress = {
+	script = _progress_container.get_node("ScriptProgress"),
+	script_xy = _progress_container.get_node("ScriptProgress/xy"),
+	test = _progress_container.get_node("TestProgress"),
+	test_xy = _progress_container.get_node("TestProgress/xy")
+}
+onready var _summary = {
+	control = $VBox/TitleBar/HBox/Summary,
+	failing = $VBox/TitleBar/HBox/Summary/Failing,
+	passing = $VBox/TitleBar/HBox/Summary/Passing,
+	asserts = $VBox/TitleBar/HBox/Summary/AssertCount,
+	fail_count = 0,
+	pass_count = 0
+}
+
+onready var _extras = $ExtraOptions
+onready var _ignore_pauses = $ExtraOptions/IgnorePause
+onready var _continue_button = $VBox/BottomPanel/VBox/HBox/Continue/Continue
+onready var _text_box = $VBox/TextDisplay/RichTextLabel
+onready var _text_box_container = $VBox/TextDisplay
+onready var _log_level_slider = $VBox/BottomPanel/VBox/HBox2/LogLevelSlider
+onready var _resize_handle = $ResizeHandle
+onready var _current_script = $VBox/BottomPanel/VBox/HBox2/CurrentScriptLabel
+onready var _title_replacement = $VBox/TitleBar/HBox/TitleReplacement
+
+onready var _titlebar = {
+	bar = $VBox/TitleBar, time = $VBox/TitleBar/HBox/Time, label = $VBox/TitleBar/HBox/Title
+}
+
+onready var _user_files = $UserFileViewer
+
+var _mouse = {down = false, in_title = false, down_pos = null, in_handle = false}
+
+var _is_running = false
+var _start_time = 0.0
+var _time = 0.0
+
+const DEFAULT_TITLE = "GUT"
+var _pre_maximize_rect = null
+var _font_size = 20
+var _compact_mode = false
+
+var min_sizes = {
+	compact = Vector2(330, 100),
+	full = Vector2(740, 300),
+}
+
+signal end_pause
+signal ignore_pause
+signal log_level_changed
+signal run_script
+signal run_single_script
+
+
+func _ready():
+	if Engine.editor_hint:
+		return
+
+	_current_script.text = ""
+	_pre_maximize_rect = get_rect()
+	_hide_scripts()
+	_update_controls()
+	_nav.current_script.set_text("No scripts available")
+	set_title()
+	clear_summary()
+	_titlebar.time.set_text("t: 0.0")
+
+	_extras.visible = false
+	update()
+
+	set_font_size(_font_size)
+	set_font("CourierPrime")
+
+	_user_files.set_position(Vector2(10, 30))
+
+
+func elapsed_time_as_str():
+	return str("%.1f" % (_time / 1000.0), "s")
+
+
+func _process(_delta):
+	if _is_running:
+		_time = OS.get_ticks_msec() - _start_time
+		_titlebar.time.set_text(str("t: ", elapsed_time_as_str()))
+
+
+func _draw():  # needs get_size()
+	# Draw the lines in the corner to show where you can
+	# drag to resize the dialog
+	var grab_margin = 3
+	var line_space = 3
+	var grab_line_color = Color(.4, .4, .4)
+	if _resize_handle.visible:
+		for i in range(1, 10):
+			var x = rect_size - Vector2(i * line_space, grab_margin)
+			var y = rect_size - Vector2(grab_margin, i * line_space)
+			draw_line(x, y, grab_line_color, 1, true)
+
+
+func _on_Maximize_draw():
+	# draw the maximize square thing.
+	var btn = $VBox/TitleBar/HBox/Maximize
+	btn.set_text("")
+	var w = btn.get_size().x
+	var h = btn.get_size().y
+	btn.draw_rect(Rect2(0, 2, w, h - 2), Color(0, 0, 0, 1))
+	btn.draw_rect(Rect2(2, 6, w - 4, h - 8), Color(1, 1, 1, 1))
+
+
+func _on_ShowExtras_draw():
+	var btn = $VBox/BottomPanel/VBox/HBox/Continue/ShowExtras
+	btn.set_text("")
+	var start_x = 20
+	var start_y = 15
+	var pad = 5
+	var color = Color(.1, .1, .1, 1)
+	var width = 2
+	for i in range(3):
+		var y = start_y + pad * i
+		btn.draw_line(
+			Vector2(start_x, y), Vector2(btn.get_size().x - start_x, y), color, width, true
+		)
+
+
+# ####################
+# GUI Events
+# ####################
+func _on_Run_pressed():
+	_run_mode()
+	emit_signal("run_script", get_selected_index())
+
+
+func _on_CurrentScript_pressed():
+	_toggle_scripts()
+
+
+func _on_Previous_pressed():
+	_select_script(get_selected_index() - 1)
+
+
+func _on_Next_pressed():
+	_select_script(get_selected_index() + 1)
+
+
+func _on_LogLevelSlider_value_changed(_value):
+	emit_signal("log_level_changed", _log_level_slider.value)
+
+
+func _on_Continue_pressed():
+	_continue_button.disabled = true
+	emit_signal("end_pause")
+
+
+func _on_IgnorePause_pressed():
+	var checked = _ignore_pauses.is_pressed()
+	emit_signal("ignore_pause", checked)
+	if checked:
+		emit_signal("end_pause")
+		_continue_button.disabled = true
+
+
+func _on_RunSingleScript_pressed():
+	_run_mode()
+	emit_signal("run_single_script", get_selected_index())
+
+
+func _on_ScriptsList_item_selected(index):
+	var tmr = $ScriptsList/DoubleClickTimer
+	if !tmr.is_stopped():
+		_run_mode()
+		emit_signal("run_single_script", get_selected_index())
+		tmr.stop()
+	else:
+		tmr.start()
+
+	_select_script(index)
+
+
+func _on_TitleBar_mouse_entered():
+	_mouse.in_title = true
+
+
+func _on_TitleBar_mouse_exited():
+	_mouse.in_title = false
+
+
+func _input(event):
+	if event is InputEventMouseButton:
+		if event.button_index == 1:
+			_mouse.down = event.pressed
+			if _mouse.down:
+				_mouse.down_pos = event.position
+
+	if _mouse.in_title:
+		if event is InputEventMouseMotion and _mouse.down:
+			set_position(get_position() + (event.position - _mouse.down_pos))
+			_mouse.down_pos = event.position
+			_pre_maximize_rect = get_rect()
+
+	if _mouse.in_handle:
+		if event is InputEventMouseMotion and _mouse.down:
+			var new_size = rect_size + event.position - _mouse.down_pos
+			var new_mouse_down_pos = event.position
+			rect_size = new_size
+			_mouse.down_pos = new_mouse_down_pos
+			_pre_maximize_rect = get_rect()
+
+
+func _on_ResizeHandle_mouse_entered():
+	_mouse.in_handle = true
+
+
+func _on_ResizeHandle_mouse_exited():
+	_mouse.in_handle = false
+
+
+func _on_RichTextLabel_gui_input(ev):
+	pass
+	# leaving this b/c it is wired up and might have to send
+	# more signals through
+
+
+func _on_Copy_pressed():
+	OS.clipboard = _text_box.text
+
+
+func _on_ShowExtras_toggled(button_pressed):
+	_extras.visible = button_pressed
+
+
+func _on_Maximize_pressed():
+	if get_rect() == _pre_maximize_rect:
+		compact_mode(false)
+		maximize()
+	else:
+		compact_mode(false)
+		rect_size = _pre_maximize_rect.size
+		rect_position = _pre_maximize_rect.position
+
+
+func _on_Minimize_pressed():
+	compact_mode(!_compact_mode)
+
+
+func _on_Minimize_draw():
+	# draw the maximize square thing.
+	var btn = $VBox/TitleBar/HBox/Minimize
+	btn.set_text("")
+	var w = btn.get_size().x
+	var h = btn.get_size().y
+	btn.draw_rect(Rect2(0, h - 3, w, 3), Color(0, 0, 0, 1))
+
+
+func _on_UserFiles_pressed():
+	_user_files.show_open()
+
+
+# ####################
+# Private
+# ####################
+func _run_mode(is_running = true):
+	if is_running:
+		_start_time = OS.get_ticks_msec()
+		_time = 0.0
+		clear_summary()
+	_is_running = is_running
+
+	_hide_scripts()
+	_nav.prev.disabled = is_running
+	_nav.next.disabled = is_running
+	_nav.run.disabled = is_running
+	_nav.current_script.disabled = is_running
+	_nav.run_single.disabled = is_running
+
+
+func _select_script(index):
+	var text = _script_list.get_item_text(index)
+	var max_len = 50
+	if text.length() > max_len:
+		text = "..." + text.right(text.length() - (max_len - 5))
+	_nav.current_script.set_text(text)
+	_script_list.select(index)
+	_update_controls()
+
+
+func _toggle_scripts():
+	if _script_list.visible:
+		_hide_scripts()
+	else:
+		_show_scripts()
+
+
+func _show_scripts():
+	_script_list.show()
+
+
+func _hide_scripts():
+	_script_list.hide()
+
+
+func _update_controls():
+	var is_empty = _script_list.get_selected_items().size() == 0
+	if is_empty:
+		_nav.next.disabled = true
+		_nav.prev.disabled = true
+	else:
+		var index = get_selected_index()
+		_nav.prev.disabled = index <= 0
+		_nav.next.disabled = index >= _script_list.get_item_count() - 1
+
+	_nav.run.disabled = is_empty
+	_nav.current_script.disabled = is_empty
+	_nav.run_single.disabled = is_empty
+
+
+func _update_summary():
+	if !_summary:
+		return
+
+	var total = _summary.fail_count + _summary.pass_count
+	_summary.control.visible = !total == 0
+	_summary.asserts.text = str("Failures ", _summary.fail_count, "/", total)
+
+
+# ####################
+# Public
+# ####################
+func run_mode(is_running = true):
+	_run_mode(is_running)
+
+
+func set_scripts(scripts):
+	_script_list.clear()
+	for i in range(scripts.size()):
+		_script_list.add_item(scripts[i])
+	_select_script(0)
+	_update_controls()
+
+
+func select_script(index):
+	_select_script(index)
+
+
+func get_selected_index():
+	return _script_list.get_selected_items()[0]
+
+
+func get_log_level():
+	return _log_level_slider.value
+
+
+func set_log_level(value):
+	var new_value = value
+	if new_value == null:
+		new_value = 0
+	# !! For some reason, _log_level_slider was null, but this wasn't, so
+	# here's another hardcoded node path.
+	$VBox/BottomPanel/VBox/HBox2/LogLevelSlider.value = new_value
+
+
+func set_ignore_pause(should):
+	_ignore_pauses.pressed = should
+
+
+func get_ignore_pause():
+	return _ignore_pauses.pressed
+
+
+func get_text_box():
+	# due to some timing issue, this cannot return _text_box but can return
+	# this.
+	return $VBox/TextDisplay/RichTextLabel
+
+
+func end_run():
+	_run_mode(false)
+	_update_controls()
+
+
+func set_progress_script_max(value):
+	var max_val = max(value, 1)
+	_progress.script.set_max(max_val)
+	_progress.script_xy.set_text(str("0/", max_val))
+
+
+func set_progress_script_value(value):
+	_progress.script.set_value(value)
+	var txt = str(value, "/", _progress.test.get_max())
+	_progress.script_xy.set_text(txt)
+
+
+func set_progress_test_max(value):
+	var max_val = max(value, 1)
+	_progress.test.set_max(max_val)
+	_progress.test_xy.set_text(str("0/", max_val))
+
+
+func set_progress_test_value(value):
+	_progress.test.set_value(value)
+	var txt = str(value, "/", _progress.test.get_max())
+	_progress.test_xy.set_text(txt)
+
+
+func clear_progress():
+	_progress.test.set_value(0)
+	_progress.script.set_value(0)
+
+
+func pause():
+	_continue_button.disabled = false
+
+
+func set_title(title = null):
+	if title == null:
+		_titlebar.label.set_text(DEFAULT_TITLE)
+	else:
+		_titlebar.label.set_text(title)
+
+
+func add_passing(amount = 1):
+	if !_summary:
+		return
+	_summary.pass_count += amount
+	_update_summary()
+
+
+func add_failing(amount = 1):
+	if !_summary:
+		return
+	_summary.fail_count += amount
+	_update_summary()
+
+
+func clear_summary():
+	_summary.fail_count = 0
+	_summary.pass_count = 0
+	_update_summary()
+
+
+func maximize():
+	if is_inside_tree():
+		var vp_size_offset = get_tree().root.get_viewport().get_visible_rect().size
+		rect_size = vp_size_offset / get_scale()
+		set_position(Vector2(0, 0))
+
+
+func clear_text():
+	_text_box.bbcode_text = ""
+
+
+func scroll_to_bottom():
+	pass
+	#_text_box.cursor_set_line(_gui.get_text_box().get_line_count())
+
+
+func _set_font_size_for_rtl(rtl, new_size):
+	if rtl.get("custom_fonts/normal_font") != null:
+		rtl.get("custom_fonts/bold_italics_font").size = new_size
+		rtl.get("custom_fonts/bold_font").size = new_size
+		rtl.get("custom_fonts/italics_font").size = new_size
+		rtl.get("custom_fonts/normal_font").size = new_size
+
+
+func _set_fonts_for_rtl(rtl, base_font_name):
+	pass
+
+
+func set_font_size(new_size):
+	_font_size = new_size
+	_set_font_size_for_rtl(_text_box, new_size)
+	_set_font_size_for_rtl(_user_files.get_rich_text_label(), new_size)
+
+
+func _set_font(rtl, font_name, custom_name):
+	if font_name == null:
+		rtl.set("custom_fonts/" + custom_name, null)
+	else:
+		var dyn_font = preload("res://addons/godot_xterm/themes/fonts/regular.tres").duplicate()
+		rtl.set("custom_fonts/" + custom_name, dyn_font)
+
+
+func _set_all_fonts_in_ftl(ftl, base_name):
+	if base_name == "Default":
+		_set_font(ftl, null, "normal_font")
+		_set_font(ftl, null, "bold_font")
+		_set_font(ftl, null, "italics_font")
+		_set_font(ftl, null, "bold_italics_font")
+	else:
+		_set_font(ftl, base_name + "-Regular", "normal_font")
+		_set_font(ftl, base_name + "-Bold", "bold_font")
+		_set_font(ftl, base_name + "-Italic", "italics_font")
+		_set_font(ftl, base_name + "-BoldItalic", "bold_italics_font")
+	set_font_size(_font_size)
+
+
+func set_font(base_name):
+	_set_all_fonts_in_ftl(_text_box, base_name)
+	_set_all_fonts_in_ftl(_user_files.get_rich_text_label(), base_name)
+
+
+func set_default_font_color(color):
+	_text_box.set("custom_colors/default_color", color)
+
+
+func set_background_color(color):
+	_text_box_container.color = color
+
+
+func get_waiting_label():
+	return $VBox/TextDisplay/WaitingLabel
+
+
+func compact_mode(should):
+	if _compact_mode == should:
+		return
+
+	_compact_mode = should
+	_text_box_container.visible = !should
+	_nav.container.visible = !should
+	_log_level_slider.visible = !should
+	$VBox/BottomPanel/VBox/HBox/Continue/ShowExtras.visible = !should
+	_titlebar.label.visible = !should
+	_resize_handle.visible = !should
+	_current_script.visible = !should
+	_title_replacement.visible = should
+
+	if should:
+		rect_min_size = min_sizes.compact
+		rect_size = rect_min_size
+	else:
+		rect_min_size = min_sizes.full
+		rect_size = min_sizes.full
+
+	goto_bottom_right_corner()
+
+
+func set_script_path(text):
+	_current_script.text = text
+
+
+func goto_bottom_right_corner():
+	rect_position = get_tree().root.get_viewport().get_visible_rect().size - rect_size

addons/gut/GutScene.tscn

@@ -0,0 +1,617 @@
+[gd_scene load_steps=16 format=2]
+
+[ext_resource path="res://addons/gut/GutScene.gd" type="Script" id=1]
+[ext_resource path="res://addons/gut/UserFileViewer.tscn" type="PackedScene" id=6]
+
+[sub_resource type="StyleBoxFlat" id=1]
+bg_color = Color( 0.192157, 0.192157, 0.227451, 1 )
+corner_radius_top_left = 10
+corner_radius_top_right = 10
+
+[sub_resource type="StyleBoxFlat" id=2]
+bg_color = Color( 1, 1, 1, 1 )
+border_color = Color( 0, 0, 0, 1 )
+corner_radius_top_left = 5
+corner_radius_top_right = 5
+
+[sub_resource type="Theme" id=3]
+resource_local_to_scene = true
+Panel/styles/panel = SubResource( 2 )
+Panel/styles/panelf = null
+Panel/styles/panelnc = null
+
+[sub_resource type="StyleBoxFlat" id=8]
+bg_color = Color( 0.192157, 0.192157, 0.227451, 1 )
+corner_radius_top_left = 20
+corner_radius_top_right = 20
+
+[node name="Gut" type="Panel"]
+margin_right = 740.0
+margin_bottom = 300.0
+rect_min_size = Vector2( 740, 300 )
+custom_styles/panel = SubResource( 1 )
+script = ExtResource( 1 )
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="UserFileViewer" parent="." instance=ExtResource( 6 )]
+margin_top = 388.0
+margin_bottom = 818.0
+
+[node name="VBox" type="VBoxContainer" parent="."]
+anchor_right = 1.0
+anchor_bottom = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="TitleBar" type="Panel" parent="VBox"]
+margin_right = 740.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 0, 30 )
+theme = SubResource( 3 )
+__meta__ = {
+"_edit_group_": true,
+"_edit_use_anchors_": false
+}
+
+[node name="HBox" type="HBoxContainer" parent="VBox/TitleBar"]
+anchor_right = 1.0
+anchor_bottom = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Summary" type="Control" parent="VBox/TitleBar/HBox"]
+margin_right = 110.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 110, 0 )
+mouse_filter = 2
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Passing" type="Label" parent="VBox/TitleBar/HBox/Summary"]
+visible = false
+margin_left = 5.0
+margin_top = 7.0
+margin_right = 45.0
+margin_bottom = 21.0
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "0"
+align = 1
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Failing" type="Label" parent="VBox/TitleBar/HBox/Summary"]
+visible = false
+margin_left = 100.0
+margin_top = 7.0
+margin_right = 140.0
+margin_bottom = 21.0
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "0"
+align = 1
+valign = 1
+
+[node name="AssertCount" type="Label" parent="VBox/TitleBar/HBox/Summary"]
+margin_left = 5.0
+margin_top = 7.0
+margin_right = 165.0
+margin_bottom = 21.0
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "Assert count"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="TitleReplacement" type="CenterContainer" parent="VBox/TitleBar/HBox"]
+visible = false
+margin_left = 114.0
+margin_right = 352.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 5, 0 )
+mouse_filter = 2
+size_flags_horizontal = 3
+size_flags_vertical = 3
+
+[node name="Title" type="Label" parent="VBox/TitleBar/HBox"]
+margin_left = 114.0
+margin_right = 594.0
+margin_bottom = 30.0
+size_flags_horizontal = 3
+size_flags_vertical = 7
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "Gut"
+align = 1
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Time" type="Label" parent="VBox/TitleBar/HBox"]
+margin_left = 598.0
+margin_top = 7.0
+margin_right = 654.0
+margin_bottom = 22.0
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "9999.99"
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CC" type="CenterContainer" parent="VBox/TitleBar/HBox"]
+margin_left = 658.0
+margin_right = 663.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 5, 0 )
+mouse_filter = 2
+
+[node name="Minimize" type="Button" parent="VBox/TitleBar/HBox"]
+margin_left = 667.0
+margin_right = 697.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 30, 0 )
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "N"
+flat = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Maximize" type="Button" parent="VBox/TitleBar/HBox"]
+margin_left = 701.0
+margin_right = 731.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 30, 0 )
+custom_colors/font_color = Color( 0, 0, 0, 1 )
+text = "X"
+flat = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CC2" type="CenterContainer" parent="VBox/TitleBar/HBox"]
+margin_left = 735.0
+margin_right = 740.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 5, 0 )
+mouse_filter = 2
+
+[node name="TextDisplay" type="ColorRect" parent="VBox"]
+margin_top = 34.0
+margin_right = 740.0
+margin_bottom = 176.0
+size_flags_horizontal = 3
+size_flags_vertical = 3
+color = Color( 0, 0, 0, 1 )
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="RichTextLabel" type="RichTextLabel" parent="VBox/TextDisplay"]
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = 10.0
+rect_min_size = Vector2( 0, 116 )
+focus_mode = 2
+size_flags_horizontal = 3
+size_flags_vertical = 3
+bbcode_enabled = true
+scroll_following = true
+selection_enabled = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="WaitingLabel" type="RichTextLabel" parent="VBox/TextDisplay"]
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_top = -25.0
+bbcode_enabled = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="BottomPanel" type="ColorRect" parent="VBox"]
+margin_top = 180.0
+margin_right = 740.0
+margin_bottom = 300.0
+rect_min_size = Vector2( 0, 120 )
+size_flags_horizontal = 9
+size_flags_vertical = 9
+color = Color( 1, 1, 1, 0 )
+
+[node name="VBox" type="VBoxContainer" parent="VBox/BottomPanel"]
+anchor_right = 1.0
+anchor_bottom = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="HBox" type="HBoxContainer" parent="VBox/BottomPanel/VBox"]
+margin_right = 740.0
+margin_bottom = 80.0
+size_flags_horizontal = 3
+
+[node name="CC1" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox"]
+margin_right = 5.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 5, 0 )
+
+[node name="Progress" type="VBoxContainer" parent="VBox/BottomPanel/VBox/HBox"]
+margin_left = 9.0
+margin_right = 179.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 170, 0 )
+alignment = 1
+
+[node name="TestProgress" type="ProgressBar" parent="VBox/BottomPanel/VBox/HBox/Progress"]
+margin_top = 11.0
+margin_right = 100.0
+margin_bottom = 36.0
+rect_min_size = Vector2( 100, 25 )
+hint_tooltip = "Test progress for the current script."
+size_flags_horizontal = 0
+step = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Label" type="Label" parent="VBox/BottomPanel/VBox/HBox/Progress/TestProgress"]
+margin_left = 107.5
+margin_top = 3.0
+margin_right = 172.5
+margin_bottom = 18.0
+text = "Tests"
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="xy" type="Label" parent="VBox/BottomPanel/VBox/HBox/Progress/TestProgress"]
+visible = false
+anchor_right = 1.0
+anchor_bottom = 1.0
+text = "0/0"
+align = 1
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="ScriptProgress" type="ProgressBar" parent="VBox/BottomPanel/VBox/HBox/Progress"]
+margin_top = 40.0
+margin_right = 100.0
+margin_bottom = 65.0
+rect_min_size = Vector2( 100, 25 )
+hint_tooltip = "Overall progress of executing tests."
+size_flags_horizontal = 0
+step = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Label" type="Label" parent="VBox/BottomPanel/VBox/HBox/Progress/ScriptProgress"]
+margin_left = 107.0
+margin_top = 3.5
+margin_right = 172.0
+margin_bottom = 18.5
+text = "Scripts"
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="xy" type="Label" parent="VBox/BottomPanel/VBox/HBox/Progress/ScriptProgress"]
+visible = false
+anchor_right = 1.0
+anchor_bottom = 1.0
+text = "0/0"
+align = 1
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CenterContainer" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox/Progress"]
+margin_top = 69.0
+margin_right = 170.0
+margin_bottom = 69.0
+
+[node name="CC2" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox"]
+margin_left = 183.0
+margin_right = 226.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 5, 0 )
+size_flags_horizontal = 3
+
+[node name="Navigation" type="Panel" parent="VBox/BottomPanel/VBox/HBox"]
+self_modulate = Color( 1, 1, 1, 0 )
+margin_left = 230.0
+margin_right = 580.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 350, 80 )
+__meta__ = {
+"_edit_group_": true,
+"_edit_use_anchors_": false
+}
+
+[node name="VBox" type="VBoxContainer" parent="VBox/BottomPanel/VBox/HBox/Navigation"]
+anchor_right = 1.0
+anchor_bottom = 1.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CurrentScript" type="Button" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox"]
+margin_right = 350.0
+margin_bottom = 38.0
+hint_tooltip = "Select a script to run.  You can run just this script, or this script and all scripts after using the run buttons."
+size_flags_horizontal = 3
+size_flags_vertical = 3
+text = "res://test/unit/test_gut.gd"
+clip_text = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="HBox" type="HBoxContainer" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox"]
+margin_top = 42.0
+margin_right = 350.0
+margin_bottom = 80.0
+size_flags_horizontal = 3
+size_flags_vertical = 3
+
+[node name="Previous" type="Button" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox"]
+margin_right = 84.0
+margin_bottom = 38.0
+hint_tooltip = "Previous script in the list."
+size_flags_horizontal = 3
+size_flags_vertical = 3
+text = "|<"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Next" type="Button" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox"]
+margin_left = 88.0
+margin_right = 173.0
+margin_bottom = 38.0
+hint_tooltip = "Next script in the list.
+"
+size_flags_horizontal = 3
+size_flags_vertical = 3
+text = ">|"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Run" type="Button" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox"]
+margin_left = 177.0
+margin_right = 261.0
+margin_bottom = 38.0
+hint_tooltip = "Run the currently selected item and all after it."
+size_flags_horizontal = 3
+size_flags_vertical = 3
+text = ">"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="RunSingleScript" type="Button" parent="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox"]
+margin_left = 265.0
+margin_right = 350.0
+margin_bottom = 38.0
+hint_tooltip = "Run the currently selected item.
+
+If the selected item has Inner Test Classes
+then they will all be run.  If the selected item
+is an Inner Test Class then only it will be run."
+size_flags_horizontal = 3
+size_flags_vertical = 3
+text = "> (1)"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CC3" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox"]
+margin_left = 584.0
+margin_right = 627.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 5, 0 )
+size_flags_horizontal = 3
+
+[node name="Continue" type="VBoxContainer" parent="VBox/BottomPanel/VBox/HBox"]
+self_modulate = Color( 1, 1, 1, 0 )
+margin_left = 631.0
+margin_right = 731.0
+margin_bottom = 80.0
+alignment = 1
+
+[node name="ShowExtras" type="Button" parent="VBox/BottomPanel/VBox/HBox/Continue"]
+margin_right = 50.0
+margin_bottom = 35.0
+rect_min_size = Vector2( 50, 35 )
+rect_pivot_offset = Vector2( 35, 20 )
+hint_tooltip = "Show/hide additional options."
+size_flags_horizontal = 0
+toggle_mode = true
+text = "_"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Continue" type="Button" parent="VBox/BottomPanel/VBox/HBox/Continue"]
+margin_top = 39.0
+margin_right = 100.0
+margin_bottom = 79.0
+rect_min_size = Vector2( 100, 40 )
+hint_tooltip = "When a pause_before_teardown is encountered this button will be enabled and must be pressed to continue running tests."
+disabled = true
+text = "Continue"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CC4" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox"]
+margin_left = 735.0
+margin_right = 740.0
+margin_bottom = 80.0
+rect_min_size = Vector2( 5, 0 )
+
+[node name="HBox2" type="HBoxContainer" parent="VBox/BottomPanel/VBox"]
+margin_top = 84.0
+margin_right = 740.0
+margin_bottom = 114.0
+
+[node name="CC" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox2"]
+margin_right = 5.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 5, 0 )
+
+[node name="LogLevelSlider" type="HSlider" parent="VBox/BottomPanel/VBox/HBox2"]
+margin_left = 9.0
+margin_right = 109.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 100, 30 )
+size_flags_vertical = 3
+max_value = 2.0
+tick_count = 3
+ticks_on_borders = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Label" type="Label" parent="VBox/BottomPanel/VBox/HBox2/LogLevelSlider"]
+margin_left = 4.0
+margin_top = -17.0
+margin_right = 85.0
+margin_bottom = 7.0
+text = "Log Level"
+valign = 1
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="CenterContainer" type="CenterContainer" parent="VBox/BottomPanel/VBox/HBox2"]
+margin_left = 113.0
+margin_right = 163.0
+margin_bottom = 30.0
+rect_min_size = Vector2( 50, 0 )
+
+[node name="CurrentScriptLabel" type="Label" parent="VBox/BottomPanel/VBox/HBox2"]
+margin_left = 167.0
+margin_top = 7.0
+margin_right = 740.0
+margin_bottom = 22.0
+size_flags_horizontal = 3
+size_flags_vertical = 6
+text = "res://test/unit/test_something.gd"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="ScriptsList" type="ItemList" parent="."]
+visible = false
+anchor_bottom = 1.0
+margin_left = 179.0
+margin_top = 40.0
+margin_right = 619.0
+margin_bottom = -110.0
+allow_reselect = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="DoubleClickTimer" type="Timer" parent="ScriptsList"]
+wait_time = 0.3
+one_shot = true
+
+[node name="ExtraOptions" type="Panel" parent="."]
+visible = false
+anchor_left = 1.0
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -212.0
+margin_top = -260.0
+margin_right = -2.0
+margin_bottom = -106.0
+custom_styles/panel = SubResource( 8 )
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="IgnorePause" type="CheckBox" parent="ExtraOptions"]
+margin_left = 17.5
+margin_top = 4.5
+margin_right = 162.5
+margin_bottom = 29.5
+rect_scale = Vector2( 1.2, 1.2 )
+hint_tooltip = "Ignore all calls to pause_before_teardown."
+text = "Ignore Pauses"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Copy" type="Button" parent="ExtraOptions"]
+margin_left = 15.0
+margin_top = 40.0
+margin_right = 195.0
+margin_bottom = 80.0
+hint_tooltip = "Copy all output to the clipboard."
+text = "Copy to Clipboard"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="UserFiles" type="Button" parent="ExtraOptions"]
+margin_left = 15.0
+margin_top = 90.0
+margin_right = 195.0
+margin_bottom = 130.0
+hint_tooltip = "Copy all output to the clipboard."
+text = "View User Files"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="ResizeHandle" type="Control" parent="."]
+anchor_left = 1.0
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -40.0
+margin_top = -40.0
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[connection signal="mouse_entered" from="VBox/TitleBar" to="." method="_on_TitleBar_mouse_entered"]
+[connection signal="mouse_exited" from="VBox/TitleBar" to="." method="_on_TitleBar_mouse_exited"]
+[connection signal="draw" from="VBox/TitleBar/HBox/Minimize" to="." method="_on_Minimize_draw"]
+[connection signal="pressed" from="VBox/TitleBar/HBox/Minimize" to="." method="_on_Minimize_pressed"]
+[connection signal="draw" from="VBox/TitleBar/HBox/Maximize" to="." method="_on_Maximize_draw"]
+[connection signal="pressed" from="VBox/TitleBar/HBox/Maximize" to="." method="_on_Maximize_pressed"]
+[connection signal="gui_input" from="VBox/TextDisplay/RichTextLabel" to="." method="_on_RichTextLabel_gui_input"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Navigation/VBox/CurrentScript" to="." method="_on_CurrentScript_pressed"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox/Previous" to="." method="_on_Previous_pressed"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox/Next" to="." method="_on_Next_pressed"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox/Run" to="." method="_on_Run_pressed"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Navigation/VBox/HBox/RunSingleScript" to="." method="_on_RunSingleScript_pressed"]
+[connection signal="draw" from="VBox/BottomPanel/VBox/HBox/Continue/ShowExtras" to="." method="_on_ShowExtras_draw"]
+[connection signal="toggled" from="VBox/BottomPanel/VBox/HBox/Continue/ShowExtras" to="." method="_on_ShowExtras_toggled"]
+[connection signal="pressed" from="VBox/BottomPanel/VBox/HBox/Continue/Continue" to="." method="_on_Continue_pressed"]
+[connection signal="value_changed" from="VBox/BottomPanel/VBox/HBox2/LogLevelSlider" to="." method="_on_LogLevelSlider_value_changed"]
+[connection signal="item_selected" from="ScriptsList" to="." method="_on_ScriptsList_item_selected"]
+[connection signal="pressed" from="ExtraOptions/IgnorePause" to="." method="_on_IgnorePause_pressed"]
+[connection signal="pressed" from="ExtraOptions/Copy" to="." method="_on_Copy_pressed"]
+[connection signal="pressed" from="ExtraOptions/UserFiles" to="." method="_on_UserFiles_pressed"]
+[connection signal="mouse_entered" from="ResizeHandle" to="." method="_on_ResizeHandle_mouse_entered"]
+[connection signal="mouse_exited" from="ResizeHandle" to="." method="_on_ResizeHandle_mouse_exited"]

addons/gut/LICENSE.md

@@ -1,6 +1,7 @@
-MIT License
+The MIT License (MIT)
+=====================
 
-Copyright (c) 2021 Tan Jian Ping
+Copyright (c) 2018 Tom "Butch" Wesley
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +10,13 @@ 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
+The above copyright notice and this permission notice shall be included in
-copies or substantial portions of the Software.
+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
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-SOFTWARE.
+THE SOFTWARE.

addons/gut/UserFileViewer.gd

@@ -0,0 +1,66 @@
+extends WindowDialog
+
+onready var rtl = $TextDisplay/RichTextLabel
+var _has_opened_file = false
+
+
+func _get_file_as_text(path):
+	var to_return = null
+	var f = File.new()
+	var result = f.open(path, f.READ)
+	if result == OK:
+		to_return = f.get_as_text()
+		f.close()
+	else:
+		to_return = str("ERROR:  Could not open file.  Error code ", result)
+	return to_return
+
+
+func _ready():
+	rtl.clear()
+
+
+func _on_OpenFile_pressed():
+	$FileDialog.popup_centered()
+
+
+func _on_FileDialog_file_selected(path):
+	show_file(path)
+
+
+func _on_Close_pressed():
+	self.hide()
+
+
+func show_file(path):
+	var text = _get_file_as_text(path)
+	if text == "":
+		text = "<Empty File>"
+	rtl.set_text(text)
+	self.window_title = path
+
+
+func show_open():
+	self.popup_centered()
+	$FileDialog.popup_centered()
+
+
+func _on_FileDialog_popup_hide():
+	if rtl.text.length() == 0:
+		self.hide()
+
+
+func get_rich_text_label():
+	return $TextDisplay/RichTextLabel
+
+
+func _on_Home_pressed():
+	rtl.scroll_to_line(0)
+
+
+func _on_End_pressed():
+	rtl.scroll_to_line(rtl.get_line_count() - 1)
+
+
+func _on_Copy_pressed():
+	OS.clipboard = rtl.text

addons/gut/UserFileViewer.tscn

@@ -0,0 +1,128 @@
+[gd_scene load_steps=2 format=2]
+
+[ext_resource path="res://addons/gut/UserFileViewer.gd" type="Script" id=1]
+
+[node name="UserFileViewer" type="WindowDialog"]
+margin_top = 20.0
+margin_right = 800.0
+margin_bottom = 450.0
+rect_min_size = Vector2( 800, 180 )
+popup_exclusive = true
+window_title = "View  File"
+resizable = true
+script = ExtResource( 1 )
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="FileDialog" type="FileDialog" parent="."]
+margin_right = 416.0
+margin_bottom = 184.0
+rect_min_size = Vector2( 400, 140 )
+rect_scale = Vector2( 2, 2 )
+popup_exclusive = true
+window_title = "Open a File"
+resizable = true
+mode = 0
+access = 1
+show_hidden_files = true
+current_dir = "user://"
+current_path = "user://"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="TextDisplay" type="ColorRect" parent="."]
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = 8.0
+margin_right = -10.0
+margin_bottom = -65.0
+color = Color( 0.2, 0.188235, 0.188235, 1 )
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="RichTextLabel" type="RichTextLabel" parent="TextDisplay"]
+anchor_right = 1.0
+anchor_bottom = 1.0
+focus_mode = 2
+text = "In publishing and graphic design, Lorem ipsum is a placeholder text commonly used to demonstrate the visual form of a document or a typeface without relying on meaningful content. Lorem ipsum may be used before final copy is available, but it may also be used to temporarily replace copy in a process called greeking, which allows designers to consider form without the meaning of the text influencing the design.
+
+Lorem ipsum is typically a corrupted version of De finibus bonorum et malorum, a first-century BCE text by the Roman statesman and philosopher Cicero, with words altered, added, and removed to make it nonsensical, improper Latin.
+
+Versions of the Lorem ipsum text have been used in typesetting at least since the 1960s, when it was popularized by advertisements for Letraset transfer sheets. Lorem ipsum was introduced to the digital world in the mid-1980s when Aldus employed it in graphic and word-processing templates for its desktop publishing program PageMaker. Other popular word processors including Pages and Microsoft Word have since adopted Lorem ipsum as well."
+selection_enabled = true
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="OpenFile" type="Button" parent="."]
+anchor_left = 1.0
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -158.0
+margin_top = -50.0
+margin_right = -84.0
+margin_bottom = -30.0
+rect_scale = Vector2( 2, 2 )
+text = "Open File"
+
+[node name="Home" type="Button" parent="."]
+anchor_left = 1.0
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -478.0
+margin_top = -50.0
+margin_right = -404.0
+margin_bottom = -30.0
+rect_scale = Vector2( 2, 2 )
+text = "Home"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="Copy" type="Button" parent="."]
+anchor_top = 1.0
+anchor_bottom = 1.0
+margin_left = 160.0
+margin_top = -50.0
+margin_right = 234.0
+margin_bottom = -30.0
+rect_scale = Vector2( 2, 2 )
+text = "Copy"
+__meta__ = {
+"_edit_use_anchors_": false
+}
+
+[node name="End" type="Button" parent="."]
+anchor_left = 1.0
+anchor_top = 1.0
+anchor_right = 1.0
+anchor_bottom = 1.0
+margin_left = -318.0
+margin_top = -50.0
+margin_right = -244.0
+margin_bottom = -30.0
+rect_scale = Vector2( 2, 2 )
+text = "End"
+
+[node name="Close" type="Button" parent="."]
+anchor_top = 1.0
+anchor_bottom = 1.0
+margin_left = 10.0
+margin_top = -50.0
+margin_right = 80.0
+margin_bottom = -30.0
+rect_scale = Vector2( 2, 2 )
+text = "Close"
+
+[connection signal="file_selected" from="FileDialog" to="." method="_on_FileDialog_file_selected"]
+[connection signal="popup_hide" from="FileDialog" to="." method="_on_FileDialog_popup_hide"]
+[connection signal="pressed" from="OpenFile" to="." method="_on_OpenFile_pressed"]
+[connection signal="pressed" from="Home" to="." method="_on_Home_pressed"]
+[connection signal="pressed" from="Copy" to="." method="_on_Copy_pressed"]
+[connection signal="pressed" from="End" to="." method="_on_End_pressed"]
+[connection signal="pressed" from="Close" to="." method="_on_Close_pressed"]

addons/gut/autofree.gd

@@ -0,0 +1,62 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Class used to keep track of objects to be freed and utilities to free them.
+# ##############################################################################
+var _to_free = []
+var _to_queue_free = []
+
+
+func add_free(thing):
+	if typeof(thing) == TYPE_OBJECT:
+		if !thing is Reference:
+			_to_free.append(thing)
+
+
+func add_queue_free(thing):
+	_to_queue_free.append(thing)
+
+
+func get_queue_free_count():
+	return _to_queue_free.size()
+
+
+func get_free_count():
+	return _to_free.size()
+
+
+func free_all():
+	for i in range(_to_free.size()):
+		if is_instance_valid(_to_free[i]):
+			_to_free[i].free()
+	_to_free.clear()
+
+	for i in range(_to_queue_free.size()):
+		if is_instance_valid(_to_queue_free[i]):
+			_to_queue_free[i].queue_free()
+	_to_queue_free.clear()

addons/gut/comparator.gd

@@ -0,0 +1,134 @@
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _strutils = _utils.Strutils.new()
+var _max_length = 100
+var _should_compare_int_to_float = true
+
+const MISSING = "|__missing__gut__compare__value__|"
+const DICTIONARY_DISCLAIMER = "Dictionaries are compared-by-ref.  See assert_eq in wiki."
+
+
+func _cannot_comapre_text(v1, v2):
+	return str(
+		"Cannot compare ", _strutils.types[typeof(v1)], " with ", _strutils.types[typeof(v2)], "."
+	)
+
+
+func _make_missing_string(text):
+	return "<missing " + text + ">"
+
+
+func _create_missing_result(v1, v2, text):
+	var to_return = null
+	var v1_str = format_value(v1)
+	var v2_str = format_value(v2)
+
+	if typeof(v1) == TYPE_STRING and v1 == MISSING:
+		v1_str = _make_missing_string(text)
+		to_return = _utils.CompareResult.new()
+	elif typeof(v2) == TYPE_STRING and v2 == MISSING:
+		v2_str = _make_missing_string(text)
+		to_return = _utils.CompareResult.new()
+
+	if to_return != null:
+		to_return.summary = str(v1_str, " != ", v2_str)
+		to_return.are_equal = false
+
+	return to_return
+
+
+func simple(v1, v2, missing_string = ""):
+	var missing_result = _create_missing_result(v1, v2, missing_string)
+	if missing_result != null:
+		return missing_result
+
+	var result = _utils.CompareResult.new()
+	var cmp_str = null
+	var extra = ""
+
+	if _should_compare_int_to_float and [2, 3].has(typeof(v1)) and [2, 3].has(typeof(v2)):
+		result.are_equal = v1 == v2
+
+	elif _utils.are_datatypes_same(v1, v2):
+		result.are_equal = v1 == v2
+		if typeof(v1) == TYPE_DICTIONARY:
+			if result.are_equal:
+				extra = ".  Same dictionary ref.  "
+			else:
+				extra = ".  Different dictionary refs.  "
+			extra += DICTIONARY_DISCLAIMER
+
+		if typeof(v1) == TYPE_ARRAY:
+			var array_result = _utils.DiffTool.new(v1, v2, _utils.DIFF.SHALLOW)
+			result.summary = array_result.get_short_summary()
+			if !array_result.are_equal():
+				extra = ".\n" + array_result.get_short_summary()
+
+	else:
+		cmp_str = "!="
+		result.are_equal = false
+		extra = str(".  ", _cannot_comapre_text(v1, v2))
+
+	cmp_str = get_compare_symbol(result.are_equal)
+	if typeof(v1) != TYPE_ARRAY:
+		result.summary = str(format_value(v1), " ", cmp_str, " ", format_value(v2), extra)
+
+	return result
+
+
+func shallow(v1, v2):
+	var result = null
+
+	if _utils.are_datatypes_same(v1, v2):
+		if typeof(v1) in [TYPE_ARRAY, TYPE_DICTIONARY]:
+			result = _utils.DiffTool.new(v1, v2, _utils.DIFF.SHALLOW)
+		else:
+			result = simple(v1, v2)
+	else:
+		result = simple(v1, v2)
+
+	return result
+
+
+func deep(v1, v2):
+	var result = null
+
+	if _utils.are_datatypes_same(v1, v2):
+		if typeof(v1) in [TYPE_ARRAY, TYPE_DICTIONARY]:
+			result = _utils.DiffTool.new(v1, v2, _utils.DIFF.DEEP)
+		else:
+			result = simple(v1, v2)
+	else:
+		result = simple(v1, v2)
+
+	return result
+
+
+func format_value(val, max_val_length = _max_length):
+	return _strutils.truncate_string(_strutils.type2str(val), max_val_length)
+
+
+func compare(v1, v2, diff_type = _utils.DIFF.SIMPLE):
+	var result = null
+	if diff_type == _utils.DIFF.SIMPLE:
+		result = simple(v1, v2)
+	elif diff_type == _utils.DIFF.SHALLOW:
+		result = shallow(v1, v2)
+	elif diff_type == _utils.DIFF.DEEP:
+		result = deep(v1, v2)
+
+	return result
+
+
+func get_should_compare_int_to_float():
+	return _should_compare_int_to_float
+
+
+func set_should_compare_int_to_float(should_compare_int_float):
+	_should_compare_int_to_float = should_compare_int_float
+
+
+func get_compare_symbol(is_equal):
+	if is_equal:
+		return "=="
+	else:
+		return "!="

addons/gut/compare_result.gd

@@ -0,0 +1,60 @@
+var are_equal = null setget set_are_equal, get_are_equal
+var summary = null setget set_summary, get_summary
+var max_differences = 30 setget set_max_differences, get_max_differences
+var differences = {} setget set_differences, get_differences
+
+
+func _block_set(which, val):
+	push_error(str("cannot set ", which, ", value [", val, "] ignored."))
+
+
+func _to_string():
+	return str(get_summary())  # could be null, gotta str it.
+
+
+func get_are_equal():
+	return are_equal
+
+
+func set_are_equal(r_eq):
+	are_equal = r_eq
+
+
+func get_summary():
+	return summary
+
+
+func set_summary(smry):
+	summary = smry
+
+
+func get_total_count():
+	pass
+
+
+func get_different_count():
+	pass
+
+
+func get_short_summary():
+	return summary
+
+
+func get_max_differences():
+	return max_differences
+
+
+func set_max_differences(max_diff):
+	max_differences = max_diff
+
+
+func get_differences():
+	return differences
+
+
+func set_differences(diffs):
+	_block_set("differences", diffs)
+
+
+func get_brackets():
+	return null

addons/gut/diff_formatter.gd

@@ -0,0 +1,67 @@
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _strutils = _utils.Strutils.new()
+const INDENT = "    "
+var _max_to_display = 30
+const ABSOLUTE_MAX_DISPLAYED = 10000
+const UNLIMITED = -1
+
+
+func _single_diff(diff, depth = 0):
+	var to_return = ""
+	var brackets = diff.get_brackets()
+
+	if brackets != null and !diff.are_equal:
+		to_return = ""
+		to_return += str(
+			brackets.open,
+			"\n",
+			_strutils.indent_text(differences_to_s(diff.differences, depth), depth + 1, INDENT),
+			"\n",
+			brackets.close
+		)
+	else:
+		to_return = str(diff)
+
+	return to_return
+
+
+func make_it(diff):
+	var to_return = ""
+	if diff.are_equal:
+		to_return = diff.summary
+	else:
+		if _max_to_display == ABSOLUTE_MAX_DISPLAYED:
+			to_return = str(diff.get_value_1(), " != ", diff.get_value_2())
+		else:
+			to_return = diff.get_short_summary()
+		to_return += str("\n", _strutils.indent_text(_single_diff(diff, 0), 1, "  "))
+	return to_return
+
+
+func differences_to_s(differences, depth = 0):
+	var to_return = ""
+	var keys = differences.keys()
+	keys.sort()
+	var limit = min(_max_to_display, differences.size())
+
+	for i in range(limit):
+		var key = keys[i]
+		to_return += str(key, ":  ", _single_diff(differences[key], depth))
+
+		if i != limit - 1:
+			to_return += "\n"
+
+	if differences.size() > _max_to_display:
+		to_return += str("\n\n... ", differences.size() - _max_to_display, " more.")
+
+	return to_return
+
+
+func get_max_to_display():
+	return _max_to_display
+
+
+func set_max_to_display(max_to_display):
+	_max_to_display = max_to_display
+	if _max_to_display == UNLIMITED:
+		_max_to_display = ABSOLUTE_MAX_DISPLAYED

addons/gut/diff_tool.gd

@@ -0,0 +1,179 @@
+extends "res://addons/gut/compare_result.gd"
+const INDENT = "    "
+enum { DEEP, SHALLOW, SIMPLE }
+
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _strutils = _utils.Strutils.new()
+var _compare = _utils.Comparator.new()
+var DiffTool = load("res://addons/gut/diff_tool.gd")
+
+var _value_1 = null
+var _value_2 = null
+var _total_count = 0
+var _diff_type = null
+var _brackets = null
+var _valid = true
+var _desc_things = "somethings"
+
+
+# -------- comapre_result.gd "interface" ---------------------
+func set_are_equal(val):
+	_block_set("are_equal", val)
+
+
+func get_are_equal():
+	return are_equal()
+
+
+func set_summary(val):
+	_block_set("summary", val)
+
+
+func get_summary():
+	return summarize()
+
+
+func get_different_count():
+	return differences.size()
+
+
+func get_total_count():
+	return _total_count
+
+
+func get_short_summary():
+	var text = str(
+		_strutils.truncate_string(str(_value_1), 50),
+		" ",
+		_compare.get_compare_symbol(are_equal()),
+		" ",
+		_strutils.truncate_string(str(_value_2), 50)
+	)
+	if !are_equal():
+		text += str(
+			"  ",
+			get_different_count(),
+			" of ",
+			get_total_count(),
+			" ",
+			_desc_things,
+			" do not match."
+		)
+	return text
+
+
+func get_brackets():
+	return _brackets
+
+
+# -------- comapre_result.gd "interface" ---------------------
+
+
+func _invalidate():
+	_valid = false
+	differences = null
+
+
+func _init(v1, v2, diff_type = DEEP):
+	_value_1 = v1
+	_value_2 = v2
+	_diff_type = diff_type
+	_compare.set_should_compare_int_to_float(false)
+	_find_differences(_value_1, _value_2)
+
+
+func _find_differences(v1, v2):
+	if _utils.are_datatypes_same(v1, v2):
+		if typeof(v1) == TYPE_ARRAY:
+			_brackets = {"open": "[", "close": "]"}
+			_desc_things = "indexes"
+			_diff_array(v1, v2)
+		elif typeof(v2) == TYPE_DICTIONARY:
+			_brackets = {"open": "{", "close": "}"}
+			_desc_things = "keys"
+			_diff_dictionary(v1, v2)
+		else:
+			_invalidate()
+			_utils.get_logger().error("Only Arrays and Dictionaries are supported.")
+	else:
+		_invalidate()
+		_utils.get_logger().error("Only Arrays and Dictionaries are supported.")
+
+
+func _diff_array(a1, a2):
+	_total_count = max(a1.size(), a2.size())
+	for i in range(a1.size()):
+		var result = null
+		if i < a2.size():
+			if _diff_type == DEEP:
+				result = _compare.deep(a1[i], a2[i])
+			else:
+				result = _compare.simple(a1[i], a2[i])
+		else:
+			result = _compare.simple(a1[i], _compare.MISSING, "index")
+
+		if !result.are_equal:
+			differences[i] = result
+
+	if a1.size() < a2.size():
+		for i in range(a1.size(), a2.size()):
+			differences[i] = _compare.simple(_compare.MISSING, a2[i], "index")
+
+
+func _diff_dictionary(d1, d2):
+	var d1_keys = d1.keys()
+	var d2_keys = d2.keys()
+
+	# Process all the keys in d1
+	_total_count += d1_keys.size()
+	for key in d1_keys:
+		if !d2.has(key):
+			differences[key] = _compare.simple(d1[key], _compare.MISSING, "key")
+		else:
+			d2_keys.remove(d2_keys.find(key))
+
+			var result = null
+			if _diff_type == DEEP:
+				result = _compare.deep(d1[key], d2[key])
+			else:
+				result = _compare.simple(d1[key], d2[key])
+
+			if !result.are_equal:
+				differences[key] = result
+
+	# Process all the keys in d2 that didn't exist in d1
+	_total_count += d2_keys.size()
+	for i in range(d2_keys.size()):
+		differences[d2_keys[i]] = _compare.simple(_compare.MISSING, d2[d2_keys[i]], "key")
+
+
+func summarize():
+	var summary = ""
+
+	if are_equal():
+		summary = get_short_summary()
+	else:
+		var formatter = load("res://addons/gut/diff_formatter.gd").new()
+		formatter.set_max_to_display(max_differences)
+		summary = formatter.make_it(self)
+
+	return summary
+
+
+func are_equal():
+	if !_valid:
+		return null
+	else:
+		return differences.size() == 0
+
+
+func get_diff_type():
+	return _diff_type
+
+
+func get_value_1():
+	return _value_1
+
+
+func get_value_2():
+	return _value_2

addons/gut/double_templates/function_template.txt

@@ -0,0 +1,6 @@
+{func_decleration}
+	__gut_spy('{method_name}', {param_array})
+	if(__gut_should_call_super('{method_name}', {param_array})):
+		return {super_call}
+	else:
+		return __gut_get_stubbed_return('{method_name}', {param_array})

addons/gut/double_templates/script_template.txt

@@ -0,0 +1,59 @@
+# ##############################################################################
+# Start Script
+# ##############################################################################
+{extends}
+
+{constants}
+
+{properties}
+# ------------------------------------------------------------------------------
+# GUT Double properties and methods
+# ------------------------------------------------------------------------------
+var __gut_metadata_ = {
+	path = '{path}',
+	subpath = '{subpath}',
+	stubber = __gut_instance_from_id({stubber_id}),
+	spy = __gut_instance_from_id({spy_id}),
+	gut = __gut_instance_from_id({gut_id}),
+	from_singleton = '{singleton_name}',
+	is_partial = {is_partial}
+}
+
+func __gut_instance_from_id(inst_id):
+	if(inst_id ==  -1):
+		return null
+	else:
+		return instance_from_id(inst_id)
+
+func __gut_should_call_super(method_name, called_with):
+	if(__gut_metadata_.stubber != null):
+		return __gut_metadata_.stubber.should_call_super(self, method_name, called_with)
+	else:
+		return false
+
+var __gut_utils_ = load('res://addons/gut/utils.gd').get_instance()
+
+func __gut_spy(method_name, called_with):
+	if(__gut_metadata_.spy != null):
+		__gut_metadata_.spy.add_call(self, method_name, called_with)
+
+func __gut_get_stubbed_return(method_name, called_with):
+	if(__gut_metadata_.stubber != null):
+		return __gut_metadata_.stubber.get_return(self, method_name, called_with)
+	else:
+		return null
+
+func __gut_default_val(method_name, p_index):
+	if(__gut_metadata_.stubber != null):
+		return __gut_metadata_.stubber.get_default_value(self, method_name, p_index)
+	else:
+		return null
+
+
+func  _init():
+	if(__gut_metadata_.gut != null):
+		__gut_metadata_.gut.get_autofree().add_free(self)
+
+# ------------------------------------------------------------------------------
+# Methods start here
+# ------------------------------------------------------------------------------

addons/gut/doubler.gd

@@ -0,0 +1,763 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# ##############################################################################
+
+# ------------------------------------------------------------------------------
+# Utility class to hold the local and built in methods separately.  Add all local
+# methods FIRST, then add built ins.
+# ------------------------------------------------------------------------------
+class ScriptMethods:
+	# List of methods that should not be overloaded when they are not defined
+	# in the class being doubled.  These either break things if they are
+	# overloaded or do not have a "super" equivalent so we can't just pass
+	# through.
+	var _blacklist = [
+		"has_method",
+		"get_script",
+		"get",
+		"_notification",
+		"get_path",
+		"_enter_tree",
+		"_exit_tree",
+		"_process",
+		"_draw",
+		"_physics_process",
+		"_input",
+		"_unhandled_input",
+		"_unhandled_key_input",
+		"_set",
+		"_get",  # probably
+		"emit_signal",  # can't handle extra parameters to be sent with signal.
+		"draw_mesh",  # issue with one parameter, value is `Null((..), (..), (..))``
+		"_to_string",  # nonexistant function ._to_string
+		"_get_minimum_size",  # Nonexistent function _get_minimum_size
+	]
+
+	# These methods should not be included in the double.
+	var _skip = [
+		# There is an init in the template.  There is also no real reason
+		# to include this method since it will always be called, it has no
+		# return value, and you cannot prevent super from being called.
+		"_init"
+	]
+
+	var built_ins = []
+	var local_methods = []
+	var _method_names = []
+
+	func is_blacklisted(method_meta):
+		return _blacklist.find(method_meta.name) != -1
+
+	func _add_name_if_does_not_have(method_name):
+		if _skip.has(method_name):
+			return false
+		var should_add = _method_names.find(method_name) == -1
+		if should_add:
+			_method_names.append(method_name)
+		return should_add
+
+	func add_built_in_method(method_meta):
+		var did_add = _add_name_if_does_not_have(method_meta.name)
+		if did_add and !is_blacklisted(method_meta):
+			built_ins.append(method_meta)
+
+	func add_local_method(method_meta):
+		var did_add = _add_name_if_does_not_have(method_meta.name)
+		if did_add:
+			local_methods.append(method_meta)
+
+	func to_s():
+		var text = "Locals\n"
+		for i in range(local_methods.size()):
+			text += str("  ", local_methods[i].name, "\n")
+		text += "Built-Ins\n"
+		for i in range(built_ins.size()):
+			text += str("  ", built_ins[i].name, "\n")
+		return text
+
+
+# ------------------------------------------------------------------------------
+# Helper class to deal with objects and inner classes.
+# ------------------------------------------------------------------------------
+class ObjectInfo:
+	var _path = null
+	var _subpaths = []
+	var _utils = load("res://addons/gut/utils.gd").get_instance()
+	var _lgr = _utils.get_logger()
+	var _method_strategy = null
+	var make_partial_double = false
+	var scene_path = null
+	var _native_class = null
+	var _native_class_name = null
+	var _singleton_instance = null
+	var _singleton_name = null
+
+	func _init(path, subpath = null):
+		_path = path
+		if subpath != null:
+			_subpaths = Array(subpath.split("/"))
+
+	# Returns an instance of the class/inner class
+	func instantiate():
+		var to_return = null
+
+		if _singleton_instance != null:
+			to_return = _singleton_instance
+		elif is_native():
+			to_return = _native_class.new()
+		else:
+			to_return = get_loaded_class().new()
+
+		return to_return
+
+	# Can't call it get_class because that is reserved so it gets this ugly name.
+	# Loads up the class and then any inner classes to give back a reference to
+	# the desired Inner class (if there is any)
+	func get_loaded_class():
+		var LoadedClass = load(_path)
+		for i in range(_subpaths.size()):
+			LoadedClass = LoadedClass.get(_subpaths[i])
+		return LoadedClass
+
+	func to_s():
+		return str(_path, "[", get_subpath(), "]")
+
+	func get_path():
+		return _path
+
+	func get_subpath():
+		return PoolStringArray(_subpaths).join("/")
+
+	func has_subpath():
+		return _subpaths.size() != 0
+
+	func get_method_strategy():
+		return _method_strategy
+
+	func set_method_strategy(method_strategy):
+		_method_strategy = method_strategy
+
+	func is_native():
+		return _native_class != null
+
+	func set_native_class(native_class):
+		_native_class = native_class
+		var inst = native_class.new()
+		_native_class_name = inst.get_class()
+		_path = _native_class_name
+		if !inst is Reference:
+			inst.free()
+
+	func get_native_class_name():
+		return _native_class_name
+
+	func get_singleton_instance():
+		return _singleton_instance
+
+	func get_singleton_name():
+		return _singleton_name
+
+	func set_singleton_name(singleton_name):
+		_singleton_name = singleton_name
+		_singleton_instance = _utils.get_singleton_by_name(_singleton_name)
+
+	func is_singleton():
+		return _singleton_instance != null
+
+	func get_extends_text():
+		var extend = null
+		if is_singleton():
+			extend = str("# Double of singleton ", _singleton_name, ", base class is Reference")
+		elif is_native():
+			var native = get_native_class_name()
+			if native.begins_with("_"):
+				native = native.substr(1)
+			extend = str("extends ", native)
+		else:
+			extend = str("extends '", get_path(), "'")
+
+		if has_subpath():
+			extend += str(".", get_subpath().replace("/", "."))
+
+		return extend
+
+	func get_constants_text():
+		if !is_singleton():
+			return ""
+
+		# do not include constants defined in the super class which for
+		# singletons stubs is Reference.
+		var exclude_constants = Array(ClassDB.class_get_integer_constant_list("Reference"))
+		var text = str("# -----\n# ", _singleton_name, " Constants\n# -----\n")
+		var constants = ClassDB.class_get_integer_constant_list(_singleton_name)
+		for c in constants:
+			if !exclude_constants.has(c):
+				var value = ClassDB.class_get_integer_constant(_singleton_name, c)
+				text += str("const ", c, " = ", value, "\n")
+
+		return text
+
+	func get_properties_text():
+		if !is_singleton():
+			return ""
+
+		var text = str("# -----\n# ", _singleton_name, " Properties\n# -----\n")
+		var props = ClassDB.class_get_property_list(_singleton_name)
+		for prop in props:
+			var accessors = {"setter": null, "getter": null}
+			var prop_text = str("var ", prop["name"])
+
+			var getter_name = "get_" + prop["name"]
+			if ClassDB.class_has_method(_singleton_name, getter_name):
+				accessors.getter = getter_name
+			else:
+				getter_name = "is_" + prop["name"]
+				if ClassDB.class_has_method(_singleton_name, getter_name):
+					accessors.getter = getter_name
+
+			var setter_name = "set_" + prop["name"]
+			if ClassDB.class_has_method(_singleton_name, setter_name):
+				accessors.setter = setter_name
+
+			var setget_text = ""
+			if accessors.setter != null and accessors.getter != null:
+				setget_text = str("setget ", accessors.setter, ", ", accessors.getter)
+			else:
+				# never seen this message show up, but it should show up if we
+				# get misbehaving singleton.
+				_lgr.error(
+					str(
+						"Could not find setget methods for property:  ",
+						_singleton_name,
+						".",
+						prop["name"]
+					)
+				)
+
+			text += str(prop_text, " ", setget_text, "\n")
+
+		return text
+
+
+# ------------------------------------------------------------------------------
+# Allows for interacting with a file but only creating a string.  This was done
+# to ease the transition from files being created for doubles to loading
+# doubles from a string.  This allows the files to be created for debugging
+# purposes since reading a file is easier than reading a dumped out string.
+# ------------------------------------------------------------------------------
+class FileOrString:
+	extends File
+
+	var _do_file = false
+	var _contents = ""
+	var _path = null
+
+	func open(path, mode):
+		_path = path
+		if _do_file:
+			return .open(path, mode)
+		else:
+			return OK
+
+	func close():
+		if _do_file:
+			return .close()
+
+	func store_string(s):
+		if _do_file:
+			.store_string(s)
+		_contents += s
+
+	func get_contents():
+		return _contents
+
+	func get_path():
+		return _path
+
+	func load_it():
+		if _contents != "":
+			var script = GDScript.new()
+			script.set_source_code(get_contents())
+			script.reload()
+			return script
+		else:
+			return load(_path)
+
+
+# ------------------------------------------------------------------------------
+# A stroke of genius if I do say so.  This allows for doubling a scene without
+# having  to write any files.  By overloading the "instance" method  we can
+# make whatever we want.
+# ------------------------------------------------------------------------------
+class PackedSceneDouble:
+	extends PackedScene
+	var _script = null
+	var _scene = null
+
+	func set_script_obj(obj):
+		_script = obj
+
+	func instance(edit_state = 0):
+		var inst = _scene.instance(edit_state)
+		if _script != null:
+			inst.set_script(_script)
+		return inst
+
+	func load_scene(path):
+		_scene = load(path)
+
+
+# ------------------------------------------------------------------------------
+# START Doubler
+# ------------------------------------------------------------------------------
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+
+var _ignored_methods = _utils.OneToMany.new()
+var _stubber = _utils.Stubber.new()
+var _lgr = _utils.get_logger()
+var _method_maker = _utils.MethodMaker.new()
+
+var _output_dir = "user://gut_temp_directory"
+var _double_count = 0  # used in making files names unique
+var _spy = null
+var _gut = null
+var _strategy = null
+var _base_script_text = _utils.get_file_as_text(
+	"res://addons/gut/double_templates/script_template.txt"
+)
+var _make_files = false
+# used by tests for debugging purposes.
+var _print_source = false
+
+
+func _init(strategy = _utils.DOUBLE_STRATEGY.PARTIAL):
+	set_logger(_utils.get_logger())
+	_strategy = strategy
+
+
+# ###############
+# Private
+# ###############
+func _get_indented_line(indents, text):
+	var to_return = ""
+	for _i in range(indents):
+		to_return += "\t"
+	return str(to_return, text, "\n")
+
+
+func _stub_to_call_super(obj_info, method_name):
+	if _utils.non_super_methods.has(method_name):
+		return
+
+	var path = obj_info.get_path()
+	if obj_info.is_singleton():
+		path = obj_info.get_singleton_name()
+	elif obj_info.scene_path != null:
+		path = obj_info.scene_path
+
+	var params = _utils.StubParams.new(path, method_name, obj_info.get_subpath())
+	params.to_call_super()
+	_stubber.add_stub(params)
+
+
+func _get_base_script_text(obj_info, override_path):
+	var path = obj_info.get_path()
+	if override_path != null:
+		path = override_path
+
+	var stubber_id = -1
+	if _stubber != null:
+		stubber_id = _stubber.get_instance_id()
+
+	var spy_id = -1
+	if _spy != null:
+		spy_id = _spy.get_instance_id()
+
+	var gut_id = -1
+	if _gut != null:
+		gut_id = _gut.get_instance_id()
+
+	var values = {
+		# Top  sections
+		"extends": obj_info.get_extends_text(),
+		"constants": obj_info.get_constants_text(),
+		"properties": obj_info.get_properties_text(),
+		# metadata values
+		"path": path,
+		"subpath": obj_info.get_subpath(),
+		"stubber_id": stubber_id,
+		"spy_id": spy_id,
+		"gut_id": gut_id,
+		"singleton_name": _utils.nvl(obj_info.get_singleton_name(), ""),
+		"is_partial": str(obj_info.make_partial_double).to_lower()
+	}
+
+	return _base_script_text.format(values)
+
+
+func _write_file(obj_info, dest_path, override_path = null):
+	var base_script = _get_base_script_text(obj_info, override_path)
+	var script_methods = _get_methods(obj_info)
+	var super_name = ""
+	var path = ""
+
+	if obj_info.is_singleton():
+		super_name = obj_info.get_singleton_name()
+	else:
+		path = obj_info.get_path()
+
+	var f = FileOrString.new()
+	f._do_file = _make_files
+	var f_result = f.open(dest_path, f.WRITE)
+
+	if f_result != OK:
+		_lgr.error(str("Error creating file ", dest_path))
+		_lgr.error(str("Could not create double for :", obj_info.to_s()))
+		return
+
+	f.store_string(base_script)
+
+	for i in range(script_methods.local_methods.size()):
+		f.store_string(_get_func_text(script_methods.local_methods[i], path, super_name))
+
+	for i in range(script_methods.built_ins.size()):
+		_stub_to_call_super(obj_info, script_methods.built_ins[i].name)
+		f.store_string(_get_func_text(script_methods.built_ins[i], path, super_name))
+
+	f.close()
+	if _print_source:
+		print(f.get_contents())
+	return f
+
+
+func _double_scene_and_script(scene_info):
+	var to_return = PackedSceneDouble.new()
+	to_return.load_scene(scene_info.get_path())
+
+	var inst = load(scene_info.get_path()).instance()
+	var script_path = null
+	if inst.get_script():
+		script_path = inst.get_script().get_path()
+	inst.free()
+
+	if script_path:
+		var oi = ObjectInfo.new(script_path)
+		oi.set_method_strategy(scene_info.get_method_strategy())
+		oi.make_partial_double = scene_info.make_partial_double
+		oi.scene_path = scene_info.get_path()
+		to_return.set_script_obj(_double(oi, scene_info.get_path()).load_it())
+
+	return to_return
+
+
+func _get_methods(object_info):
+	var obj = object_info.instantiate()
+	# any method in the script or super script
+	var script_methods = ScriptMethods.new()
+	var methods = obj.get_method_list()
+
+	if !object_info.is_singleton() and !(obj is Reference):
+		obj.free()
+
+	# first pass is for local methods only
+	for i in range(methods.size()):
+		if object_info.is_singleton():
+			#print(methods[i].name, " :: ", methods[i].flags, " :: ", methods[i].id)
+			#print("    ", methods[i])
+
+			# It appears that the ID for methods upstream from a singleton are
+			# below 200.  Initially it was thought that singleton specific methods
+			# were above 1000.  This was true for Input but not for OS.  I've
+			# changed the condition to be > 200 instead of > 1000.  It will take
+			# some investigation to figure out if this is right, but it works
+			# for now.  Someone either find an issue and open a bug, or this will
+			# just exist like this.  Sorry future me (or someone else).
+			if methods[i].id > 200 and methods[i].flags in [1, 9]:
+				script_methods.add_local_method(methods[i])
+
+		# 65 is a magic number for methods in script, though documentation
+		# says 64.  This picks up local overloads of base class methods too.
+		# See MethodFlags in @GlobalScope
+		elif (
+			methods[i].flags == 65
+			and !_ignored_methods.has(object_info.get_path(), methods[i]["name"])
+		):
+			script_methods.add_local_method(methods[i])
+
+	if object_info.get_method_strategy() == _utils.DOUBLE_STRATEGY.FULL:
+		# second pass is for anything not local
+		for j in range(methods.size()):
+			# 65 is a magic number for methods in script, though documentation
+			# says 64.  This picks up local overloads of base class methods too.
+			if (
+				methods[j].flags != 65
+				and !_ignored_methods.has(object_info.get_path(), methods[j]["name"])
+			):
+				script_methods.add_built_in_method(methods[j])
+
+	return script_methods
+
+
+func _get_inst_id_ref_str(inst):
+	var ref_str = "null"
+	if inst:
+		ref_str = str("instance_from_id(", inst.get_instance_id(), ")")
+	return ref_str
+
+
+func _get_func_text(method_hash, path, super = ""):
+	var override_count = null
+	if _stubber != null:
+		override_count = _stubber.get_parameter_count(path, method_hash.name)
+
+	var text = _method_maker.get_function_text(method_hash, path, override_count, super) + "\n"
+
+	return text
+
+
+# returns the path to write the double file to
+func _get_temp_path(object_info):
+	var file_name = null
+	var extension = null
+
+	if object_info.is_singleton():
+		file_name = str(object_info.get_singleton_instance())
+		extension = "gd"
+	elif object_info.is_native():
+		file_name = object_info.get_native_class_name()
+		extension = "gd"
+	else:
+		file_name = object_info.get_path().get_file().get_basename()
+		extension = object_info.get_path().get_extension()
+
+	if object_info.has_subpath():
+		file_name += "__" + object_info.get_subpath().replace("/", "__")
+
+	file_name += str("__dbl", _double_count, "__.", extension)
+
+	var to_return = _output_dir.plus_file(file_name)
+	return to_return
+
+
+func _double(obj_info, override_path = null):
+	var temp_path = _get_temp_path(obj_info)
+	var result = _write_file(obj_info, temp_path, override_path)
+	_double_count += 1
+	return result
+
+
+func _double_script(path, make_partial, strategy):
+	var oi = ObjectInfo.new(path)
+	oi.make_partial_double = make_partial
+	oi.set_method_strategy(strategy)
+	return _double(oi).load_it()
+
+
+func _double_inner(path, subpath, make_partial, strategy):
+	var oi = ObjectInfo.new(path, subpath)
+	oi.set_method_strategy(strategy)
+	oi.make_partial_double = make_partial
+	return _double(oi).load_it()
+
+
+func _double_scene(path, make_partial, strategy):
+	var oi = ObjectInfo.new(path)
+	oi.set_method_strategy(strategy)
+	oi.make_partial_double = make_partial
+	return _double_scene_and_script(oi)
+
+
+func _double_gdnative(native_class, make_partial, strategy):
+	var oi = ObjectInfo.new(null)
+	oi.set_native_class(native_class)
+	oi.set_method_strategy(strategy)
+	oi.make_partial_double = make_partial
+	return _double(oi).load_it()
+
+
+func _double_singleton(singleton_name, make_partial, strategy):
+	var oi = ObjectInfo.new(null)
+	oi.set_singleton_name(singleton_name)
+	oi.set_method_strategy(_utils.DOUBLE_STRATEGY.PARTIAL)
+	oi.make_partial_double = make_partial
+	return _double(oi).load_it()
+
+
+# ###############
+# Public
+# ###############
+func get_output_dir():
+	return _output_dir
+
+
+func set_output_dir(output_dir):
+	if output_dir != null:
+		_output_dir = output_dir
+		if _make_files:
+			var d = Directory.new()
+			d.make_dir_recursive(output_dir)
+
+
+func get_spy():
+	return _spy
+
+
+func set_spy(spy):
+	_spy = spy
+
+
+func get_stubber():
+	return _stubber
+
+
+func set_stubber(stubber):
+	_stubber = stubber
+
+
+func get_logger():
+	return _lgr
+
+
+func set_logger(logger):
+	_lgr = logger
+	_method_maker.set_logger(logger)
+
+
+func get_strategy():
+	return _strategy
+
+
+func set_strategy(strategy):
+	_strategy = strategy
+
+
+func get_gut():
+	return _gut
+
+
+func set_gut(gut):
+	_gut = gut
+
+
+func partial_double_scene(path, strategy = _strategy):
+	return _double_scene(path, true, strategy)
+
+
+# double a scene
+func double_scene(path, strategy = _strategy):
+	return _double_scene(path, false, strategy)
+
+
+# double a script/object
+func double(path, strategy = _strategy):
+	return _double_script(path, false, strategy)
+
+
+func partial_double(path, strategy = _strategy):
+	return _double_script(path, true, strategy)
+
+
+func partial_double_inner(path, subpath, strategy = _strategy):
+	return _double_inner(path, subpath, true, strategy)
+
+
+# double an inner class in a script
+func double_inner(path, subpath, strategy = _strategy):
+	return _double_inner(path, subpath, false, strategy)
+
+
+# must always use FULL strategy since this is a native class and you won't get
+# any methods if you don't use FULL
+func double_gdnative(native_class):
+	return _double_gdnative(native_class, false, _utils.DOUBLE_STRATEGY.FULL)
+
+
+# must always use FULL strategy since this is a native class and you won't get
+# any methods if you don't use FULL
+func partial_double_gdnative(native_class):
+	return _double_gdnative(native_class, true, _utils.DOUBLE_STRATEGY.FULL)
+
+
+func double_singleton(name):
+	return _double_singleton(name, false, _utils.DOUBLE_STRATEGY.PARTIAL)
+
+
+func partial_double_singleton(name):
+	return _double_singleton(name, true, _utils.DOUBLE_STRATEGY.PARTIAL)
+
+
+func clear_output_directory():
+	if !_make_files:
+		return false
+
+	var did = false
+	if _output_dir.find("user://") == 0:
+		var d = Directory.new()
+		var result = d.open(_output_dir)
+		# BIG GOTCHA HERE.  If it cannot open the dir w/ erro 31, then the
+		# directory becomes res:// and things go on normally and gut clears out
+		# out res:// which is SUPER BAD.
+		if result == OK:
+			d.list_dir_begin(true)
+			var f = d.get_next()
+			while f != "":
+				d.remove(f)
+				f = d.get_next()
+				did = true
+	return did
+
+
+func delete_output_directory():
+	var did = clear_output_directory()
+	if did:
+		var d = Directory.new()
+		d.remove(_output_dir)
+
+
+func add_ignored_method(path, method_name):
+	_ignored_methods.add(path, method_name)
+
+
+func get_ignored_methods():
+	return _ignored_methods
+
+
+func get_make_files():
+	return _make_files
+
+
+func set_make_files(make_files):
+	_make_files = make_files
+	set_output_dir(_output_dir)
+
+
+func get_method_maker():
+	return _method_maker

addons/gut/get_native_script.gd

@@ -0,0 +1,6 @@
+# Since NativeScript does not exist if GDNative is not included in the build
+# of Godot this script is conditionally loaded only when NativeScript exists.
+# You can then get a reference to NativeScript for use in `is` checks by calling
+# get_it.
+static func get_it():
+	return NativeScript

addons/gut/gui/GutRunner.gd

@@ -0,0 +1,103 @@
+extends Node2D
+
+var Gut = load("res://addons/gut/gut.gd")
+var ResultExporter = load("res://addons/gut/result_exporter.gd")
+var GutConfig = load("res://addons/gut/gut_config.gd")
+
+const RUNNER_JSON_PATH = "res://.gut_editor_config.json"
+const RESULT_FILE = "user://.gut_editor.bbcode"
+const RESULT_JSON = "user://.gut_editor.json"
+
+var _gut_config = null
+var _gut = null
+var _wrote_results = false
+# Flag for when this is being used at the command line.  Otherwise it is
+# assumed this is being used by the panel and being launched with
+# play_custom_scene
+var _cmdln_mode = false
+
+onready var _gut_layer = $GutLayer
+
+
+func _ready():
+	if _gut_config == null:
+		_gut_config = GutConfig.new()
+		_gut_config.load_options(RUNNER_JSON_PATH)
+
+	# The command line will call run_tests on its own.  When used from the panel
+	# we have to kick off the tests ourselves b/c there's no way I know of to
+	# interact with the scene that was run via play_custom_scene.
+	if !_cmdln_mode:
+		call_deferred("run_tests")
+
+
+func run_tests():
+	if _gut == null:
+		_gut = Gut.new()
+
+	_gut.set_add_children_to(self)
+	if _gut_config.options.gut_on_top:
+		_gut_layer.add_child(_gut)
+	else:
+		add_child(_gut)
+
+	if !_cmdln_mode:
+		_gut.connect(
+			"tests_finished",
+			self,
+			"_on_tests_finished",
+			[_gut_config.options.should_exit, _gut_config.options.should_exit_on_success]
+		)
+
+	_gut_config.config_gut(_gut)
+	if _gut_config.options.gut_on_top:
+		_gut.get_gui().goto_bottom_right_corner()
+
+	var run_rest_of_scripts = _gut_config.options.unit_test_name == ""
+	_gut.test_scripts(run_rest_of_scripts)
+
+
+func _write_results():
+	# bbcode_text appears to be empty.  I'm not 100% sure why.  Until that is
+	# figured out we have to just get the text which stinks.
+	var content = _gut.get_gui().get_text_box().text
+
+	var f = File.new()
+	var result = f.open(RESULT_FILE, f.WRITE)
+	if result == OK:
+		f.store_string(content)
+		f.close()
+	else:
+		print("ERROR Could not save bbcode, result = ", result)
+
+	var exporter = ResultExporter.new()
+	var f_result = exporter.write_summary_file(_gut, RESULT_JSON)
+	_wrote_results = true
+
+
+func _exit_tree():
+	if !_wrote_results and !_cmdln_mode:
+		_write_results()
+
+
+func _on_tests_finished(should_exit, should_exit_on_success):
+	_write_results()
+
+	if should_exit:
+		get_tree().quit()
+	elif should_exit_on_success and _gut.get_fail_count() == 0:
+		get_tree().quit()
+
+
+func get_gut():
+	if _gut == null:
+		_gut = Gut.new()
+	return _gut
+
+
+func set_gut_config(which):
+	_gut_config = which
+
+
+func set_cmdln_mode(is_it):
+	_cmdln_mode = is_it

addons/gut/gui/GutRunner.tscn

@@ -0,0 +1,9 @@
+[gd_scene load_steps=2 format=2]
+
+[ext_resource path="res://addons/gut/gui/GutRunner.gd" type="Script" id=1]
+
+[node name="GutRunner" type="Node2D"]
+script = ExtResource( 1 )
+
+[node name="GutLayer" type="CanvasLayer" parent="."]
+layer = 128

addons/gut/gut_cmdln.gd

@@ -0,0 +1,397 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# Command line interface for the GUT unit testing tool.  Allows you to run tests
+# from the command line instead of running a scene.  Place this script along with
+# gut.gd into your scripts directory at the root of your project.  Once there you
+# can run this script (from the root of your project) using the following command:
+# 	godot -s -d test/gut/gut_cmdln.gd
+#
+# See the readme for a list of options and examples.  You can also use the -gh
+# option to get more information about how to use the command line interface.
+# ##############################################################################
+extends SceneTree
+
+var Optparse = load("res://addons/gut/optparse.gd")
+var Gut = load("res://addons/gut/gut.gd")
+var GutRunner = load("res://addons/gut/gui/GutRunner.tscn")
+
+
+# ------------------------------------------------------------------------------
+# Helper class to resolve the various different places where an option can
+# be set.  Using the get_value method will enforce the order of precedence of:
+# 	1.  command line value
+#	2.  config file value
+#	3.  default value
+#
+# The idea is that you set the base_opts.  That will get you a copies of the
+# hash with null values for the other types of values.  Lower precedented hashes
+# will punch through null values of higher precedented hashes.
+# ------------------------------------------------------------------------------
+class OptionResolver:
+	var base_opts = null
+	var cmd_opts = null
+	var config_opts = null
+
+	func get_value(key):
+		return _nvl(cmd_opts[key], _nvl(config_opts[key], base_opts[key]))
+
+	func set_base_opts(opts):
+		base_opts = opts
+		cmd_opts = _null_copy(opts)
+		config_opts = _null_copy(opts)
+
+	# creates a copy of a hash with all values null.
+	func _null_copy(h):
+		var new_hash = {}
+		for key in h:
+			new_hash[key] = null
+		return new_hash
+
+	func _nvl(a, b):
+		if a == null:
+			return b
+		else:
+			return a
+
+	func _string_it(h):
+		var to_return = ""
+		for key in h:
+			to_return += str("(", key, ":", _nvl(h[key], "NULL"), ")")
+		return to_return
+
+	func to_s():
+		return str(
+			"base:\n",
+			_string_it(base_opts),
+			"\n",
+			"config:\n",
+			_string_it(config_opts),
+			"\n",
+			"cmd:\n",
+			_string_it(cmd_opts),
+			"\n",
+			"resolved:\n",
+			_string_it(get_resolved_values())
+		)
+
+	func get_resolved_values():
+		var to_return = {}
+		for key in base_opts:
+			to_return[key] = get_value(key)
+		return to_return
+
+	func to_s_verbose():
+		var to_return = ""
+		var resolved = get_resolved_values()
+		for key in base_opts:
+			to_return += str(key, "\n")
+			to_return += str("  default: ", _nvl(base_opts[key], "NULL"), "\n")
+			to_return += str("  config:  ", _nvl(config_opts[key], " --"), "\n")
+			to_return += str("  cmd:     ", _nvl(cmd_opts[key], " --"), "\n")
+			to_return += str("  final:   ", _nvl(resolved[key], "NULL"), "\n")
+
+		return to_return
+
+
+# ------------------------------------------------------------------------------
+# Here starts the actual script that uses the Options class to kick off Gut
+# and run your tests.
+# ------------------------------------------------------------------------------
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _gut_config = load("res://addons/gut/gut_config.gd").new()
+# instance of gut
+var _tester = null
+# array of command line options specified
+var _final_opts = []
+
+
+func setup_options(options, font_names):
+	var opts = Optparse.new()
+	opts.set_banner(
+		(
+			"This is the command line interface for the unit testing tool Gut.  With this "
+			+ "interface you can run one or more test scripts from the command line.  In order "
+			+ "for the Gut options to not clash with any other godot options, each option starts "
+			+ 'with a "g".  Also, any option that requires a value will take the form of '
+			+ '"-g<name>=<value>".  There cannot be any spaces between the option, the "=", or '
+			+ "inside a specified value or godot will think you are trying to run a scene."
+		)
+	)
+	opts.add("-gtest", [], "Comma delimited list of full paths to test scripts to run.")
+	opts.add("-gdir", options.dirs, "Comma delimited list of directories to add tests from.")
+	opts.add(
+		"-gprefix",
+		options.prefix,
+		'Prefix used to find tests when specifying -gdir.  Default "[default]".'
+	)
+	opts.add(
+		"-gsuffix",
+		options.suffix,
+		'Suffix used to find tests when specifying -gdir.  Default "[default]".'
+	)
+	opts.add(
+		"-ghide_orphans",
+		false,
+		'Display orphan counts for tests and scripts.  Default "[default]".'
+	)
+	opts.add("-gmaximize", false, "Maximizes test runner window to fit the viewport.")
+	opts.add(
+		"-gcompact_mode", false, "The runner will be in compact mode.  This overrides -gmaximize."
+	)
+	opts.add(
+		"-gexit",
+		false,
+		"Exit after running tests.  If not specified you have to manually close the window."
+	)
+	opts.add("-gexit_on_success", false, "Only exit if all tests pass.")
+	opts.add("-glog", options.log_level, "Log level.  Default [default]")
+	opts.add("-gignore_pause", false, "Ignores any calls to gut.pause_before_teardown.")
+	opts.add(
+		"-gselect",
+		"",
+		(
+			"Select a script to run initially.  The first script that "
+			+ "was loaded using -gtest or -gdir that contains the specified "
+			+ "string will be executed.  You may run others by interacting "
+			+ "with the GUI."
+		)
+	)
+	opts.add(
+		"-gunit_test_name",
+		"",
+		(
+			"Name of a test to run.  Any test that contains the specified "
+			+ "text will be run, all others will be skipped."
+		)
+	)
+	opts.add("-gh", false, "Print this help, then quit")
+	opts.add(
+		"-gconfig",
+		"res://.gutconfig.json",
+		"A config file that contains configuration information.  Default is res://.gutconfig.json"
+	)
+	opts.add("-ginner_class", "", "Only run inner classes that contain this string")
+	opts.add(
+		"-gopacity",
+		options.opacity,
+		"Set opacity of test runner window. Use range 0 - 100. 0 = transparent, 100 = opaque."
+	)
+	opts.add("-gpo", false, "Print option values from all sources and the value used, then quit.")
+	opts.add("-ginclude_subdirs", false, "Include subdirectories of -gdir.")
+	opts.add(
+		"-gdouble_strategy",
+		"partial",
+		'Default strategy to use when doubling.  Valid values are [partial, full].  Default "[default]"'
+	)
+	opts.add("-gdisable_colors", false, "Disable command line colors.")
+	opts.add("-gpre_run_script", "", "pre-run hook script path")
+	opts.add("-gpost_run_script", "", "post-run hook script path")
+	opts.add(
+		"-gprint_gutconfig_sample",
+		false,
+		"Print out json that can be used to make a gutconfig file then quit."
+	)
+
+	opts.add(
+		"-gfont_name",
+		options.font_name,
+		str("Valid values are:  ", font_names, '.  Default "[default]"')
+	)
+	opts.add("-gfont_size", options.font_size, 'Font size, default "[default]"')
+	opts.add(
+		"-gbackground_color",
+		options.background_color,
+		'Background color as an html color, default "[default]"'
+	)
+	opts.add("-gfont_color", options.font_color, 'Font color as an html color, default "[default]"')
+
+	opts.add(
+		"-gjunit_xml_file",
+		options.junit_xml_file,
+		"Export results of run to this file in the Junit XML format."
+	)
+	opts.add(
+		"-gjunit_xml_timestamp",
+		options.junit_xml_timestamp,
+		"Include a timestamp in the -gjunit_xml_file, default [default]"
+	)
+	return opts
+
+
+# Parses options, applying them to the _tester or setting values
+# in the options struct.
+func extract_command_line_options(from, to):
+	to.config_file = from.get_value("-gconfig")
+	to.dirs = from.get_value("-gdir")
+	to.disable_colors = from.get_value("-gdisable_colors")
+	to.double_strategy = from.get_value("-gdouble_strategy")
+	to.ignore_pause = from.get_value("-gignore_pause")
+	to.include_subdirs = from.get_value("-ginclude_subdirs")
+	to.inner_class = from.get_value("-ginner_class")
+	to.log_level = from.get_value("-glog")
+	to.opacity = from.get_value("-gopacity")
+	to.post_run_script = from.get_value("-gpost_run_script")
+	to.pre_run_script = from.get_value("-gpre_run_script")
+	to.prefix = from.get_value("-gprefix")
+	to.selected = from.get_value("-gselect")
+	to.should_exit = from.get_value("-gexit")
+	to.should_exit_on_success = from.get_value("-gexit_on_success")
+	to.should_maximize = from.get_value("-gmaximize")
+	to.compact_mode = from.get_value("-gcompact_mode")
+	to.hide_orphans = from.get_value("-ghide_orphans")
+	to.suffix = from.get_value("-gsuffix")
+	to.tests = from.get_value("-gtest")
+	to.unit_test_name = from.get_value("-gunit_test_name")
+
+	to.font_size = from.get_value("-gfont_size")
+	to.font_name = from.get_value("-gfont_name")
+	to.background_color = from.get_value("-gbackground_color")
+	to.font_color = from.get_value("-gfont_color")
+
+	to.junit_xml_file = from.get_value("-gjunit_xml_file")
+	to.junit_xml_timestamp = from.get_value("-gjunit_xml_timestamp")
+
+
+func _print_gutconfigs(values):
+	var header = """Here is a sample of a full .gutconfig.json file.
+You do not need to specify all values in your own file.  The values supplied in
+this sample are what would be used if you ran gut w/o the -gprint_gutconfig_sample
+option (option priority:  command-line, .gutconfig, default)."""
+	print("\n", header.replace("\n", " "), "\n\n")
+	var resolved = values
+
+	# remove some options that don't make sense to be in config
+	resolved.erase("config_file")
+	resolved.erase("show_help")
+
+	print(
+		"Here's a config with all the properties set based off of your current command and config."
+	)
+	print(JSON.print(resolved, "  "))
+
+	for key in resolved:
+		resolved[key] = null
+
+	print("\n\nAnd here's an empty config for you fill in what you want.")
+	print(JSON.print(resolved, " "))
+
+
+# parse options and run Gut
+func _run_gut():
+	var opt_resolver = OptionResolver.new()
+	opt_resolver.set_base_opts(_gut_config.default_options)
+
+	print("\n\n", " ---  Gut  ---")
+	var o = setup_options(_gut_config.default_options, _gut_config.valid_fonts)
+
+	var all_options_valid = o.parse()
+	extract_command_line_options(o, opt_resolver.cmd_opts)
+
+	var load_result = _gut_config.load_options_no_defaults(opt_resolver.get_value("config_file"))
+
+	# SHORTCIRCUIT
+	if !all_options_valid or load_result == -1:
+		quit(1)
+	else:
+		opt_resolver.config_opts = _gut_config.options
+
+		if o.get_value("-gh"):
+			print(_utils.get_version_text())
+			o.print_help()
+			quit()
+		elif o.get_value("-gpo"):
+			print(
+				(
+					"All command line options and where they are specified.  "
+					+ 'The "final" value shows which value will actually be used '
+					+ "based on order of precedence (default < .gutconfig < cmd line)."
+					+ "\n"
+				)
+			)
+			print(opt_resolver.to_s_verbose())
+			quit()
+		elif o.get_value("-gprint_gutconfig_sample"):
+			_print_gutconfigs(opt_resolver.get_resolved_values())
+			quit()
+		else:
+			_final_opts = opt_resolver.get_resolved_values()
+			_gut_config.options = _final_opts
+
+			var runner = GutRunner.instance()
+			runner.set_cmdln_mode(true)
+			runner.set_gut_config(_gut_config)
+
+			_tester = runner.get_gut()
+			_tester.connect(
+				"tests_finished",
+				self,
+				"_on_tests_finished",
+				[_final_opts.should_exit, _final_opts.should_exit_on_success]
+			)
+
+			get_root().add_child(runner)
+			runner.run_tests()
+
+
+# exit if option is set.
+func _on_tests_finished(should_exit, should_exit_on_success):
+	if _final_opts.dirs.size() == 0:
+		if _tester.get_summary().get_totals().scripts == 0:
+			var lgr = _tester.get_logger()
+			lgr.error(
+				"No directories configured.  Add directories with options or a .gutconfig.json file.  Use the -gh option for more information."
+			)
+
+	if _tester.get_fail_count():
+		OS.exit_code = 1
+
+	# Overwrite the exit code with the post_script
+	var post_inst = _tester.get_post_run_script_instance()
+	if post_inst != null and post_inst.get_exit_code() != null:
+		OS.exit_code = post_inst.get_exit_code()
+
+	if should_exit or (should_exit_on_success and _tester.get_fail_count() == 0):
+		quit()
+	else:
+		print("Tests finished, exit manually")
+
+
+# ------------------------------------------------------------------------------
+# MAIN
+# ------------------------------------------------------------------------------
+func _init():
+	if !_utils.is_version_ok():
+		print("\n\n", _utils.get_version_text())
+		push_error(_utils.get_bad_version_text())
+		OS.exit_code = 1
+		quit()
+	else:
+		_run_gut()

addons/gut/gut_config.gd

@@ -0,0 +1,172 @@
+var Gut = load("res://addons/gut/gut.gd")
+
+# Do not want a ref to _utils here due to use by editor plugin.
+# _utils needs to be split so that constants and what not do not
+# have to rely on the weird singleton thing I made.
+enum DOUBLE_STRATEGY { FULL, PARTIAL }
+
+var valid_fonts = ["AnonymousPro", "CourierPro", "LobsterTwo", "Default"]
+var default_options = {
+	background_color = Color(.15, .15, .15, 1).to_html(),
+	config_file = "res://.gutconfig.json",
+	dirs = [],
+	disable_colors = false,
+	double_strategy = "partial",
+	font_color = Color(.8, .8, .8, 1).to_html(),
+	font_name = "CourierPrime",
+	font_size = 16,
+	hide_orphans = false,
+	ignore_pause = false,
+	include_subdirs = false,
+	inner_class = "",
+	junit_xml_file = "",
+	junit_xml_timestamp = false,
+	log_level = 1,
+	opacity = 100,
+	post_run_script = "",
+	pre_run_script = "",
+	prefix = "test_",
+	selected = "",
+	should_exit = false,
+	should_exit_on_success = false,
+	should_maximize = false,
+	compact_mode = false,
+	show_help = false,
+	suffix = ".gd",
+	tests = [],
+	unit_test_name = "",
+	gut_on_top = true,
+}
+
+var default_panel_options = {font_name = "CourierPrime", font_size = 30}
+
+var options = default_options.duplicate()
+
+
+func _null_copy(h):
+	var new_hash = {}
+	for key in h:
+		new_hash[key] = null
+	return new_hash
+
+
+func _load_options_from_config_file(file_path, into):
+	# SHORTCIRCUIT
+	var f = File.new()
+	if !f.file_exists(file_path):
+		if file_path != "res://.gutconfig.json":
+			print('ERROR:  Config File "', file_path, '" does not exist.')
+			return -1
+		else:
+			return 1
+
+	var result = f.open(file_path, f.READ)
+	if result != OK:
+		push_error(str("Could not load data ", file_path, " ", result))
+		return result
+
+	var json = f.get_as_text()
+	f.close()
+
+	var results = JSON.parse(json)
+	# SHORTCIRCUIT
+	if results.error != OK:
+		print("\n\n", "!! ERROR parsing file:  ", file_path)
+		print("    at line ", results.error_line, ":")
+		print("    ", results.error_string)
+		return -1
+
+	# Get all the options out of the config file using the option name.  The
+	# options hash is now the default source of truth for the name of an option.
+	for key in into:
+		if results.result.has(key):
+			if results.result[key] != null:
+				into[key] = results.result[key]
+
+	return 1
+
+
+func write_options(path):
+	var content = JSON.print(options, " ")
+
+	var f = File.new()
+	var result = f.open(path, f.WRITE)
+	if result == OK:
+		f.store_string(content)
+		f.close()
+	return result
+
+
+# Apply all the options specified to _tester.  This is where the rubber meets
+# the road.
+func _apply_options(opts, _tester):
+	_tester.set_yield_between_tests(true)
+	_tester.set_modulate(Color(1.0, 1.0, 1.0, min(1.0, float(opts.opacity) / 100)))
+	_tester.show()
+
+	_tester.set_include_subdirectories(opts.include_subdirs)
+
+	if opts.should_maximize:
+		_tester.maximize()
+
+	if opts.compact_mode:
+		_tester.get_gui().compact_mode(true)
+
+	if opts.inner_class != "":
+		_tester.set_inner_class_name(opts.inner_class)
+	_tester.set_log_level(opts.log_level)
+	_tester.set_ignore_pause_before_teardown(opts.ignore_pause)
+
+	for i in range(opts.dirs.size()):
+		_tester.add_directory(opts.dirs[i], opts.prefix, opts.suffix)
+
+	for i in range(opts.tests.size()):
+		_tester.add_script(opts.tests[i])
+
+	if opts.selected != "":
+		_tester.select_script(opts.selected)
+		# _run_single = true
+
+	if opts.double_strategy == "full":
+		_tester.set_double_strategy(DOUBLE_STRATEGY.FULL)
+	elif opts.double_strategy == "partial":
+		_tester.set_double_strategy(DOUBLE_STRATEGY.PARTIAL)
+
+	_tester.set_unit_test_name(opts.unit_test_name)
+	_tester.set_pre_run_script(opts.pre_run_script)
+	_tester.set_post_run_script(opts.post_run_script)
+	_tester.set_color_output(!opts.disable_colors)
+	_tester.show_orphans(!opts.hide_orphans)
+	_tester.set_junit_xml_file(opts.junit_xml_file)
+	_tester.set_junit_xml_timestamp(opts.junit_xml_timestamp)
+
+	_tester.get_gui().set_font_size(opts.font_size)
+	_tester.get_gui().set_font(opts.font_name)
+	if opts.font_color != null and opts.font_color.is_valid_html_color():
+		_tester.get_gui().set_default_font_color(Color(opts.font_color))
+	if opts.background_color != null and opts.background_color.is_valid_html_color():
+		_tester.get_gui().set_background_color(Color(opts.background_color))
+
+	return _tester
+
+
+func config_gut(gut):
+	return _apply_options(options, gut)
+
+
+func load_options(path):
+	return _load_options_from_config_file(path, options)
+
+
+func load_panel_options(path):
+	options["panel_options"] = default_panel_options.duplicate()
+	return _load_options_from_config_file(path, options)
+
+
+func load_options_no_defaults(path):
+	options = _null_copy(default_options)
+	return _load_options_from_config_file(path, options)
+
+
+func apply_options(gut):
+	_apply_options(options, gut)

addons/gut/hook_script.gd

@@ -0,0 +1,47 @@
+class_name GutHookScript
+# ------------------------------------------------------------------------------
+# This script is the base for custom scripts to be used in pre and post
+# run hooks.
+#
+# To use, inherit from this script and then implement the run method.
+# ------------------------------------------------------------------------------
+var JunitXmlExport = load("res://addons/gut/junit_xml_export.gd")
+
+# This is the instance of GUT that is running the tests.  You can get
+# information about the run from this object.  This is set by GUT when the
+# script is instantiated.
+var gut = null
+
+# the exit code to be used by gut_cmdln.  See set method.
+var _exit_code = null
+
+var _should_abort = false
+
+
+# Virtual method that will be called by GUT after instantiating
+# this script.
+func run():
+	gut.get_logger().error(
+		"Run method not overloaded.  Create a 'run()' method in your hook script to run your code."
+	)
+
+
+# Set the exit code when running from the command line.  If not set then the
+# default exit code will be returned (0 when no tests fail, 1 when any tests
+# fail).
+func set_exit_code(code):
+	_exit_code = code
+
+
+func get_exit_code():
+	return _exit_code
+
+
+# Usable by pre-run script to cause the run to end AFTER the run() method
+# finishes.  post-run script will not be ran.
+func abort():
+	_should_abort = true
+
+
+func should_abort():
+	return _should_abort

addons/gut/icon.png.import

@@ -0,0 +1,35 @@
+[remap]
+
+importer="texture"
+type="StreamTexture"
+path="res://.import/icon.png-91b084043b8aaf2f1c906e7b9fa92969.stex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://addons/gut/icon.png"
+dest_files=[ "res://.import/icon.png-91b084043b8aaf2f1c906e7b9fa92969.stex" ]
+
+[params]
+
+compress/mode=0
+compress/lossy_quality=0.7
+compress/hdr_mode=0
+compress/bptc_ldr=0
+compress/normal_map=0
+flags/repeat=0
+flags/filter=true
+flags/mipmaps=false
+flags/anisotropic=false
+flags/srgb=2
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/HDR_as_SRGB=false
+process/invert_color=false
+process/normal_map_invert_y=false
+stream=false
+size_limit=0
+detect_3d=true
+svg/scale=1.0

addons/gut/input_factory.gd

@@ -0,0 +1,140 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# ##############################################################################
+
+# Implemented InputEvent* convenience methods
+# 	InputEventAction
+# 	InputEventKey
+# 	InputEventMouseButton
+# 	InputEventMouseMotion
+
+# Yet to implement InputEvents
+# 	InputEventJoypadButton
+# 	InputEventJoypadMotion
+# 	InputEventMagnifyGesture
+# 	InputEventMIDI
+# 	InputEventPanGesture
+# 	InputEventScreenDrag
+# 	InputEventScreenTouch
+
+static func _to_scancode(which):
+	var key_code = which
+	if typeof(key_code) == TYPE_STRING:
+		key_code = key_code.to_upper().to_ascii()[0]
+	return key_code
+
+
+static func new_mouse_button_event(position, global_position, pressed, button_index):
+	var event = InputEventMouseButton.new()
+	event.position = position
+	if global_position != null:
+		event.global_position = global_position
+	event.pressed = pressed
+	event.button_index = button_index
+
+	return event
+
+
+static func key_up(which):
+	var event = InputEventKey.new()
+	event.scancode = _to_scancode(which)
+	event.pressed = false
+	return event
+
+
+static func key_down(which):
+	var event = InputEventKey.new()
+	event.scancode = _to_scancode(which)
+	event.pressed = true
+	return event
+
+
+static func action_up(which, strength = 1.0):
+	var event = InputEventAction.new()
+	event.action = which
+	event.strength = strength
+	return event
+
+
+static func action_down(which, strength = 1.0):
+	var event = InputEventAction.new()
+	event.action = which
+	event.strength = strength
+	event.pressed = true
+	return event
+
+
+static func mouse_left_button_down(position, global_position = null):
+	var event = new_mouse_button_event(position, global_position, true, BUTTON_LEFT)
+	return event
+
+
+static func mouse_left_button_up(position, global_position = null):
+	var event = new_mouse_button_event(position, global_position, false, BUTTON_LEFT)
+	return event
+
+
+static func mouse_double_click(position, global_position = null):
+	var event = new_mouse_button_event(position, global_position, false, BUTTON_LEFT)
+	event.doubleclick = true
+	return event
+
+
+static func mouse_right_button_down(position, global_position = null):
+	var event = new_mouse_button_event(position, global_position, true, BUTTON_RIGHT)
+	return event
+
+
+static func mouse_right_button_up(position, global_position = null):
+	var event = new_mouse_button_event(position, global_position, false, BUTTON_RIGHT)
+	return event
+
+
+static func mouse_motion(position, global_position = null):
+	var event = InputEventMouseMotion.new()
+	event.position = position
+	if global_position != null:
+		event.global_position = global_position
+	return event
+
+
+static func mouse_relative_motion(offset, last_motion_event = null, speed = Vector2(0, 0)):
+	var event = null
+	if last_motion_event == null:
+		event = mouse_motion(offset)
+		event.speed = speed
+	else:
+		event = last_motion_event.duplicate()
+		event.position += offset
+		event.global_position += offset
+		event.relative = offset
+		event.speed = speed
+	return event

addons/gut/input_sender.gd

@@ -0,0 +1,391 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# This class sends input to one or more recievers.  The receivers' _input,
+# _unhandled_input, and _gui_input are called sending InputEvent* events.
+# InputEvents can be sent via the helper methods or a custom made InputEvent
+# can be sent via send_event(...)
+#
+# ##############################################################################
+#extends "res://addons/gut/input_factory.gd"
+
+# Implemented InputEvent* convenience methods
+# 	InputEventAction
+# 	InputEventKey
+# 	InputEventMouseButton
+#	InputEventMouseMotion
+
+# Yet to implement InputEvents
+# 	InputEventJoypadButton
+# 	InputEventJoypadMotion
+# 	InputEventMagnifyGesture
+# 	InputEventMIDI
+# 	InputEventPanGesture
+# 	InputEventScreenDrag
+# 	InputEventScreenTouch
+
+class InputQueueItem:
+	extends Node
+
+	var events = []
+	var time_delay = null
+	var frame_delay = null
+	var _waited_frames = 0
+	var _is_ready = false
+	var _delay_started = false
+
+	signal event_ready
+
+	# TODO should this be done in _physics_process instead or should it be
+	# configurable?
+	func _physics_process(delta):
+		if frame_delay > 0 and _delay_started:
+			_waited_frames += 1
+			if _waited_frames >= frame_delay:
+				emit_signal("event_ready")
+
+	func _init(t_delay, f_delay):
+		time_delay = t_delay
+		frame_delay = f_delay
+		_is_ready = time_delay == 0 and frame_delay == 0
+
+	func _on_time_timeout():
+		_is_ready = true
+		emit_signal("event_ready")
+
+	func _delay_timer(t):
+		return Engine.get_main_loop().root.get_tree().create_timer(t)
+
+	func is_ready():
+		return _is_ready
+
+	func start():
+		_delay_started = true
+		if time_delay > 0:
+			var t = _delay_timer(time_delay)
+			t.connect("timeout", self, "_on_time_timeout")
+
+
+# ##############################################################################
+#
+# ##############################################################################
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var InputFactory = load("res://addons/gut/input_factory.gd")
+
+const INPUT_WARN = "If using Input as a reciever it will not respond to *_down events until a *_up event is recieved.  Call the appropriate *_up event or use .hold_for(...) to automatically release after some duration."
+
+var _lgr = _utils.get_logger()
+var _receivers = []
+var _input_queue = []
+var _next_queue_item = null
+# used by mouse_relative_motion.  These use this instead of _last_event since
+# it is logical to have a series of events happen between mouse motions.
+var _last_mouse_motion = null
+# used by hold_for and echo.
+var _last_event = null
+
+# indexed by scancode, each entry contains a boolean value indicating the
+# last emitted "pressed" value for that scancode.
+var _pressed_keys = {}
+var _pressed_actions = {}
+var _pressed_mouse_buttons = {}
+
+signal idle
+
+
+func _init(r = null):
+	if r != null:
+		add_receiver(r)
+
+
+func _send_event(event):
+	if event is InputEventKey:
+		if (event.pressed and !event.echo) and is_key_pressed(event.scancode):
+			_lgr.warn(
+				str(
+					"InputSender:  key_down called for ",
+					event.as_text(),
+					" when that key is already pressed.  ",
+					INPUT_WARN
+				)
+			)
+		_pressed_keys[event.scancode] = event.pressed
+	elif event is InputEventAction:
+		if event.pressed and is_action_pressed(event.action):
+			_lgr.warn(
+				str(
+					"InputSender:  action_down called for ",
+					event.action,
+					" when that action is already pressed.  ",
+					INPUT_WARN
+				)
+			)
+		_pressed_actions[event.action] = event.pressed
+	elif event is InputEventMouseButton:
+		if event.pressed and is_mouse_button_pressed(event.button_index):
+			_lgr.warn(
+				str(
+					"InputSender:  mouse_button_down called for ",
+					event.button_index,
+					" when that mouse button is already pressed.  ",
+					INPUT_WARN
+				)
+			)
+		_pressed_mouse_buttons[event.button_index] = event
+
+	for r in _receivers:
+		if r == Input:
+			Input.parse_input_event(event)
+		else:
+			if r.has_method("_input"):
+				r._input(event)
+
+			if r.has_method("_gui_input"):
+				r._gui_input(event)
+
+			if r.has_method("_unhandled_input"):
+				r._unhandled_input(event)
+
+
+func _send_or_record_event(event):
+	_last_event = event
+	if _next_queue_item != null:
+		_next_queue_item.events.append(event)
+	else:
+		_send_event(event)
+
+
+func _on_queue_item_ready(item):
+	for event in item.events:
+		_send_event(event)
+
+	var done_event = _input_queue.pop_front()
+	done_event.queue_free()
+
+	if _input_queue.size() == 0:
+		_next_queue_item = null
+		emit_signal("idle")
+	else:
+		_input_queue[0].start()
+
+
+func _add_queue_item(item):
+	item.connect("event_ready", self, "_on_queue_item_ready", [item])
+	_next_queue_item = item
+	_input_queue.append(item)
+	Engine.get_main_loop().root.add_child(item)
+	if _input_queue.size() == 1:
+		item.start()
+
+
+func add_receiver(obj):
+	_receivers.append(obj)
+
+
+func get_receivers():
+	return _receivers
+
+
+func wait(t):
+	if typeof(t) == TYPE_STRING:
+		var suffix = t.substr(t.length() - 1, 1)
+		var val = float(t.rstrip("s").rstrip("f"))
+
+		if suffix.to_lower() == "s":
+			wait_secs(val)
+		elif suffix.to_lower() == "f":
+			wait_frames(val)
+	else:
+		wait_secs(t)
+
+	return self
+
+
+func wait_frames(num_frames):
+	var item = InputQueueItem.new(0, num_frames)
+	_add_queue_item(item)
+	return self
+
+
+func wait_secs(num_secs):
+	var item = InputQueueItem.new(num_secs, 0)
+	_add_queue_item(item)
+	return self
+
+
+# ------------------------------
+# Event methods
+# ------------------------------
+func key_up(which):
+	var event = InputFactory.key_up(which)
+	_send_or_record_event(event)
+	return self
+
+
+func key_down(which):
+	var event = InputFactory.key_down(which)
+	_send_or_record_event(event)
+	return self
+
+
+func key_echo():
+	if _last_event != null and _last_event is InputEventKey:
+		var new_key = _last_event.duplicate()
+		new_key.echo = true
+		_send_or_record_event(new_key)
+	return self
+
+
+func action_up(which, strength = 1.0):
+	var event = InputFactory.action_up(which, strength)
+	_send_or_record_event(event)
+	return self
+
+
+func action_down(which, strength = 1.0):
+	var event = InputFactory.action_down(which, strength)
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_left_button_down(position, global_position = null):
+	var event = InputFactory.mouse_left_button_down(position, global_position)
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_left_button_up(position, global_position = null):
+	var event = InputFactory.mouse_left_button_up(position, global_position)
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_double_click(position, global_position = null):
+	var event = InputFactory.mouse_double_click(position, global_position)
+	event.doubleclick = true
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_right_button_down(position, global_position = null):
+	var event = InputFactory.mouse_right_button_down(position, global_position)
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_right_button_up(position, global_position = null):
+	var event = InputFactory.mouse_right_button_up(position, global_position)
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_motion(position, global_position = null):
+	var event = InputFactory.mouse_motion(position, global_position)
+	_last_mouse_motion = event
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_relative_motion(offset, speed = Vector2(0, 0)):
+	var event = InputFactory.mouse_relative_motion(offset, _last_mouse_motion, speed)
+	_last_mouse_motion = event
+	_send_or_record_event(event)
+	return self
+
+
+func mouse_set_position(position, global_position = null):
+	_last_mouse_motion = InputFactory.mouse_motion(position, global_position)
+	return self
+
+
+func send_event(event):
+	_send_or_record_event(event)
+	return self
+
+
+func release_all():
+	for key in _pressed_keys:
+		if _pressed_keys[key]:
+			_send_event(InputFactory.key_up(key))
+	_pressed_keys.clear()
+
+	for key in _pressed_actions:
+		if _pressed_actions[key]:
+			_send_event(InputFactory.action_up(key))
+	_pressed_actions.clear()
+
+	for key in _pressed_mouse_buttons:
+		var event = _pressed_mouse_buttons[key].duplicate()
+		if event.pressed:
+			event.pressed = false
+			_send_event(event)
+	_pressed_mouse_buttons.clear()
+
+
+func hold_for(duration):
+	if _last_event != null and _last_event.pressed:
+		var next_event = _last_event.duplicate()
+		next_event.pressed = false
+		wait(duration)
+		send_event(next_event)
+	return self
+
+
+func clear():
+	pass
+
+	_last_event = null
+	_last_mouse_motion = null
+	_next_queue_item = null
+
+	for item in _input_queue:
+		item.free()
+	_input_queue.clear()
+
+	_pressed_keys.clear()
+	_pressed_actions.clear()
+	_pressed_mouse_buttons.clear()
+
+
+func is_idle():
+	return _input_queue.size() == 0
+
+
+func is_key_pressed(which):
+	var event = InputFactory.key_up(which)
+	return _pressed_keys.has(event.scancode) and _pressed_keys[event.scancode]
+
+
+func is_action_pressed(which):
+	return _pressed_actions.has(which) and _pressed_actions[which]
+
+
+func is_mouse_button_pressed(which):
+	return _pressed_mouse_buttons.has(which) and _pressed_mouse_buttons[which]

addons/gut/junit_xml_export.gd

@@ -0,0 +1,95 @@
+# ------------------------------------------------------------------------------
+# Creates an export of a test run in the JUnit XML format.
+# ------------------------------------------------------------------------------
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+
+var _exporter = _utils.ResultExporter.new()
+
+
+func indent(s, ind):
+	var to_return = ind + s
+	to_return = to_return.replace("\n", "\n" + ind)
+	return to_return
+
+
+func add_attr(name, value):
+	return str(name, '="', value, '" ')
+
+
+func _export_test_result(test):
+	var to_return = ""
+
+	# Right now the pending and failure messages won't fit in the message
+	# attribute because they can span multiple lines and need to be escaped.
+	if test.status == "pending":
+		var skip_tag = str('<skipped message="pending">', test.pending[0], "</skipped>")
+		to_return += skip_tag
+	elif test.status == "fail":
+		var fail_tag = str('<failure message="failed">', test.failing[0], "</failure>")
+		to_return += fail_tag
+
+	return to_return
+
+
+func _export_tests(script_result, classname):
+	var to_return = ""
+
+	for key in script_result.keys():
+		var test = script_result[key]
+		var assert_count = test.passing.size() + test.failing.size()
+		to_return += "<testcase "
+		to_return += add_attr("name", key)
+		to_return += add_attr("assertions", assert_count)
+		to_return += add_attr("status", test.status)
+		to_return += add_attr("classname", classname)
+		to_return += ">\n"
+
+		to_return += _export_test_result(test)
+
+		to_return += "</testcase>\n"
+
+	return to_return
+
+
+func _export_scripts(exp_results):
+	var to_return = ""
+	for key in exp_results.test_scripts.scripts.keys():
+		var s = exp_results.test_scripts.scripts[key]
+		to_return += "<testsuite "
+		to_return += add_attr("name", key)
+		to_return += add_attr("tests", s.props.tests)
+		to_return += add_attr("failures", s.props.failures)
+		to_return += add_attr("skipped", s.props.pending)
+		to_return += ">\n"
+
+		to_return += indent(_export_tests(s.tests, key), "    ")
+
+		to_return += "</testsuite>\n"
+
+	return to_return
+
+
+func get_results_xml(gut):
+	var exp_results = _exporter.get_results_dictionary(gut)
+	var to_return = '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+	to_return += "<testsuites "
+	to_return += add_attr("name", "GutTests")
+	to_return += add_attr("failures", exp_results.test_scripts.props.failures)
+	to_return += add_attr("tests", exp_results.test_scripts.props.tests)
+	to_return += ">\n"
+
+	to_return += indent(_export_scripts(exp_results), "  ")
+
+	to_return += "</testsuites>"
+	return to_return
+
+
+func write_file(gut, path):
+	var xml = get_results_xml(gut)
+
+	var f_result = _utils.write_file(path, xml)
+	if f_result != OK:
+		var msg = str("Error:  ", f_result, ".  Could not create export file ", path)
+		_utils.get_logger().error(msg)
+
+	return f_result

addons/gut/logger.gd

@@ -0,0 +1,391 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# This class wraps around the various printers and supplies formatting for the
+# various message types (error, warning, etc).
+# ##############################################################################
+var types = {
+	debug = "debug",
+	deprecated = "deprecated",
+	error = "error",
+	failed = "failed",
+	info = "info",
+	normal = "normal",
+	orphan = "orphan",
+	passed = "passed",
+	pending = "pending",
+	warn = "warn",
+}
+
+var fmts = {
+	red = "red",
+	yellow = "yellow",
+	green = "green",
+	bold = "bold",
+	underline = "underline",
+	none = null
+}
+
+var _type_data = {
+	types.debug: {disp = "DEBUG", enabled = true, fmt = fmts.none},
+	types.deprecated: {disp = "DEPRECATED", enabled = true, fmt = fmts.none},
+	types.error: {disp = "ERROR", enabled = true, fmt = fmts.red},
+	types.failed: {disp = "Failed", enabled = true, fmt = fmts.red},
+	types.info: {disp = "INFO", enabled = true, fmt = fmts.bold},
+	types.normal: {disp = "NORMAL", enabled = true, fmt = fmts.none},
+	types.orphan: {disp = "Orphans", enabled = true, fmt = fmts.yellow},
+	types.passed: {disp = "Passed", enabled = true, fmt = fmts.green},
+	types.pending: {disp = "Pending", enabled = true, fmt = fmts.yellow},
+	types.warn: {disp = "WARNING", enabled = true, fmt = fmts.yellow},
+}
+
+var _logs = {
+	types.warn: [],
+	types.error: [],
+	types.info: [],
+	types.debug: [],
+	types.deprecated: [],
+}
+
+var _printers = {terminal = null, gui = null, console = null}
+
+var _gut = null
+var _utils = null
+var _indent_level = 0
+var _indent_string = "    "
+var _skip_test_name_for_testing = false
+var _less_test_names = false
+var _yield_calls = 0
+var _last_yield_text = ""
+
+
+func _init():
+	_utils = load("res://addons/gut/utils.gd").get_instance()
+	_printers.terminal = _utils.Printers.TerminalPrinter.new()
+	_printers.console = _utils.Printers.ConsolePrinter.new()
+	# There were some problems in the timing of disabling this at the right
+	# time in gut_cmdln so it is disabled by default.  This is enabled
+	# by plugin_control.gd based on settings.
+	_printers.console.set_disabled(true)
+
+
+func get_indent_text():
+	var pad = ""
+	for i in range(_indent_level):
+		pad += _indent_string
+
+	return pad
+
+
+func _indent_text(text):
+	var to_return = text
+	var ending_newline = ""
+
+	if text.ends_with("\n"):
+		ending_newline = "\n"
+		to_return = to_return.left(to_return.length() - 1)
+
+	var pad = get_indent_text()
+	to_return = to_return.replace("\n", "\n" + pad)
+	to_return += ending_newline
+
+	return pad + to_return
+
+
+func _should_print_to_printer(key_name):
+	return _printers[key_name] != null and !_printers[key_name].get_disabled()
+
+
+func _print_test_name():
+	if _gut == null:
+		return
+	var cur_test = _gut.get_current_test_object()
+	if cur_test == null:
+		return false
+
+	if !cur_test.has_printed_name:
+		_output("* " + cur_test.name + "\n")
+		cur_test.has_printed_name = true
+
+
+func _output(text, fmt = null):
+	for key in _printers:
+		if _should_print_to_printer(key):
+			var info = ""  #str(self, ':', key, ':', _printers[key], '|  ')
+			_printers[key].send(info + text, fmt)
+
+
+func _log(text, fmt = fmts.none):
+	_print_test_name()
+	var indented = _indent_text(text)
+	_output(indented, fmt)
+
+
+# ---------------
+# Get Methods
+# ---------------
+func get_warnings():
+	return get_log_entries(types.warn)
+
+
+func get_errors():
+	return get_log_entries(types.error)
+
+
+func get_infos():
+	return get_log_entries(types.info)
+
+
+func get_debugs():
+	return get_log_entries(types.debug)
+
+
+func get_deprecated():
+	return get_log_entries(types.deprecated)
+
+
+func get_count(log_type = null):
+	var count = 0
+	if log_type == null:
+		for key in _logs:
+			count += _logs[key].size()
+	else:
+		count = _logs[log_type].size()
+	return count
+
+
+func get_log_entries(log_type):
+	return _logs[log_type]
+
+
+# ---------------
+# Log methods
+# ---------------
+func _output_type(type, text):
+	var td = _type_data[type]
+	if !td.enabled:
+		return
+
+	_print_test_name()
+	if type != types.normal:
+		if _logs.has(type):
+			_logs[type].append(text)
+
+		var start = str("[", td.disp, "]")
+		if text != null and text != "":
+			start += ":  "
+		else:
+			start += " "
+		var indented_start = _indent_text(start)
+		var indented_end = _indent_text(text)
+		indented_end = indented_end.lstrip(_indent_string)
+		_output(indented_start, td.fmt)
+		_output(indented_end + "\n")
+
+
+func debug(text):
+	_output_type(types.debug, text)
+
+
+# supply some text or the name of the deprecated method and the replacement.
+func deprecated(text, alt_method = null):
+	var msg = text
+	if alt_method:
+		msg = str("The method ", text, " is deprecated, use ", alt_method, " instead.")
+	return _output_type(types.deprecated, msg)
+
+
+func error(text):
+	_output_type(types.error, text)
+
+
+func failed(text):
+	_output_type(types.failed, text)
+
+
+func info(text):
+	_output_type(types.info, text)
+
+
+func orphan(text):
+	_output_type(types.orphan, text)
+
+
+func passed(text):
+	_output_type(types.passed, text)
+
+
+func pending(text):
+	_output_type(types.pending, text)
+
+
+func warn(text):
+	_output_type(types.warn, text)
+
+
+func log(text = "", fmt = fmts.none):
+	end_yield()
+	if text == "":
+		_output("\n")
+	else:
+		_log(text + "\n", fmt)
+	return null
+
+
+func lograw(text, fmt = fmts.none):
+	return _output(text, fmt)
+
+
+# Print the test name if we aren't skipping names of tests that pass (basically
+# what _less_test_names means))
+func log_test_name():
+	# suppress output if we haven't printed the test name yet and
+	# what to print is the test name.
+	if !_less_test_names:
+		_print_test_name()
+
+
+# ---------------
+# Misc
+# ---------------
+func get_gut():
+	return _gut
+
+
+func set_gut(gut):
+	_gut = gut
+	if _gut == null:
+		_printers.gui = null
+	else:
+		if _printers.gui == null:
+			_printers.gui = _utils.Printers.GutGuiPrinter.new()
+		_printers.gui.set_gut(gut)
+
+
+func get_indent_level():
+	return _indent_level
+
+
+func set_indent_level(indent_level):
+	_indent_level = indent_level
+
+
+func get_indent_string():
+	return _indent_string
+
+
+func set_indent_string(indent_string):
+	_indent_string = indent_string
+
+
+func clear():
+	for key in _logs:
+		_logs[key].clear()
+
+
+func inc_indent():
+	_indent_level += 1
+
+
+func dec_indent():
+	_indent_level = max(0, _indent_level - 1)
+
+
+func is_type_enabled(type):
+	return _type_data[type].enabled
+
+
+func set_type_enabled(type, is_enabled):
+	_type_data[type].enabled = is_enabled
+
+
+func get_less_test_names():
+	return _less_test_names
+
+
+func set_less_test_names(less_test_names):
+	_less_test_names = less_test_names
+
+
+func disable_printer(name, is_disabled):
+	_printers[name].set_disabled(is_disabled)
+
+
+func is_printer_disabled(name):
+	return _printers[name].get_disabled()
+
+
+func disable_formatting(is_disabled):
+	for key in _printers:
+		_printers[key].set_format_enabled(!is_disabled)
+
+
+func get_printer(printer_key):
+	return _printers[printer_key]
+
+
+func _yield_text_terminal(text):
+	var printer = _printers["terminal"]
+	if _yield_calls != 0:
+		printer.clear_line()
+		printer.back(_last_yield_text.length())
+	printer.send(text, fmts.yellow)
+
+
+func _end_yield_terminal():
+	var printer = _printers["terminal"]
+	printer.clear_line()
+	printer.back(_last_yield_text.length())
+
+
+func _yield_text_gui(text):
+	var lbl = _gut.get_gui().get_waiting_label()
+	lbl.visible = true
+	lbl.set_bbcode("[color=yellow]" + text + "[/color]")
+
+
+func _end_yield_gui():
+	var lbl = _gut.get_gui().get_waiting_label()
+	lbl.visible = false
+	lbl.set_text("")
+
+
+func yield_text(text):
+	_yield_text_terminal(text)
+	_yield_text_gui(text)
+	_last_yield_text = text
+	_yield_calls += 1
+
+
+func end_yield():
+	if _yield_calls == 0:
+		return
+	_end_yield_terminal()
+	_end_yield_gui()
+	_yield_calls = 0
+	_last_yield_text = ""

addons/gut/method_maker.gd

@@ -0,0 +1,299 @@
+class CallParameters:
+	var p_name = null
+	var default = null
+
+	func _init(n, d):
+		p_name = n
+		default = d
+
+
+# ------------------------------------------------------------------------------
+# This class will generate method declaration lines based on method meta
+# data.  It will create defaults that match the method data.
+#
+# --------------------
+# function meta data
+# --------------------
+# name:
+# flags:
+# args: [{
+# 	(class_name:),
+# 	(hint:0),
+# 	(hint_string:),
+# 	(name:),
+# 	(type:4),
+# 	(usage:7)
+# }]
+# default_args []
+
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _lgr = _utils.get_logger()
+const PARAM_PREFIX = "p_"
+
+# ------------------------------------------------------
+# _supported_defaults
+#
+# This array contains all the data types that are supported for default values.
+# If a value is supported it will contain either an empty string or a prefix
+# that should be used when setting the parameter default value.
+# For example int, real, bool do not need anything func(p1=1, p2=2.2, p3=false)
+# but things like Vectors and Colors do since only the parameters to create a
+# new Vector or Color are included in the metadata.
+# ------------------------------------------------------
+# TYPE_NIL = 0 — Variable is of type nil (only applied for null).
+# TYPE_BOOL = 1 — Variable is of type bool.
+# TYPE_INT = 2 — Variable is of type int.
+# TYPE_REAL = 3 — Variable is of type float/real.
+# TYPE_STRING = 4 — Variable is of type String.
+# TYPE_VECTOR2 = 5 — Variable is of type Vector2.
+# TYPE_RECT2 = 6 — Variable is of type Rect2.
+# TYPE_VECTOR3 = 7 — Variable is of type Vector3.
+# TYPE_COLOR = 14 — Variable is of type Color.
+# TYPE_OBJECT = 17 — Variable is of type Object.
+# TYPE_DICTIONARY = 18 — Variable is of type Dictionary.
+# TYPE_ARRAY = 19 — Variable is of type Array.
+# TYPE_VECTOR2_ARRAY = 24 — Variable is of type PoolVector2Array.
+# TYPE_TRANSFORM = 13 — Variable is of type Transform.
+# TYPE_TRANSFORM2D = 8 — Variable is of type Transform2D.
+# TYPE_RID = 16 — Variable is of type RID.
+# TYPE_INT_ARRAY = 21 — Variable is of type PoolIntArray.
+# TYPE_REAL_ARRAY = 22 — Variable is of type PoolRealArray.
+
+# TYPE_PLANE = 9 — Variable is of type Plane.
+# TYPE_QUAT = 10 — Variable is of type Quat.
+# TYPE_AABB = 11 — Variable is of type AABB.
+# TYPE_BASIS = 12 — Variable is of type Basis.
+# TYPE_NODE_PATH = 15 — Variable is of type NodePath.
+# TYPE_RAW_ARRAY = 20 — Variable is of type PoolByteArray.
+# TYPE_STRING_ARRAY = 23 — Variable is of type PoolStringArray.
+# TYPE_VECTOR3_ARRAY = 25 — Variable is of type PoolVector3Array.
+# TYPE_COLOR_ARRAY = 26 — Variable is of type PoolColorArray.
+# TYPE_MAX = 27 — Marker for end of type constants.
+# ------------------------------------------------------
+var _supported_defaults = []
+
+
+func _init():
+	for _i in range(TYPE_MAX):
+		_supported_defaults.append(null)
+
+	# These types do not require a prefix for defaults
+	_supported_defaults[TYPE_NIL] = ""
+	_supported_defaults[TYPE_BOOL] = ""
+	_supported_defaults[TYPE_INT] = ""
+	_supported_defaults[TYPE_REAL] = ""
+	_supported_defaults[TYPE_OBJECT] = ""
+	_supported_defaults[TYPE_ARRAY] = ""
+	_supported_defaults[TYPE_STRING] = ""
+	_supported_defaults[TYPE_DICTIONARY] = ""
+	_supported_defaults[TYPE_VECTOR2_ARRAY] = ""
+	_supported_defaults[TYPE_RID] = ""
+
+	# These require a prefix for whatever default is provided
+	_supported_defaults[TYPE_VECTOR2] = "Vector2"
+	_supported_defaults[TYPE_RECT2] = "Rect2"
+	_supported_defaults[TYPE_VECTOR3] = "Vector3"
+	_supported_defaults[TYPE_COLOR] = "Color"
+	_supported_defaults[TYPE_TRANSFORM2D] = "Transform2D"
+	_supported_defaults[TYPE_TRANSFORM] = "Transform"
+	_supported_defaults[TYPE_INT_ARRAY] = "PoolIntArray"
+	_supported_defaults[TYPE_REAL_ARRAY] = "PoolRealArray"
+
+
+# ###############
+# Private
+# ###############
+var _func_text = _utils.get_file_as_text("res://addons/gut/double_templates/function_template.txt")
+
+
+func _is_supported_default(type_flag):
+	return type_flag >= 0 and type_flag < _supported_defaults.size() and [type_flag] != null
+
+
+func _make_stub_default(method, index):
+	return str('__gut_default_val("', method, '",', index, ")")
+
+
+func _make_arg_array(method_meta, override_size):
+	var to_return = []
+
+	var has_unsupported_defaults = false
+	var dflt_start = method_meta.args.size() - method_meta.default_args.size()
+
+	for i in range(method_meta.args.size()):
+		var pname = method_meta.args[i].name
+		var dflt_text = ""
+
+		if i < dflt_start:
+			dflt_text = _make_stub_default(method_meta.name, i)
+		else:
+			var dflt_idx = i - dflt_start
+			var t = method_meta.args[i]["type"]
+			if _is_supported_default(t):
+				# strings are special, they need quotes around the value
+				if t == TYPE_STRING:
+					dflt_text = str("'", str(method_meta.default_args[dflt_idx]), "'")
+				# Colors need the parens but things like Vector2 and Rect2 don't
+				elif t == TYPE_COLOR:
+					dflt_text = str(
+						_supported_defaults[t], "(", str(method_meta.default_args[dflt_idx]), ")"
+					)
+				elif t == TYPE_OBJECT:
+					if str(method_meta.default_args[dflt_idx]) == "[Object:null]":
+						dflt_text = str(_supported_defaults[t], "null")
+					else:
+						dflt_text = str(
+							_supported_defaults[t],
+							str(method_meta.default_args[dflt_idx]).to_lower()
+						)
+				elif t == TYPE_TRANSFORM:
+					#value will be 4 Vector3 and look like: 1, 0, 0, 0, 1, 0, 0, 0, 1 - 0, 0, 0
+					var sections = str(method_meta.default_args[dflt_idx]).split("-")
+					var vecs = sections[0].split(",")
+					vecs.append_array(sections[1].split(","))
+					var v1 = str("Vector3(", vecs[0], ", ", vecs[1], ", ", vecs[2], ")")
+					var v2 = str("Vector3(", vecs[3], ", ", vecs[4], ", ", vecs[5], ")")
+					var v3 = str("Vector3(", vecs[6], ", ", vecs[7], ", ", vecs[8], ")")
+					var v4 = str("Vector3(", vecs[9], ", ", vecs[10], ", ", vecs[11], ")")
+					dflt_text = str(
+						_supported_defaults[t], "(", v1, ", ", v2, ", ", v3, ", ", v4, ")"
+					)
+				elif t == TYPE_TRANSFORM2D:
+					# value will look like:  ((1, 0), (0, 1), (0, 0))
+					var vectors = str(method_meta.default_args[dflt_idx])
+					vectors = vectors.replace("((", "(")
+					vectors = vectors.replace("))", ")")
+					vectors = vectors.replace("(", "Vector2(")
+					dflt_text = str(_supported_defaults[t], "(", vectors, ")")
+				elif t == TYPE_RID:
+					dflt_text = str(_supported_defaults[t], "null")
+				elif t in [TYPE_REAL_ARRAY, TYPE_INT_ARRAY]:
+					dflt_text = str(_supported_defaults[t], "()")
+
+				# Everything else puts the prefix (if one is there) form _supported_defaults
+				# in front.  The to_lower is used b/c for some reason the defaults for
+				# null, true, false are all "Null", "True", "False".
+				else:
+					dflt_text = str(
+						_supported_defaults[t], str(method_meta.default_args[dflt_idx]).to_lower()
+					)
+			else:
+				_lgr.error(
+					str(
+						"Unsupported default param type:  ",
+						method_meta.name,
+						"-",
+						method_meta.args[i].name,
+						" ",
+						t,
+						" = ",
+						method_meta.default_args[dflt_idx]
+					)
+				)
+				dflt_text = str("unsupported=", t)
+				has_unsupported_defaults = true
+
+		# Finally add in the parameter
+		to_return.append(CallParameters.new(PARAM_PREFIX + pname, dflt_text))
+
+	# Add in extra parameters from stub settings.
+	if override_size != null:
+		for i in range(method_meta.args.size(), override_size):
+			var pname = str(PARAM_PREFIX, "arg", i)
+			var dflt_text = _make_stub_default(method_meta.name, i)
+			to_return.append(CallParameters.new(pname, dflt_text))
+
+	return [has_unsupported_defaults, to_return]
+
+
+# Creates a list of parameters with defaults of null unless a default value is
+# found in the metadata.  If a default is found in the meta then it is used if
+# it is one we know how support.
+#
+# If a default is found that we don't know how to handle then this method will
+# return null.
+func _get_arg_text(arg_array):
+	var text = ""
+
+	for i in range(arg_array.size()):
+		text += str(arg_array[i].p_name, "=", arg_array[i].default)
+		if i != arg_array.size() - 1:
+			text += ", "
+
+	return text
+
+
+# creates a call to the function in meta in the super's class.
+func _get_super_call_text(method_name, args, super_name = ""):
+	var params = ""
+	for i in range(args.size()):
+		params += args[i].p_name
+		if i != args.size() - 1:
+			params += ", "
+
+	return str(super_name, ".", method_name, "(", params, ")")
+
+
+func _get_spy_call_parameters_text(args):
+	var called_with = "null"
+
+	if args.size() > 0:
+		called_with = "["
+		for i in range(args.size()):
+			called_with += args[i].p_name
+			if i < args.size() - 1:
+				called_with += ", "
+		called_with += "]"
+
+	return called_with
+
+
+# ###############
+# Public
+# ###############
+
+
+# Creates a delceration for a function based off of function metadata.  All
+# types whose defaults are supported will have their values.  If a datatype
+# is not supported and the parameter has a default, a warning message will be
+# printed and the declaration will return null.
+func get_function_text(meta, path = null, override_size = null, super_name = ""):
+	var method_params = ""
+	var text = null
+	var result = _make_arg_array(meta, override_size)
+	var has_unsupported = result[0]
+	var args = result[1]
+
+	var param_array = _get_spy_call_parameters_text(args)
+
+	if has_unsupported:
+		# This will cause a runtime error.  This is the most convenient way to
+		# to stop running before the error gets more obscure.  _make_arg_array
+		# generates a gut error when unsupported defaults are found.
+		method_params = null
+	else:
+		method_params = _get_arg_text(args)
+
+	if param_array == "null":
+		param_array = "[]"
+
+	if method_params != null:
+		var decleration = str("func ", meta.name, "(", method_params, "):")
+		text = _func_text.format(
+			{
+				"func_decleration": decleration,
+				"method_name": meta.name,
+				"param_array": param_array,
+				"super_call": _get_super_call_text(meta.name, args, super_name)
+			}
+		)
+
+	return text
+
+
+func get_logger():
+	return _lgr
+
+
+func set_logger(logger):
+	_lgr = logger

addons/gut/one_to_many.gd

@@ -0,0 +1,43 @@
+# ------------------------------------------------------------------------------
+# This datastructure represents a simple one-to-many relationship.  It manages
+# a dictionary of value/array pairs.  It ignores duplicates of both the "one"
+# and the "many".
+# ------------------------------------------------------------------------------
+var _items = {}
+
+
+# return the size of _items or the size of an element in _items if "one" was
+# specified.
+func size(one = null):
+	var to_return = 0
+	if one == null:
+		to_return = _items.size()
+	elif _items.has(one):
+		to_return = _items[one].size()
+	return to_return
+
+
+# Add an element to "one" if it does not already exist
+func add(one, many_item):
+	if _items.has(one) and !_items[one].has(many_item):
+		_items[one].append(many_item)
+	else:
+		_items[one] = [many_item]
+
+
+func clear():
+	_items.clear()
+
+
+func has(one, many_item):
+	var to_return = false
+	if _items.has(one):
+		to_return = _items[one].has(many_item)
+	return to_return
+
+
+func to_s():
+	var to_return = ""
+	for key in _items:
+		to_return += str(key, ":  ", _items[key], "\n")
+	return to_return

addons/gut/optparse.gd

@@ -0,0 +1,262 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# Command line interface for the GUT unit testing tool.  Allows you to run tests
+# from the command line instead of running a scene.  Place this script along with
+# gut.gd into your scripts directory at the root of your project.  Once there you
+# can run this script (from the root of your project) using the following command:
+# 	godot -s -d test/gut/gut_cmdln.gd
+#
+# See the readme for a list of options and examples.  You can also use the -gh
+# option to get more information about how to use the command line interface.
+# ##############################################################################
+
+#-------------------------------------------------------------------------------
+# Parses the command line arguments supplied into an array that can then be
+# examined and parsed based on how the gut options work.
+#-------------------------------------------------------------------------------
+class CmdLineParser:
+	var _used_options = []
+	# an array of arrays.  Each element in this array will contain an option
+	# name and if that option contains a value then it will have a sedond
+	# element.  For example:
+	# 	[[-gselect, test.gd], [-gexit]]
+	var _opts = []
+
+	func _init():
+		for i in range(OS.get_cmdline_args().size()):
+			var opt_val = OS.get_cmdline_args()[i].split("=")
+			_opts.append(opt_val)
+
+	# Parse out multiple comma delimited values from a command line
+	# option.  Values are separated from option name with "=" and
+	# additional values are comma separated.
+	func _parse_array_value(full_option):
+		var value = _parse_option_value(full_option)
+		var split = value.split(",")
+		return split
+
+	# Parse out the value of an option.  Values are separated from
+	# the option name with "="
+	func _parse_option_value(full_option):
+		if full_option.size() > 1:
+			return full_option[1]
+		else:
+			return null
+
+	# Search _opts for an element that starts with the option name
+	# specified.
+	func find_option(name):
+		var found = false
+		var idx = 0
+
+		while idx < _opts.size() and !found:
+			if _opts[idx][0] == name:
+				found = true
+			else:
+				idx += 1
+
+		if found:
+			return idx
+		else:
+			return -1
+
+	func get_array_value(option):
+		_used_options.append(option)
+		var to_return = []
+		var opt_loc = find_option(option)
+		if opt_loc != -1:
+			to_return = _parse_array_value(_opts[opt_loc])
+			_opts.remove(opt_loc)
+
+		return to_return
+
+	# returns the value of an option if it was specified, null otherwise.  This
+	# used to return the default but that became problemnatic when trying to
+	# punch through the different places where values could be specified.
+	func get_value(option):
+		_used_options.append(option)
+		var to_return = null
+		var opt_loc = find_option(option)
+		if opt_loc != -1:
+			to_return = _parse_option_value(_opts[opt_loc])
+			_opts.remove(opt_loc)
+
+		return to_return
+
+	# returns true if it finds the option, false if not.
+	func was_specified(option):
+		_used_options.append(option)
+		return find_option(option) != -1
+
+	# Returns any unused command line options.  I found that only the -s and
+	# script name come through from godot, all other options that godot uses
+	# are not sent through OS.get_cmdline_args().
+	#
+	# This is a onetime thing b/c i kill all items in _used_options
+	func get_unused_options():
+		var to_return = []
+		for i in range(_opts.size()):
+			to_return.append(_opts[i][0])
+
+		var script_option = to_return.find("-s")
+		if script_option != -1:
+			to_return.remove(script_option + 1)
+			to_return.remove(script_option)
+
+		while _used_options.size() > 0:
+			var index = to_return.find(_used_options[0].split("=")[0])
+			if index != -1:
+				to_return.remove(index)
+			_used_options.remove(0)
+
+		return to_return
+
+
+#-------------------------------------------------------------------------------
+# Simple class to hold a command line option
+#-------------------------------------------------------------------------------
+class Option:
+	var value = null
+	var option_name = ""
+	var default = null
+	var description = ""
+
+	func _init(name, default_value, desc = ""):
+		option_name = name
+		default = default_value
+		description = desc
+		value = null  #default_value
+
+	func pad(to_pad, size, pad_with = " "):
+		var to_return = to_pad
+		for _i in range(to_pad.length(), size):
+			to_return += pad_with
+
+		return to_return
+
+	func to_s(min_space = 0):
+		var subbed_desc = description
+		if subbed_desc.find("[default]") != -1:
+			subbed_desc = subbed_desc.replace("[default]", str(default))
+		return pad(option_name, min_space) + subbed_desc
+
+
+#-------------------------------------------------------------------------------
+# The high level interface between this script and the command line options
+# supplied.  Uses Option class and CmdLineParser to extract information from
+# the command line and make it easily accessible.
+#-------------------------------------------------------------------------------
+var options = []
+var _opts = []
+var _banner = ""
+
+
+func add(name, default, desc):
+	options.append(Option.new(name, default, desc))
+
+
+func get_value(name):
+	var found = false
+	var idx = 0
+
+	while idx < options.size() and !found:
+		if options[idx].option_name == name:
+			found = true
+		else:
+			idx += 1
+
+	if found:
+		return options[idx].value
+	else:
+		print("COULD NOT FIND OPTION " + name)
+		return null
+
+
+func set_banner(banner):
+	_banner = banner
+
+
+func print_help():
+	var longest = 0
+	for i in range(options.size()):
+		if options[i].option_name.length() > longest:
+			longest = options[i].option_name.length()
+
+	print("---------------------------------------------------------")
+	print(_banner)
+
+	print("\nOptions\n-------")
+	for i in range(options.size()):
+		print("  " + options[i].to_s(longest + 2))
+	print("---------------------------------------------------------")
+
+
+func print_options():
+	for i in range(options.size()):
+		print(options[i].option_name + "=" + str(options[i].value))
+
+
+func parse():
+	var parser = CmdLineParser.new()
+
+	for i in range(options.size()):
+		var t = typeof(options[i].default)
+		# only set values that were specified at the command line so that
+		# we can punch through default and config values correctly later.
+		# Without this check, you can't tell the difference between the
+		# defaults and what was specified, so you can't punch through
+		# higher level options.
+		if parser.was_specified(options[i].option_name):
+			if t == TYPE_INT:
+				options[i].value = int(parser.get_value(options[i].option_name))
+			elif t == TYPE_STRING:
+				options[i].value = parser.get_value(options[i].option_name)
+			elif t == TYPE_ARRAY:
+				options[i].value = parser.get_array_value(options[i].option_name)
+			elif t == TYPE_BOOL:
+				options[i].value = parser.was_specified(options[i].option_name)
+			elif t == TYPE_NIL:
+				print(options[i].option_name + " cannot be processed, it has a nil datatype")
+			else:
+				print(
+					(
+						options[i].option_name
+						+ " cannot be processed, it has unknown datatype:"
+						+ str(t)
+					)
+				)
+
+	var unused = parser.get_unused_options()
+	if unused.size() > 0:
+		print("Unrecognized options:  ", unused)
+		return false
+
+	return true

addons/gut/orphan_counter.gd

@@ -0,0 +1,59 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# This is a utility for tracking changes in the orphan count.  Each time
+# add_counter is called it adds/resets the value in the dictionary to the
+# current number of orphans.  Each call to get_counter will return the change
+# in orphans since add_counter was last called.
+# ##############################################################################
+var _counters = {}
+
+
+func orphan_count():
+	return Performance.get_monitor(Performance.OBJECT_ORPHAN_NODE_COUNT)
+
+
+func add_counter(name):
+	_counters[name] = orphan_count()
+
+
+# Returns the number of orphans created since add_counter was last called for
+# the name.  Returns -1 to avoid blowing up with an invalid name but still
+# be somewhat visible that we've done something wrong.
+func get_counter(name):
+	return orphan_count() - _counters[name] if _counters.has(name) else -1
+
+
+func print_orphans(name, lgr):
+	var count = get_counter(name)
+
+	if count > 0:
+		var o = "orphan"
+		if count > 1:
+			o = "orphans"
+		lgr.orphan(str(count, " new ", o, "(", name, ")."))

addons/gut/parameter_factory.gd

@@ -0,0 +1,75 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# This is the home for all parameter creation helpers.  These functions should
+# all return an array of values to be used as parameters for parameterized
+# tests.
+# ##############################################################################
+
+# ------------------------------------------------------------------------------
+# Creates an array of dictionaries.  It pairs up the names array with each set
+# of values in values.  If more names than values are specified then the missing
+# values will be filled with nulls.  If more values than names are specified
+# those values will be ignored.
+#
+# Example:
+# 	create_named_parameters(['a', 'b'], [[1, 2], ['one', 'two']]) returns
+#		[{a:1, b:2}, {a:'one', b:'two'}]
+#
+# 	This allows you to increase readability of your parameterized tests:
+#	var params = create_named_parameters(['a', 'b'], [[1, 2], ['one', 'two']])
+#	func test_foo(p = use_parameters(params)):
+#		assert_eq(p.a, p.b)
+#
+# Parameters:
+# 	names:  an array of names to be used as keys in the dictionaries
+#   values:  an array of arrays of values.
+# ------------------------------------------------------------------------------
+static func named_parameters(names, values):
+	var named = []
+	for i in range(values.size()):
+		var entry = {}
+
+		var parray = values[i]
+		if typeof(parray) != TYPE_ARRAY:
+			parray = [values[i]]
+
+		for j in range(names.size()):
+			if j >= parray.size():
+				entry[names[j]] = null
+			else:
+				entry[names[j]] = parray[j]
+		named.append(entry)
+
+	return named
+
+# Additional Helper Ideas
+# * File.  IDK what it would look like.  csv maybe.
+# * Random values within a range?
+# * All int values in a range or add an optioanal step.
+# *

addons/gut/parameter_handler.gd

@@ -0,0 +1,44 @@
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _params = null
+var _call_count = 0
+var _logger = null
+
+
+func _init(params = null):
+	_params = params
+	_logger = _utils.get_logger()
+	if typeof(_params) != TYPE_ARRAY:
+		_logger.error("You must pass an array to parameter_handler constructor.")
+		_params = null
+
+
+func next_parameters():
+	_call_count += 1
+	return _params[_call_count - 1]
+
+
+func get_current_parameters():
+	return _params[_call_count]
+
+
+func is_done():
+	var done = true
+	if _params != null:
+		done = _call_count == _params.size()
+	return done
+
+
+func get_logger():
+	return _logger
+
+
+func set_logger(logger):
+	_logger = logger
+
+
+func get_call_count():
+	return _call_count
+
+
+func get_parameter_count():
+	return _params.size()

addons/gut/plugin_control.gd

@@ -0,0 +1,268 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# This is the control that is added via the editor.  It exposes GUT settings
+# through the editor and delays the creation of the GUT instance until
+# Engine.get_main_loop() works as expected.
+# ##############################################################################
+tool
+extends Control
+
+# ------------------------------------------------------------------------------
+# GUT Settings
+# ------------------------------------------------------------------------------
+export(String, "AnonymousPro", "CourierPrime", "LobsterTwo", "Default") var _font_name = "AnonymousPro"
+export(int) var _font_size = 20
+export(Color) var _font_color = Color(.8, .8, .8, 1)
+export(Color) var _background_color = Color(.15, .15, .15, 1)
+# Enable/Disable coloring of output.
+export(bool) var _color_output = true
+# The full/partial name of a script to select upon startup
+export(String) var _select_script = ""
+# The full/partial name of a test.  All tests that contain the string will be
+# run
+export(String) var _tests_like = ""
+# The full/partial name of an Inner Class to be run.  All Inner Classes that
+# contain the string will be run.
+export(String) var _inner_class_name = ""
+# Start running tests when the scene finishes loading
+export var _run_on_load = false
+# Maximize the GUT control on startup
+export var _should_maximize = false
+# Print output to the consol as well
+export var _should_print_to_console = true
+# Display orphan counts at the end of tests/scripts.
+export var _show_orphans = true
+# The log level.
+export(int, "Fail/Errors", "Errors/Warnings/Test Names", "Everything") var _log_level = 1
+# When enabled GUT will yield between tests to give the GUI time to paint.
+# Disabling this can make the program appear to hang and can have some
+# unwanted consequences with the timing of freeing objects
+export var _yield_between_tests = true
+# When GUT compares values it first checks the types to prevent runtime errors.
+# This behavior can be disabled if desired.  This flag was added early in
+# development to prevent any breaking changes and will likely be removed in
+# the future.
+export var _disable_strict_datatype_checks = false
+# The prefix used to find test methods.
+export var _test_prefix = "test_"
+# The prefix used to find test scripts.
+export var _file_prefix = "test_"
+# The file extension for test scripts (I don't think you can change this and
+# everythign work).
+export var _file_extension = ".gd"
+# The prefix used to find Inner Test Classes.
+export var _inner_class_prefix = "Test"
+# The directory GUT will use to write any temporary files.  This isn't used
+# much anymore since there was a change to the double creation implementation.
+# This will be removed in a later release.
+export(String) var _temp_directory = "user://gut_temp_directory"
+# The path and filename for exported test information.
+export(String) var _export_path = ""
+# When enabled, any directory added will also include its subdirectories when
+# GUT looks for test scripts.
+export var _include_subdirectories = false
+# Allow user to add test directories via editor.  This is done with strings
+# instead of an array because the interface for editing arrays is really
+# cumbersome and complicates testing because arrays set through the editor
+# apply to ALL instances.  This also allows the user to use the built in
+# dialog to pick a directory.
+export(String, DIR) var _directory1 = ""
+export(String, DIR) var _directory2 = ""
+export(String, DIR) var _directory3 = ""
+export(String, DIR) var _directory4 = ""
+export(String, DIR) var _directory5 = ""
+export(String, DIR) var _directory6 = ""
+# Must match the types in _utils for double strategy
+export(int, "FULL", "PARTIAL") var _double_strategy = 1
+# Path and filename to the script to run before all tests are run.
+export(String, FILE) var _pre_run_script = ""
+# Path and filename to the script to run after all tests are run.
+export(String, FILE) var _post_run_script = ""
+# Path to the file that gut will export results to in the junit xml format
+export(String, FILE) var _junit_xml_file = ""
+# Flag to include a timestamp in the filename of _junit_xml_file
+export(bool) var _junit_xml_timestamp = false
+# ------------------------------------------------------------------------------
+
+# ------------------------------------------------------------------------------
+# Signals
+# ------------------------------------------------------------------------------
+# Emitted when all the tests have finished running.
+signal tests_finished
+# Emitted when GUT is ready to be interacted with, and before any tests are run.
+signal gut_ready
+
+# ------------------------------------------------------------------------------
+# Private stuff.
+# ------------------------------------------------------------------------------
+var _gut = null
+var _lgr = null
+var _cancel_import = false
+var _placeholder = null
+
+
+func _init():
+	# This min size has to be what the min size of the GutScene's min size is
+	# but it has to be set here and not inferred i think.
+	rect_min_size = Vector2(740, 250)
+
+
+func _ready():
+	# Must call this deferred so that there is enough time for
+	# Engine.get_main_loop() is populated and the psuedo singleton utils.gd
+	# can be setup correctly.
+	if Engine.editor_hint:
+		_placeholder = load("res://addons/gut/GutScene.tscn").instance()
+		call_deferred("add_child", _placeholder)
+		_placeholder.rect_size = rect_size
+	else:
+		call_deferred("_setup_gut")
+
+	connect("resized", self, "_on_resized")
+
+
+func _on_resized():
+	if _placeholder != null:
+		_placeholder.rect_size = rect_size
+
+
+# Templates can be missing if tests are exported and the export config for the
+# project does not include '*.txt' files.  This check and related flags make
+# sure GUT does not blow up and that the error is not lost in all the import
+# output that is generated as well as ensuring that no tests are run.
+#
+# Assumption:  This is only a concern when running from the scene since you
+# cannot run GUT from the command line in an exported game.
+func _check_for_templates():
+	var f = File.new()
+	if !f.file_exists("res://addons/gut/double_templates/function_template.txt"):
+		_lgr.error(
+			'Templates are missing.  Make sure you are exporting "*.txt" or "addons/gut/double_templates/*.txt".'
+		)
+		_run_on_load = false
+		_cancel_import = true
+		return false
+	return true
+
+
+func _setup_gut():
+	var _utils = load("res://addons/gut/utils.gd").get_instance()
+
+	_lgr = _utils.get_logger()
+	_gut = load("res://addons/gut/gut.gd").new()
+	_gut.connect("tests_finished", self, "_on_tests_finished")
+
+	if !_check_for_templates():
+		return
+
+	_gut._select_script = _select_script
+	_gut._tests_like = _tests_like
+	_gut._inner_class_name = _inner_class_name
+
+	_gut._test_prefix = _test_prefix
+	_gut._file_prefix = _file_prefix
+	_gut._file_extension = _file_extension
+	_gut._inner_class_prefix = _inner_class_prefix
+	_gut._temp_directory = _temp_directory
+
+	_gut.set_should_maximize(_should_maximize)
+	_gut.set_yield_between_tests(_yield_between_tests)
+	_gut.disable_strict_datatype_checks(_disable_strict_datatype_checks)
+	_gut.set_export_path(_export_path)
+	_gut.set_include_subdirectories(_include_subdirectories)
+	_gut.set_double_strategy(_double_strategy)
+	_gut.set_pre_run_script(_pre_run_script)
+	_gut.set_post_run_script(_post_run_script)
+	_gut.set_color_output(_color_output)
+	_gut.show_orphans(_show_orphans)
+	_gut.set_junit_xml_file(_junit_xml_file)
+	_gut.set_junit_xml_timestamp(_junit_xml_timestamp)
+
+	get_parent().add_child(_gut)
+
+	if !_utils.is_version_ok():
+		return
+
+	_gut.set_log_level(_log_level)
+
+	_gut.add_directory(_directory1)
+	_gut.add_directory(_directory2)
+	_gut.add_directory(_directory3)
+	_gut.add_directory(_directory4)
+	_gut.add_directory(_directory5)
+	_gut.add_directory(_directory6)
+
+	_gut.get_logger().disable_printer("console", !_should_print_to_console)
+	# When file logging enabled then the log will contain terminal escape
+	# strings.  So when running the scene this is disabled.  Also if enabled
+	# this may cause duplicate entries into the logs.
+	_gut.get_logger().disable_printer("terminal", true)
+
+	_gut.get_gui().set_font_size(_font_size)
+	_gut.get_gui().set_font(_font_name)
+	_gut.get_gui().set_default_font_color(_font_color)
+	_gut.get_gui().set_background_color(_background_color)
+	_gut.get_gui().rect_size = rect_size
+	emit_signal("gut_ready")
+
+	if _run_on_load:
+		# Run the test scripts.  If one has been selected then only run that one
+		# otherwise all tests will be run.
+		var run_rest_of_scripts = _select_script == null
+		_gut.test_scripts(run_rest_of_scripts)
+
+
+func _is_ready_to_go(action):
+	if _gut == null:
+		push_error(
+			str(
+				"GUT is not ready for ",
+				action,
+				" yet.  Perform actions on GUT in/after the gut_ready signal."
+			)
+		)
+	return _gut != null
+
+
+func _on_tests_finished():
+	emit_signal("tests_finished")
+
+
+func get_gut():
+	return _gut
+
+
+func export_if_tests_found():
+	if _is_ready_to_go("export_if_tests_found"):
+		_gut.export_if_tests_found()
+
+
+func import_tests_if_none_found():
+	if _is_ready_to_go("import_tests_if_none_found") and !_cancel_import:
+		_gut.import_tests_if_none_found()

addons/gut/printers.gd

@@ -0,0 +1,153 @@
+# ------------------------------------------------------------------------------
+# Interface and some basic functionality for all printers.
+# ------------------------------------------------------------------------------
+class Printer:
+	var _format_enabled = true
+	var _disabled = false
+	var _printer_name = "NOT SET"
+	var _show_name = false  # used for debugging, set manually
+
+	func get_format_enabled():
+		return _format_enabled
+
+	func set_format_enabled(format_enabled):
+		_format_enabled = format_enabled
+
+	func send(text, fmt = null):
+		if _disabled:
+			return
+
+		var formatted = text
+		if fmt != null and _format_enabled:
+			formatted = format_text(text, fmt)
+
+		if _show_name:
+			formatted = str("(", _printer_name, ")") + formatted
+
+		_output(formatted)
+
+	func get_disabled():
+		return _disabled
+
+	func set_disabled(disabled):
+		_disabled = disabled
+
+	# --------------------
+	# Virtual Methods (some have some default behavior)
+	# --------------------
+	func _output(text):
+		pass
+
+	func format_text(text, fmt):
+		return text
+
+
+# ------------------------------------------------------------------------------
+# Responsible for sending text to a GUT gui.
+# ------------------------------------------------------------------------------
+class GutGuiPrinter:
+	extends Printer
+	var _gut = null
+
+	var _colors = {red = Color.red, yellow = Color.yellow, green = Color.green}
+
+	func _init():
+		_printer_name = "gui"
+
+	func _wrap_with_tag(text, tag):
+		return str("[", tag, "]", text, "[/", tag, "]")
+
+	func _color_text(text, c_word):
+		return "[color=" + c_word + "]" + text + "[/color]"
+
+	func format_text(text, fmt):
+		var box = _gut.get_gui().get_text_box()
+
+		if fmt == "bold":
+			box.push_bold()
+		elif fmt == "underline":
+			box.push_underline()
+		elif _colors.has(fmt):
+			box.push_color(_colors[fmt])
+		else:
+			# just pushing something to pop.
+			box.push_normal()
+
+		box.add_text(text)
+		box.pop()
+
+		return ""
+
+	func _output(text):
+		_gut.get_gui().get_text_box().add_text(text)
+
+	func get_gut():
+		return _gut
+
+	func set_gut(gut):
+		_gut = gut
+
+	# This can be very very slow when the box has a lot of text.
+	func clear_line():
+		var box = _gut.get_gui().get_text_box()
+		box.remove_line(box.get_line_count() - 1)
+		box.update()
+
+
+# ------------------------------------------------------------------------------
+# This AND TerminalPrinter should not be enabled at the same time since it will
+# result in duplicate output.  printraw does not print to the console so i had
+# to make another one.
+# ------------------------------------------------------------------------------
+class ConsolePrinter:
+	extends Printer
+	var _buffer = ""
+
+	func _init():
+		_printer_name = "console"
+
+	# suppresses output until it encounters a newline to keep things
+	# inline as much as possible.
+	func _output(text):
+		if text.ends_with("\n"):
+			print(_buffer + text.left(text.length() - 1))
+			_buffer = ""
+		else:
+			_buffer += text
+
+
+# ------------------------------------------------------------------------------
+# Prints text to terminal, formats some words.
+# ------------------------------------------------------------------------------
+class TerminalPrinter:
+	extends Printer
+
+	var escape = PoolByteArray([0x1b]).get_string_from_ascii()
+	var cmd_colors = {
+		red = escape + "[31m",
+		yellow = escape + "[33m",
+		green = escape + "[32m",
+		underline = escape + "[4m",
+		bold = escape + "[1m",
+		default = escape + "[0m",
+		clear_line = escape + "[2K"
+	}
+
+	func _init():
+		_printer_name = "terminal"
+
+	func _output(text):
+		# Note, printraw does not print to the console.
+		printraw(text)
+
+	func format_text(text, fmt):
+		return cmd_colors[fmt] + text + cmd_colors.default
+
+	func clear_line():
+		send(cmd_colors.clear_line)
+
+	func back(n):
+		send(escape + str("[", n, "D"))
+
+	func forward(n):
+		send(escape + str("[", n, "C"))

addons/gut/result_exporter.gd

@@ -0,0 +1,116 @@
+# ------------------------------------------------------------------------------
+# Creates a structure that contains all the data about the results of running
+# tests.  This was created to make an intermediate step organizing the result
+# of a run and exporting it in a specific format.  This can also serve as a
+# unofficial GUT export format.
+# ------------------------------------------------------------------------------
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+
+
+func _export_tests(summary_script):
+	var to_return = {}
+	var tests = summary_script.get_tests()
+	for key in tests.keys():
+		to_return[key] = {
+			"status": tests[key].get_status(),
+			"passing": tests[key].pass_texts,
+			"failing": tests[key].fail_texts,
+			"pending": tests[key].pending_texts,
+			"orphans": tests[key].orphans,
+		}
+
+	return to_return
+
+
+# TODO
+#	errors
+func _export_scripts(summary):
+	if summary == null:
+		return {}
+
+	var scripts = {}
+
+	for s in summary.get_scripts():
+		scripts[s.name] = {
+			"props":
+			{
+				"tests": s._tests.size(),
+				"pending": s.get_pending_count(),
+				"failures": s.get_fail_count(),
+			},
+			"tests": _export_tests(s)
+		}
+	return scripts
+
+
+func _make_results_dict():
+	var result = {
+		"test_scripts":
+		{
+			"props":
+			{
+				"pending": 0,
+				"failures": 0,
+				"passing": 0,
+				"tests": 0,
+				"time": 0,
+				"orphans": 0,
+				"errors": 0,
+				"warnings": 0
+			},
+			"scripts": []
+		}
+	}
+	return result
+
+
+# TODO
+#	time
+#	errors
+func get_results_dictionary(gut, include_scripts = true):
+	var summary = gut.get_summary()
+	var scripts = []
+
+	if include_scripts:
+		scripts = _export_scripts(summary)
+
+	var result = _make_results_dict()
+	if summary != null:
+		var totals = summary.get_totals()
+
+		var props = result.test_scripts.props
+		props.pending = totals.pending
+		props.failures = totals.failing
+		props.passing = totals.passing_tests
+		props.tests = totals.tests
+		props.errors = gut.get_logger().get_errors().size()
+		props.warnings = gut.get_logger().get_warnings().size()
+		props.time = gut.get_gui().elapsed_time_as_str().replace("s", "")
+		props.orphans = gut.get_orphan_counter().get_counter("total")
+		result.test_scripts.scripts = scripts
+
+	return result
+
+
+func write_json_file(gut, path):
+	var dict = get_results_dictionary(gut)
+	var json = JSON.print(dict, " ")
+
+	var f_result = _utils.write_file(path, json)
+	if f_result != OK:
+		var msg = str("Error:  ", f_result, ".  Could not create export file ", path)
+		_utils.get_logger().error(msg)
+
+	return f_result
+
+
+func write_summary_file(gut, path):
+	var dict = get_results_dictionary(gut, false)
+	var json = JSON.print(dict, " ")
+
+	var f_result = _utils.write_file(path, json)
+	if f_result != OK:
+		var msg = str("Error:  ", f_result, ".  Could not create export file ", path)
+		_utils.get_logger().error(msg)
+
+	return f_result

addons/gut/signal_watcher.gd

@@ -0,0 +1,188 @@
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+
+# Some arbitrary string that should never show up by accident.  If it does, then
+# shame on  you.
+const ARG_NOT_SET = "_*_argument_*_is_*_not_set_*_"
+
+# This hash holds the objects that are being watched, the signals that are being
+# watched, and an array of arrays that contains arguments that were passed
+# each time the signal was emitted.
+#
+# For example:
+#	_watched_signals => {
+#		ref1 => {
+#			'signal1' => [[], [], []],
+#			'signal2' => [[p1, p2]],
+#			'signal3' => [[p1]]
+#		},
+#		ref2 => {
+#			'some_signal' => [],
+#			'other_signal' => [[p1, p2, p3], [p1, p2, p3], [p1, p2, p3]]
+#		}
+#	}
+#
+# In this sample:
+#	- signal1 on the ref1 object was emitted 3 times and each time, zero
+#	  parameters were passed.
+#	- signal3 on ref1 was emitted once and passed a single parameter
+#	- some_signal on ref2 was never emitted.
+#	- other_signal on ref2 was emitted 3 times, each time with 3 parameters.
+var _watched_signals = {}
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+
+
+func _add_watched_signal(obj, name):
+	# SHORTCIRCUIT - ignore dupes
+	if _watched_signals.has(obj) and _watched_signals[obj].has(name):
+		return
+
+	if !_watched_signals.has(obj):
+		_watched_signals[obj] = {name: []}
+	else:
+		_watched_signals[obj][name] = []
+	obj.connect(name, self, "_on_watched_signal", [obj, name])
+
+
+# This handles all the signals that are watched.  It supports up to 9 parameters
+# which could be emitted by the signal and the two parameters used when it is
+# connected via watch_signal.  I chose 9 since you can only specify up to 9
+# parameters when dynamically calling a method via call (per the Godot
+# documentation, i.e. some_object.call('some_method', 1, 2, 3...)).
+#
+# Based on the documentation of emit_signal, it appears you can only pass up
+# to 4 parameters when firing a signal.  I haven't verified this, but this should
+# future proof this some if the value ever grows.
+func _on_watched_signal(
+	arg1 = ARG_NOT_SET,
+	arg2 = ARG_NOT_SET,
+	arg3 = ARG_NOT_SET,
+	arg4 = ARG_NOT_SET,
+	arg5 = ARG_NOT_SET,
+	arg6 = ARG_NOT_SET,
+	arg7 = ARG_NOT_SET,
+	arg8 = ARG_NOT_SET,
+	arg9 = ARG_NOT_SET,
+	arg10 = ARG_NOT_SET,
+	arg11 = ARG_NOT_SET
+):
+	var args = [arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11]
+
+	# strip off any unused vars.
+	var idx = args.size() - 1
+	while str(args[idx]) == ARG_NOT_SET:
+		args.remove(idx)
+		idx -= 1
+
+	# retrieve object and signal name from the array and remove them.  These
+	# will always be at the end since they are added when the connect happens.
+	var signal_name = args[args.size() - 1]
+	args.pop_back()
+	var object = args[args.size() - 1]
+	args.pop_back()
+
+	_watched_signals[object][signal_name].append(args)
+
+
+func does_object_have_signal(object, signal_name):
+	var signals = object.get_signal_list()
+	for i in range(signals.size()):
+		if signals[i]["name"] == signal_name:
+			return true
+	return false
+
+
+func watch_signals(object):
+	var signals = object.get_signal_list()
+	for i in range(signals.size()):
+		_add_watched_signal(object, signals[i]["name"])
+
+
+func watch_signal(object, signal_name):
+	var did = false
+	if does_object_have_signal(object, signal_name):
+		_add_watched_signal(object, signal_name)
+		did = true
+	return did
+
+
+func get_emit_count(object, signal_name):
+	var to_return = -1
+	if is_watching(object, signal_name):
+		to_return = _watched_signals[object][signal_name].size()
+	return to_return
+
+
+func did_emit(object, signal_name):
+	var did = false
+	if is_watching(object, signal_name):
+		did = get_emit_count(object, signal_name) != 0
+	return did
+
+
+func print_object_signals(object):
+	var list = object.get_signal_list()
+	for i in range(list.size()):
+		print(list[i].name, "\n  ", list[i])
+
+
+func get_signal_parameters(object, signal_name, index = -1):
+	var params = null
+	if is_watching(object, signal_name):
+		var all_params = _watched_signals[object][signal_name]
+		if all_params.size() > 0:
+			if index == -1:
+				index = all_params.size() - 1
+			params = all_params[index]
+	return params
+
+
+func is_watching_object(object):
+	return _watched_signals.has(object)
+
+
+func is_watching(object, signal_name):
+	return _watched_signals.has(object) and _watched_signals[object].has(signal_name)
+
+
+func clear():
+	for obj in _watched_signals:
+		if _utils.is_not_freed(obj):
+			for signal_name in _watched_signals[obj]:
+				obj.disconnect(signal_name, self, "_on_watched_signal")
+	_watched_signals.clear()
+
+
+# Returns a list of all the signal names that were emitted by the object.
+# If the object is not being watched then an empty list is returned.
+func get_signals_emitted(obj):
+	var emitted = []
+	if is_watching_object(obj):
+		for signal_name in _watched_signals[obj]:
+			if _watched_signals[obj][signal_name].size() > 0:
+				emitted.append(signal_name)
+
+	return emitted

addons/gut/spy.gd

@@ -0,0 +1,127 @@
+# {
+#   instance_id_or_path1:{
+#       method1:[ [p1, p2], [p1, p2] ],
+#       method2:[ [p1, p2], [p1, p2] ]
+#   },
+#   instance_id_or_path1:{
+#       method1:[ [p1, p2], [p1, p2] ],
+#       method2:[ [p1, p2], [p1, p2] ]
+#   },
+# }
+var _calls = {}
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _lgr = _utils.get_logger()
+var _compare = _utils.Comparator.new()
+
+
+func _find_parameters(call_params, params_to_find):
+	var found = false
+	var idx = 0
+	while idx < call_params.size() and !found:
+		var result = _compare.deep(call_params[idx], params_to_find)
+		if result.are_equal:
+			found = true
+		else:
+			idx += 1
+	return found
+
+
+func _get_params_as_string(params):
+	var to_return = ""
+	if params == null:
+		return ""
+
+	for i in range(params.size()):
+		if params[i] == null:
+			to_return += "null"
+		else:
+			if typeof(params[i]) == TYPE_STRING:
+				to_return += str('"', params[i], '"')
+			else:
+				to_return += str(params[i])
+		if i != params.size() - 1:
+			to_return += ", "
+	return to_return
+
+
+func add_call(variant, method_name, parameters = null):
+	if !_calls.has(variant):
+		_calls[variant] = {}
+
+	if !_calls[variant].has(method_name):
+		_calls[variant][method_name] = []
+
+	_calls[variant][method_name].append(parameters)
+
+
+func was_called(variant, method_name, parameters = null):
+	var to_return = false
+	if _calls.has(variant) and _calls[variant].has(method_name):
+		if parameters:
+			to_return = _find_parameters(_calls[variant][method_name], parameters)
+		else:
+			to_return = true
+	return to_return
+
+
+func get_call_parameters(variant, method_name, index = -1):
+	var to_return = null
+	var get_index = -1
+
+	if _calls.has(variant) and _calls[variant].has(method_name):
+		var call_size = _calls[variant][method_name].size()
+		if index == -1:
+			# get the most recent call by default
+			get_index = call_size - 1
+		else:
+			get_index = index
+
+		if get_index < call_size:
+			to_return = _calls[variant][method_name][get_index]
+		else:
+			_lgr.error(
+				str(
+					"Specified index ",
+					index,
+					" is outside range of the number of registered calls:  ",
+					call_size
+				)
+			)
+
+	return to_return
+
+
+func call_count(instance, method_name, parameters = null):
+	var to_return = 0
+
+	if was_called(instance, method_name):
+		if parameters:
+			for i in range(_calls[instance][method_name].size()):
+				if _calls[instance][method_name][i] == parameters:
+					to_return += 1
+		else:
+			to_return = _calls[instance][method_name].size()
+	return to_return
+
+
+func clear():
+	_calls = {}
+
+
+func get_call_list_as_string(instance):
+	var to_return = ""
+	if _calls.has(instance):
+		for method in _calls[instance]:
+			for i in range(_calls[instance][method].size()):
+				to_return += str(
+					method, "(", _get_params_as_string(_calls[instance][method][i]), ")\n"
+				)
+	return to_return
+
+
+func get_logger():
+	return _lgr
+
+
+func set_logger(logger):
+	_lgr = logger

addons/gut/strutils.gd

@@ -0,0 +1,185 @@
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+# Hash containing all the built in types in Godot.  This provides an English
+# name for the types that corosponds with the type constants defined in the
+# engine.
+var types = {}
+var NativeScriptClass = null
+
+
+func _init_types_dictionary():
+	types[TYPE_NIL] = "TYPE_NIL"
+	types[TYPE_BOOL] = "Bool"
+	types[TYPE_INT] = "Int"
+	types[TYPE_REAL] = "Float/Real"
+	types[TYPE_STRING] = "String"
+	types[TYPE_VECTOR2] = "Vector2"
+	types[TYPE_RECT2] = "Rect2"
+	types[TYPE_VECTOR3] = "Vector3"
+	#types[8] = 'Matrix32'
+	types[TYPE_PLANE] = "Plane"
+	types[TYPE_QUAT] = "QUAT"
+	types[TYPE_AABB] = "AABB"
+	#types[12] = 'Matrix3'
+	types[TYPE_TRANSFORM] = "Transform"
+	types[TYPE_COLOR] = "Color"
+	#types[15] = 'Image'
+	types[TYPE_NODE_PATH] = "Node Path"
+	types[TYPE_RID] = "RID"
+	types[TYPE_OBJECT] = "TYPE_OBJECT"
+	#types[19] = 'TYPE_INPUT_EVENT'
+	types[TYPE_DICTIONARY] = "Dictionary"
+	types[TYPE_ARRAY] = "Array"
+	types[TYPE_RAW_ARRAY] = "TYPE_RAW_ARRAY"
+	types[TYPE_INT_ARRAY] = "TYPE_INT_ARRAY"
+	types[TYPE_REAL_ARRAY] = "TYPE_REAL_ARRAY"
+	types[TYPE_STRING_ARRAY] = "TYPE_STRING_ARRAY"
+	types[TYPE_VECTOR2_ARRAY] = "TYPE_VECTOR2_ARRAY"
+	types[TYPE_VECTOR3_ARRAY] = "TYPE_VECTOR3_ARRAY"
+	types[TYPE_COLOR_ARRAY] = "TYPE_COLOR_ARRAY"
+	types[TYPE_MAX] = "TYPE_MAX"
+
+
+# Types to not be formatted when using _str
+var _str_ignore_types = [TYPE_INT, TYPE_REAL, TYPE_STRING, TYPE_NIL, TYPE_BOOL]
+
+
+func _init():
+	_init_types_dictionary()
+	# NativeScript does not exist when GDNative is not included in the build
+	if type_exists("NativeScript"):
+		var getter = load("res://addons/gut/get_native_script.gd")
+		NativeScriptClass = getter.get_it()
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+func _get_filename(path):
+	return path.split("/")[-1]
+
+
+# ------------------------------------------------------------------------------
+# Gets the filename of an object passed in.  This does not return the
+# full path to the object, just the filename.
+# ------------------------------------------------------------------------------
+func _get_obj_filename(thing):
+	var filename = null
+
+	if (
+		thing == null
+		or !is_instance_valid(thing)
+		or str(thing) == "[Object:null]"
+		or typeof(thing) != TYPE_OBJECT
+		or thing.has_method("__gut_instance_from_id")
+	):
+		return
+
+	if thing.get_script() == null:
+		if thing is PackedScene:
+			filename = _get_filename(thing.resource_path)
+		else:
+			# If it isn't a packed scene and it doesn't have a script then
+			# we do nothing.  This just read better.
+			pass
+	elif NativeScriptClass != null and thing.get_script() is NativeScriptClass:
+		# Work with GDNative scripts:
+		# inst2dict fails with "Not a script with an instance" on GDNative script instances
+		filename = _get_filename(thing.get_script().resource_path)
+	elif !_utils.is_native_class(thing):
+		var dict = inst2dict(thing)
+		filename = _get_filename(dict["@path"])
+		if dict["@subpath"] != "":
+			filename += str("/", dict["@subpath"])
+
+	return filename
+
+
+# ------------------------------------------------------------------------------
+# Better object/thing to string conversion.  Includes extra details about
+# whatever is passed in when it can/should.
+# ------------------------------------------------------------------------------
+func type2str(thing):
+	var filename = _get_obj_filename(thing)
+	var str_thing = str(thing)
+
+	if thing == null:
+		# According to str there is a difference between null and an Object
+		# that is somehow null.  To avoid getting '[Object:null]' as output
+		# always set it to str(null) instead of str(thing).  A null object
+		# will pass typeof(thing) == TYPE_OBJECT check so this has to be
+		# before that.
+		str_thing = str(null)
+	elif typeof(thing) == TYPE_REAL:
+		if !"." in str_thing:
+			str_thing += ".0"
+	elif typeof(thing) == TYPE_STRING:
+		str_thing = str('"', thing, '"')
+	elif typeof(thing) in _str_ignore_types:
+		# do nothing b/c we already have str(thing) in
+		# to_return.  I think this just reads a little
+		# better this way.
+		pass
+	elif typeof(thing) == TYPE_OBJECT:
+		if _utils.is_native_class(thing):
+			str_thing = _utils.get_native_class_name(thing)
+		elif _utils.is_double(thing):
+			var double_path = _get_filename(thing.__gut_metadata_.path)
+			if thing.__gut_metadata_.subpath != "":
+				double_path += str("/", thing.__gut_metadata_.subpath)
+			elif thing.__gut_metadata_.from_singleton != "":
+				double_path = thing.__gut_metadata_.from_singleton + " Singleton"
+
+			var double_type = "double"
+			if thing.__gut_metadata_.is_partial:
+				double_type = "partial-double"
+
+			str_thing += str("(", double_type, " of ", double_path, ")")
+
+			filename = null
+	elif types.has(typeof(thing)):
+		if !str_thing.begins_with("("):
+			str_thing = "(" + str_thing + ")"
+		str_thing = str(types[typeof(thing)], str_thing)
+
+	if filename != null:
+		str_thing += str("(", filename, ")")
+	return str_thing
+
+
+# ------------------------------------------------------------------------------
+# Returns the string truncated with an '...' in it.  Shows the start and last
+# 10 chars.  If the string is  smaller than max_size the entire string is
+# returned.  If max_size is -1 then truncation is skipped.
+# ------------------------------------------------------------------------------
+func truncate_string(src, max_size):
+	var to_return = src
+	if src.length() > max_size - 10 and max_size != -1:
+		to_return = str(
+			src.substr(0, max_size - 10), "...", src.substr(src.length() - 10, src.length())
+		)
+	return to_return
+
+
+func _get_indent_text(times, pad):
+	var to_return = ""
+	for i in range(times):
+		to_return += pad
+
+	return to_return
+
+
+func indent_text(text, times, pad):
+	if times == 0:
+		return text
+
+	var to_return = text
+	var ending_newline = ""
+
+	if text.ends_with("\n"):
+		ending_newline = "\n"
+		to_return = to_return.left(to_return.length() - 1)
+
+	var padding = _get_indent_text(times, pad)
+	to_return = to_return.replace("\n", "\n" + padding)
+	to_return += ending_newline
+
+	return padding + to_return

addons/gut/stub_params.gd

@@ -0,0 +1,117 @@
+var return_val = null
+var stub_target = null
+var target_subpath = null
+# the parameter values to match method call on.
+var parameters = null
+var stub_method = null
+var call_super = false
+
+# -- Paramter Override --
+# Parmater overrides are stored in here along with all the other stub info
+# so that you can chain stubbing parameter overrides along with all the
+# other stubbing.  This adds some complexity to the logic that tries to
+# find the correct stub for a call by a double.  Since an instance of this
+# class could be just a parameter override, or it could have been chained
+# we have to have _paramter_override_only so that we know when to tell the
+# difference.
+var parameter_count = -1
+var parameter_defaults = null
+# Anything that would make this stub not just an override of paramters
+# must set this flag to false.  This must be private bc the actual logic
+# to determine if this stub is only an override is more complicated.
+var _parameter_override_only = true
+# --
+
+const NOT_SET = "|_1_this_is_not_set_1_|"
+
+
+func _init(target = null, method = null, subpath = null):
+	stub_target = target
+	stub_method = method
+	target_subpath = subpath
+
+
+func to_return(val):
+	return_val = val
+	call_super = false
+	_parameter_override_only = false
+	return self
+
+
+func to_do_nothing():
+	return to_return(null)
+
+
+func to_call_super():
+	call_super = true
+	_parameter_override_only = false
+	return self
+
+
+func when_passed(
+	p1 = NOT_SET,
+	p2 = NOT_SET,
+	p3 = NOT_SET,
+	p4 = NOT_SET,
+	p5 = NOT_SET,
+	p6 = NOT_SET,
+	p7 = NOT_SET,
+	p8 = NOT_SET,
+	p9 = NOT_SET,
+	p10 = NOT_SET
+):
+	parameters = [p1, p2, p3, p4, p5, p6, p7, p8, p9, p10]
+	var idx = 0
+	while idx < parameters.size():
+		if str(parameters[idx]) == NOT_SET:
+			parameters.remove(idx)
+		else:
+			idx += 1
+	return self
+
+
+func param_count(x):
+	parameter_count = x
+	return self
+
+
+func param_defaults(values):
+	parameter_count = values.size()
+	parameter_defaults = values
+	return self
+
+
+func has_param_override():
+	return parameter_count != -1
+
+
+func is_param_override_only():
+	var to_return = false
+	if has_param_override():
+		to_return = _parameter_override_only
+	return to_return
+
+
+func to_s():
+	var base_string = str(stub_target)
+	if target_subpath != null:
+		base_string += str("[", target_subpath, "].")
+	else:
+		base_string += "."
+	base_string += stub_method
+
+	if has_param_override():
+		base_string += str(
+			" (param count override=", parameter_count, " defaults=", parameter_defaults
+		)
+		if is_param_override_only():
+			base_string += " ONLY"
+		base_string += ") "
+
+	if call_super:
+		base_string += " to call SUPER"
+
+	if parameters != null:
+		base_string += str(" with params (", parameters, ") returns ", return_val)
+
+	return base_string

addons/gut/stubber.gd

@@ -0,0 +1,229 @@
+# -------------
+# returns{} and parameters {} have the followin structure
+# -------------
+# {
+# 	inst_id_or_path1:{
+# 		method_name1: [StubParams, StubParams],
+# 		method_name2: [StubParams, StubParams]
+# 	},
+# 	inst_id_or_path2:{
+# 		method_name1: [StubParams, StubParams],
+# 		method_name2: [StubParams, StubParams]
+# 	}
+# }
+var returns = {}
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _lgr = _utils.get_logger()
+var _strutils = _utils.Strutils.new()
+
+
+func _make_key_from_metadata(doubled):
+	var to_return = doubled.__gut_metadata_.path
+
+	if doubled.__gut_metadata_.from_singleton != "":
+		to_return = str(doubled.__gut_metadata_.from_singleton)
+	elif doubled.__gut_metadata_.subpath != "":
+		to_return += str("-", doubled.__gut_metadata_.subpath)
+
+	return to_return
+
+
+# Creates they key for the returns hash based on the type of object passed in
+# obj could be a string of a path to a script with an optional subpath or
+# it could be an instance of a doubled object.
+func _make_key_from_variant(obj, subpath = null):
+	var to_return = null
+
+	match typeof(obj):
+		TYPE_STRING:
+			# this has to match what is done in _make_key_from_metadata
+			to_return = obj
+			if subpath != null and subpath != "":
+				to_return += str("-", subpath)
+		TYPE_OBJECT:
+			if _utils.is_instance(obj):
+				to_return = _make_key_from_metadata(obj)
+			elif _utils.is_native_class(obj):
+				to_return = _utils.get_native_class_name(obj)
+			else:
+				to_return = obj.resource_path
+
+	return to_return
+
+
+func _add_obj_method(obj, method, subpath = null):
+	var key = _make_key_from_variant(obj, subpath)
+	if _utils.is_instance(obj):
+		key = obj
+
+	if !returns.has(key):
+		returns[key] = {}
+	if !returns[key].has(method):
+		returns[key][method] = []
+
+	return key
+
+
+# ##############
+# Public
+# ##############
+
+
+# Searches returns for an entry that matches the instance or the class that
+# passed in obj is.
+#
+# obj can be an instance, class, or a path.
+func _find_stub(obj, method, parameters = null, find_overloads = false):
+	var key = _make_key_from_variant(obj)
+	var to_return = null
+
+	if _utils.is_instance(obj):
+		if returns.has(obj) and returns[obj].has(method):
+			key = obj
+		elif obj.get("__gut_metadata_"):
+			key = _make_key_from_metadata(obj)
+
+	if returns.has(key) and returns[key].has(method):
+		var param_match = null
+		var null_match = null
+		var overload_match = null
+
+		for i in range(returns[key][method].size()):
+			if returns[key][method][i].parameters == parameters:
+				param_match = returns[key][method][i]
+
+			if returns[key][method][i].parameters == null:
+				null_match = returns[key][method][i]
+
+			if returns[key][method][i].has_param_override():
+				overload_match = returns[key][method][i]
+
+		if find_overloads and overload_match != null:
+			to_return = overload_match
+		# We have matching parameter values so return the stub value for that
+		elif param_match != null:
+			to_return = param_match
+		# We found a case where the parameters were not specified so return
+		# parameters for that.  Only do this if the null match is not *just*
+		# a paramerter override stub.
+		elif null_match != null and !null_match.is_param_override_only():
+			to_return = null_match
+		else:
+			_lgr.warn(
+				str(
+					"Call to [",
+					method,
+					"] was not stubbed for the supplied parameters ",
+					parameters,
+					".  Null was returned."
+				)
+			)
+
+	return to_return
+
+
+func add_stub(stub_params):
+	if stub_params.stub_method == "_init":
+		_lgr.error("You cannot stub _init.  Super's _init is ALWAYS called.")
+	else:
+		var key = _add_obj_method(
+			stub_params.stub_target, stub_params.stub_method, stub_params.target_subpath
+		)
+		returns[key][stub_params.stub_method].append(stub_params)
+
+
+# Gets a stubbed return value for the object and method passed in.  If the
+# instance was stubbed it will use that, otherwise it will use the path and
+# subpath of the object to try to find a value.
+#
+# It will also use the optional list of parameter values to find a value.  If
+# the object was stubbed with no parameters than any parameters will match.
+# If it was stubbed with specific parameter values then it will try to match.
+# If the parameters do not match BUT there was also an empty parameter list stub
+# then it will return those.
+# If it cannot find anything that matches then null is returned.for
+#
+# Parameters
+# obj:  this should be an instance of a doubled object.
+# method:  the method called
+# parameters:  optional array of parameter vales to find a return value for.
+func get_return(obj, method, parameters = null):
+	var stub_info = _find_stub(obj, method, parameters)
+
+	if stub_info != null:
+		return stub_info.return_val
+	else:
+		return null
+
+
+func should_call_super(obj, method, parameters = null):
+	if _utils.non_super_methods.has(method):
+		return false
+
+	var stub_info = _find_stub(obj, method, parameters)
+
+	var is_partial = false
+	if typeof(obj) != TYPE_STRING:  # some stubber tests test with strings
+		is_partial = obj.__gut_metadata_.is_partial
+	var should = is_partial
+
+	if stub_info != null:
+		should = stub_info.call_super
+	elif !is_partial:
+		# this log message is here because of how the generated doubled scripts
+		# are structured.  With this log msg here, you will only see one
+		# "unstubbed" info instead of multiple.
+		_lgr.info("Unstubbed call to " + method + "::" + _strutils.type2str(obj))
+		should = false
+
+	return should
+
+
+func get_parameter_count(obj, method):
+	var to_return = null
+	var stub_info = _find_stub(obj, method, null, true)
+
+	if stub_info != null and stub_info.has_param_override():
+		to_return = stub_info.parameter_count
+
+	return to_return
+
+
+func get_default_value(obj, method, p_index):
+	var to_return = null
+	var stub_info = _find_stub(obj, method, null, true)
+	if (
+		stub_info != null
+		and stub_info.parameter_defaults != null
+		and stub_info.parameter_defaults.size() > p_index
+	):
+		to_return = stub_info.parameter_defaults[p_index]
+
+	return to_return
+
+
+func clear():
+	returns.clear()
+
+
+func get_logger():
+	return _lgr
+
+
+func set_logger(logger):
+	_lgr = logger
+
+
+func to_s():
+	var text = ""
+	for thing in returns:
+		text += str("-- ", thing, " --\n")
+		for method in returns[thing]:
+			text += str("\t", method, "\n")
+			for i in range(returns[thing][method].size()):
+				text += "\t\t" + returns[thing][method][i].to_s() + "\n"
+
+	if text == "":
+		text = "Stubber is empty"
+
+	return text

addons/gut/summary.gd

@@ -0,0 +1,215 @@
+# ------------------------------------------------------------------------------
+# Contains all the results of a single test.  Allows for multiple asserts results
+# and pending calls.
+# ------------------------------------------------------------------------------
+class Test:
+	var pass_texts = []
+	var fail_texts = []
+	var pending_texts = []
+	var orphans = 0
+
+	# NOTE:  The "failed" and "pending" text must match what is outputted by
+	# the logger in order for text highlighting to occur in summary.
+	func to_s():
+		var pad = "     "
+		var to_return = ""
+		for i in range(fail_texts.size()):
+			to_return += str(pad, "[Failed]:  ", fail_texts[i], "\n")
+		for i in range(pending_texts.size()):
+			to_return += str(pad, "[Pending]:  ", pending_texts[i], "\n")
+		return to_return
+
+	func get_status():
+		var to_return = "no asserts"
+		if pending_texts.size() > 0:
+			to_return = "pending"
+		elif fail_texts.size() > 0:
+			to_return = "fail"
+		elif pass_texts.size() > 0:
+			to_return = "pass"
+
+		return to_return
+
+
+# ------------------------------------------------------------------------------
+# Contains all the results for a single test-script/inner class.  Persists the
+# names of the tests and results and the order in which  the tests were run.
+# ------------------------------------------------------------------------------
+class TestScript:
+	var name = "NOT_SET"
+	var _tests = {}
+	var _test_order = []
+
+	func _init(script_name):
+		name = script_name
+
+	func get_pass_count():
+		var count = 0
+		for key in _tests:
+			count += _tests[key].pass_texts.size()
+		return count
+
+	func get_fail_count():
+		var count = 0
+		for key in _tests:
+			count += _tests[key].fail_texts.size()
+		return count
+
+	func get_pending_count():
+		var count = 0
+		for key in _tests:
+			count += _tests[key].pending_texts.size()
+		return count
+
+	func get_passing_test_count():
+		var count = 0
+		for key in _tests:
+			if _tests[key].fail_texts.size() == 0 and _tests[key].pending_texts.size() == 0:
+				count += 1
+		return count
+
+	func get_failing_test_count():
+		var count = 0
+		for key in _tests:
+			if _tests[key].fail_texts.size() != 0:
+				count += 1
+		return count
+
+	func get_test_obj(obj_name):
+		if !_tests.has(obj_name):
+			_tests[obj_name] = Test.new()
+			_test_order.append(obj_name)
+		return _tests[obj_name]
+
+	func add_pass(test_name, reason):
+		var t = get_test_obj(test_name)
+		t.pass_texts.append(reason)
+
+	func add_fail(test_name, reason):
+		var t = get_test_obj(test_name)
+		t.fail_texts.append(reason)
+
+	func add_pending(test_name, reason):
+		var t = get_test_obj(test_name)
+		t.pending_texts.append(reason)
+
+	func get_tests():
+		return _tests
+
+
+# ------------------------------------------------------------------------------
+# Summary Class
+#
+# This class holds the results of all the test scripts and Inner Classes that
+# were run.
+# ------------------------------------------------------------------------------
+var _scripts = []
+
+
+func add_script(name):
+	_scripts.append(TestScript.new(name))
+
+
+func get_scripts():
+	return _scripts
+
+
+func get_current_script():
+	return _scripts[_scripts.size() - 1]
+
+
+func add_test(test_name):
+	return get_current_script().get_test_obj(test_name)
+
+
+func add_pass(test_name, reason = ""):
+	get_current_script().add_pass(test_name, reason)
+
+
+func add_fail(test_name, reason = ""):
+	get_current_script().add_fail(test_name, reason)
+
+
+func add_pending(test_name, reason = ""):
+	get_current_script().add_pending(test_name, reason)
+
+
+func get_test_text(test_name):
+	return test_name + "\n" + get_current_script().get_test_obj(test_name).to_s()
+
+
+# Gets the count of unique script names minus the .<Inner Class Name> at the
+# end.  Used for displaying the number of scripts without including all the
+# Inner Classes.
+func get_non_inner_class_script_count():
+	var unique_scripts = {}
+	for i in range(_scripts.size()):
+		var ext_loc = _scripts[i].name.find_last(".gd.")
+		if ext_loc == -1:
+			unique_scripts[_scripts[i].name] = 1
+		else:
+			unique_scripts[_scripts[i].name.substr(0, ext_loc + 3)] = 1
+	return unique_scripts.keys().size()
+
+
+func get_totals():
+	var totals = {
+		passing = 0,
+		pending = 0,
+		failing = 0,
+		tests = 0,
+		scripts = 0,
+		passing_tests = 0,
+		failing_tests = 0
+	}
+
+	for i in range(_scripts.size()):
+		totals.passing += _scripts[i].get_pass_count()
+		totals.pending += _scripts[i].get_pending_count()
+		totals.failing += _scripts[i].get_fail_count()
+		totals.tests += _scripts[i]._test_order.size()
+		totals.passing_tests += _scripts[i].get_passing_test_count()
+		totals.failing_tests += _scripts[i].get_failing_test_count()
+
+	totals.scripts = get_non_inner_class_script_count()
+
+	return totals
+
+
+func log_summary_text(lgr):
+	var orig_indent = lgr.get_indent_level()
+	var found_failing_or_pending = false
+
+	for s in range(_scripts.size()):
+		lgr.set_indent_level(0)
+		if _scripts[s].get_fail_count() > 0 or _scripts[s].get_pending_count() > 0:
+			lgr.log(_scripts[s].name, lgr.fmts.underline)
+
+		for t in range(_scripts[s]._test_order.size()):
+			var tname = _scripts[s]._test_order[t]
+			var test = _scripts[s].get_test_obj(tname)
+			if test.fail_texts.size() > 0 or test.pending_texts.size() > 0:
+				found_failing_or_pending = true
+				lgr.log(str("- ", tname))
+				lgr.inc_indent()
+
+				for i in range(test.fail_texts.size()):
+					lgr.failed(test.fail_texts[i])
+				for i in range(test.pending_texts.size()):
+					lgr.pending(test.pending_texts[i])
+				lgr.dec_indent()
+
+	lgr.set_indent_level(0)
+	if !found_failing_or_pending:
+		lgr.log("All tests passed", lgr.fmts.green)
+
+	lgr.log()
+	var _totals = get_totals()
+	lgr.log("Totals", lgr.fmts.yellow)
+	lgr.log(str("Scripts:          ", get_non_inner_class_script_count()))
+	lgr.log(str("Passing tests     ", _totals.passing_tests))
+	lgr.log(str("Failing tests     ", _totals.failing_tests))
+	lgr.log(str("Pending:          ", _totals.pending))
+	lgr.log(str("Asserts:          ", _totals.passing, "/", _totals.failing))
+
+	lgr.set_indent_level(orig_indent)

addons/gut/test_collector.gd

@@ -0,0 +1,310 @@
+# ------------------------------------------------------------------------------
+# Used to keep track of info about each test ran.
+# ------------------------------------------------------------------------------
+class Test:
+	# indicator if it passed or not.  defaults to true since it takes only
+	# one failure to make it not pass.  _fail in gut will set this.
+	var passed = true
+	# the name of the function
+	var name = ""
+	# flag to know if the name has been printed yet.
+	var has_printed_name = false
+	# the number of arguments the method has
+	var arg_count = 0
+	# The number of asserts in the test
+	var assert_count = 0
+	# if the test has been marked pending at anypont during
+	# execution.
+	var pending = false
+
+
+# ------------------------------------------------------------------------------
+# This holds all the meta information for a test script.  It contains the
+# name of the inner class and an array of Test "structs".
+#
+# This class also facilitates all the exporting and importing of tests.
+# ------------------------------------------------------------------------------
+class TestScript:
+	var inner_class_name = null
+	var tests = []
+	var path = null
+	var _utils = null
+	var _lgr = null
+
+	func _init(utils = null, logger = null):
+		_utils = utils
+		_lgr = logger
+
+	func to_s():
+		var to_return = path
+		if inner_class_name != null:
+			to_return += str(".", inner_class_name)
+		to_return += "\n"
+		for i in range(tests.size()):
+			to_return += str("  ", tests[i].name, "\n")
+		return to_return
+
+	func get_new():
+		return load_script().new()
+
+	func load_script():
+		#print('loading:  ', get_full_name())
+		var to_return = load(path)
+		if inner_class_name != null:
+			# If we wanted to do inner classes in inner classses
+			# then this would have to become some kind of loop or recursive
+			# call to go all the way down the chain or this class would
+			# have to change to hold onto the loaded class instead of
+			# just path information.
+			to_return = to_return.get(inner_class_name)
+		return to_return
+
+	func get_filename_and_inner():
+		var to_return = get_filename()
+		if inner_class_name != null:
+			to_return += "." + inner_class_name
+		return to_return
+
+	func get_full_name():
+		var to_return = path
+		if inner_class_name != null:
+			to_return += "." + inner_class_name
+		return to_return
+
+	func get_filename():
+		return path.get_file()
+
+	func has_inner_class():
+		return inner_class_name != null
+
+	# Note:  although this no longer needs to export the inner_class names since
+	#        they are pulled from metadata now, it is easier to leave that in
+	#        so we don't have to cut the export down to unique script names.
+	func export_to(config_file, section):
+		config_file.set_value(section, "path", path)
+		config_file.set_value(section, "inner_class", inner_class_name)
+		var names = []
+		for i in range(tests.size()):
+			names.append(tests[i].name)
+		config_file.set_value(section, "tests", names)
+
+	func _remap_path(source_path):
+		var to_return = source_path
+		if !_utils.file_exists(source_path):
+			_lgr.debug("Checking for remap for:  " + source_path)
+			var remap_path = source_path.get_basename() + ".gd.remap"
+			if _utils.file_exists(remap_path):
+				var cf = ConfigFile.new()
+				cf.load(remap_path)
+				to_return = cf.get_value("remap", "path")
+			else:
+				_lgr.warn("Could not find remap file " + remap_path)
+		return to_return
+
+	func import_from(config_file, section):
+		path = config_file.get_value(section, "path")
+		path = _remap_path(path)
+		# Null is an acceptable value, but you can't pass null as a default to
+		# get_value since it thinks you didn't send a default...then it spits
+		# out red text.  This works around that.
+		var inner_name = config_file.get_value(section, "inner_class", "Placeholder")
+		if inner_name != "Placeholder":
+			inner_class_name = inner_name
+		else:  # just being explicit
+			inner_class_name = null
+
+	func get_test_named(name):
+		return _utils.search_array(tests, "name", name)
+
+
+# ------------------------------------------------------------------------------
+# start test_collector, I don't think I like the name.
+# ------------------------------------------------------------------------------
+var scripts = []
+var _test_prefix = "test_"
+var _test_class_prefix = "Test"
+
+var _utils = load("res://addons/gut/utils.gd").get_instance()
+var _lgr = _utils.get_logger()
+
+
+func _does_inherit_from_test(thing):
+	var base_script = thing.get_base_script()
+	var to_return = false
+	if base_script != null:
+		var base_path = base_script.get_path()
+		if base_path == "res://addons/gut/test.gd":
+			to_return = true
+		else:
+			to_return = _does_inherit_from_test(base_script)
+	return to_return
+
+
+func _populate_tests(test_script):
+	var methods = test_script.load_script().get_script_method_list()
+	for i in range(methods.size()):
+		var name = methods[i]["name"]
+		if name.begins_with(_test_prefix):
+			var t = Test.new()
+			t.name = name
+			t.arg_count = methods[i]["args"].size()
+			test_script.tests.append(t)
+
+
+func _get_inner_test_class_names(loaded):
+	var inner_classes = []
+	var const_map = loaded.get_script_constant_map()
+	for key in const_map:
+		var thing = const_map[key]
+		if _utils.is_gdscript(thing):
+			if key.begins_with(_test_class_prefix):
+				if _does_inherit_from_test(thing):
+					inner_classes.append(key)
+				else:
+					_lgr.warn(
+						str(
+							"Ignoring Inner Class ",
+							key,
+							" because it does not extend res://addons/gut/test.gd"
+						)
+					)
+
+			# This could go deeper and find inner classes within inner classes
+			# but requires more experimentation.  Right now I'm keeping it at
+			# one level since that is what the previous version did and there
+			# has been no demand for deeper nesting.
+			# _populate_inner_test_classes(thing)
+	return inner_classes
+
+
+func _parse_script(test_script):
+	var inner_classes = []
+	var scripts_found = []
+
+	var loaded = load(test_script.path)
+	if _does_inherit_from_test(loaded):
+		_populate_tests(test_script)
+		scripts_found.append(test_script.path)
+		inner_classes = _get_inner_test_class_names(loaded)
+
+	for i in range(inner_classes.size()):
+		var loaded_inner = loaded.get(inner_classes[i])
+		if _does_inherit_from_test(loaded_inner):
+			var ts = TestScript.new(_utils, _lgr)
+			ts.path = test_script.path
+			ts.inner_class_name = inner_classes[i]
+			_populate_tests(ts)
+			scripts.append(ts)
+			scripts_found.append(test_script.path + "[" + inner_classes[i] + "]")
+
+	return scripts_found
+
+
+# -----------------
+# Public
+# -----------------
+func add_script(path):
+	# SHORTCIRCUIT
+	if has_script(path):
+		return []
+
+	var f = File.new()
+	# SHORTCIRCUIT
+	if !f.file_exists(path):
+		_lgr.error("Could not find script:  " + path)
+		return
+
+	var ts = TestScript.new(_utils, _lgr)
+	ts.path = path
+	scripts.append(ts)
+	return _parse_script(ts)
+
+
+func clear():
+	scripts.clear()
+
+
+func has_script(path):
+	var found = false
+	var idx = 0
+	while idx < scripts.size() and !found:
+		if scripts[idx].get_full_name() == path:
+			found = true
+		else:
+			idx += 1
+	return found
+
+
+func export_tests(path):
+	var success = true
+	var f = ConfigFile.new()
+	for i in range(scripts.size()):
+		scripts[i].export_to(f, str("TestScript-", i))
+	var result = f.save(path)
+	if result != OK:
+		_lgr.error(str("Could not save exported tests to [", path, "].  Error code:  ", result))
+		success = false
+	return success
+
+
+func import_tests(path):
+	var success = false
+	var f = ConfigFile.new()
+	var result = f.load(path)
+	if result != OK:
+		_lgr.error(str("Could not load exported tests from [", path, "].  Error code:  ", result))
+	else:
+		var sections = f.get_sections()
+		for key in sections:
+			var ts = TestScript.new(_utils, _lgr)
+			ts.import_from(f, key)
+			_populate_tests(ts)
+			scripts.append(ts)
+		success = true
+	return success
+
+
+func get_script_named(name):
+	return _utils.search_array(scripts, "get_filename_and_inner", name)
+
+
+func get_test_named(script_name, test_name):
+	var s = get_script_named(script_name)
+	if s != null:
+		return s.get_test_named(test_name)
+	else:
+		return null
+
+
+func to_s():
+	var to_return = ""
+	for i in range(scripts.size()):
+		to_return += scripts[i].to_s() + "\n"
+	return to_return
+
+
+# ---------------------
+# Accessors
+# ---------------------
+func get_logger():
+	return _lgr
+
+
+func set_logger(logger):
+	_lgr = logger
+
+
+func get_test_prefix():
+	return _test_prefix
+
+
+func set_test_prefix(test_prefix):
+	_test_prefix = test_prefix
+
+
+func get_test_class_prefix():
+	return _test_class_prefix
+
+
+func set_test_class_prefix(test_class_prefix):
+	_test_class_prefix = test_class_prefix

addons/gut/thing_counter.gd

@@ -0,0 +1,51 @@
+var things = {}
+
+
+func get_unique_count():
+	return things.size()
+
+
+func add(thing):
+	if things.has(thing):
+		things[thing] += 1
+	else:
+		things[thing] = 1
+
+
+func has(thing):
+	return things.has(thing)
+
+
+func get(thing):
+	var to_return = 0
+	if things.has(thing):
+		to_return = things[thing]
+	return to_return
+
+
+func sum():
+	var count = 0
+	for key in things:
+		count += things[key]
+	return count
+
+
+func to_s():
+	var to_return = ""
+	for key in things:
+		to_return += str(key, ":  ", things[key], "\n")
+	to_return += str("sum: ", sum())
+	return to_return
+
+
+func get_max_count():
+	var max_val = null
+	for key in things:
+		if max_val == null or things[key] > max_val:
+			max_val = things[key]
+	return max_val
+
+
+func add_array_items(array):
+	for i in range(array.size()):
+		add(array[i])

addons/gut/utils.gd

@@ -0,0 +1,398 @@
+# ##############################################################################
+#(G)odot (U)nit (T)est class
+#
+# ##############################################################################
+# The MIT License (MIT)
+# =====================
+#
+# Copyright (c) 2020 Tom "Butch" Wesley
+#
+# 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.
+#
+# ##############################################################################
+# Description
+# -----------
+# This class is a PSUEDO SINGLETON.  You should not make instances of it but use
+# the get_instance static method.
+# ##############################################################################
+extends Node
+
+
+# ------------------------------------------------------------------------------
+# The instance name as a function since you can't have static variables.
+# ------------------------------------------------------------------------------
+static func INSTANCE_NAME():
+	return "__GutUtilsInstName__"
+
+
+# ------------------------------------------------------------------------------
+# Gets the root node without having to be in the tree and pushing out an error
+# if we don't have a main loop ready to go yet.
+# ------------------------------------------------------------------------------
+static func get_root_node():
+	var to_return = null
+	var main_loop = Engine.get_main_loop()
+	if main_loop != null:
+		return main_loop.root
+	else:
+		push_error("No Main Loop Yet")
+		return null
+
+
+# ------------------------------------------------------------------------------
+# Get the ONE instance of utils
+# ------------------------------------------------------------------------------
+static func get_instance():
+	var the_root = get_root_node()
+	var inst = null
+	if the_root.has_node(INSTANCE_NAME()):
+		inst = the_root.get_node(INSTANCE_NAME())
+	else:
+		inst = load("res://addons/gut/utils.gd").new()
+		inst.set_name(INSTANCE_NAME())
+		the_root.add_child(inst)
+	return inst
+
+
+var Logger = load("res://addons/gut/logger.gd")  # everything should use get_logger
+var _lgr = null
+
+var _test_mode = false
+
+var AutoFree = load("res://addons/gut/autofree.gd")
+var Comparator = load("res://addons/gut/comparator.gd")
+var CompareResult = load("res://addons/gut/compare_result.gd")
+var DiffTool = load("res://addons/gut/diff_tool.gd")
+var Doubler = load("res://addons/gut/doubler.gd")
+var Gut = load("res://addons/gut/gut.gd")
+var HookScript = load("res://addons/gut/hook_script.gd")
+var InputFactory = load("res://addons/gut/input_factory.gd")
+var InputSender = load("res://addons/gut/input_sender.gd")
+var JunitXmlExport = load("res://addons/gut/junit_xml_export.gd")
+var MethodMaker = load("res://addons/gut/method_maker.gd")
+var OneToMany = load("res://addons/gut/one_to_many.gd")
+var OrphanCounter = load("res://addons/gut/orphan_counter.gd")
+var ParameterFactory = load("res://addons/gut/parameter_factory.gd")
+var ParameterHandler = load("res://addons/gut/parameter_handler.gd")
+var Printers = load("res://addons/gut/printers.gd")
+var ResultExporter = load("res://addons/gut/result_exporter.gd")
+var Spy = load("res://addons/gut/spy.gd")
+var Strutils = load("res://addons/gut/strutils.gd")
+var Stubber = load("res://addons/gut/stubber.gd")
+var StubParams = load("res://addons/gut/stub_params.gd")
+var Summary = load("res://addons/gut/summary.gd")
+var Test = load("res://addons/gut/test.gd")
+var TestCollector = load("res://addons/gut/test_collector.gd")
+var ThingCounter = load("res://addons/gut/thing_counter.gd")
+
+# Source of truth for the GUT version
+var version = "7.3.0"
+# The required Godot version as an array.
+var req_godot = [3, 2, 0]
+# Used for doing file manipulation stuff so as to not keep making File instances.
+# could be a bit of overkill but who cares.
+var _file_checker = File.new()
+# Online fetch of the latest version available on github
+var latest_version = null
+var should_display_latest_version = false
+
+# These methods all call super implicitly.  Stubbing them to call super causes
+# super to be called twice.
+var non_super_methods = [
+	"_init",
+	"_ready",
+	"_notification",
+	"_enter_world",
+	"_exit_world",
+	"_process",
+	"_physics_process",
+	"_exit_tree",
+	"_gui_input	",
+]
+
+
+func _ready() -> void:
+	_http_request_latest_version()
+
+
+func _http_request_latest_version() -> void:
+	var http_request = HTTPRequest.new()
+	http_request.name = "http_request"
+	add_child(http_request)
+	http_request.connect("request_completed", self, "_on_http_request_latest_version_completed")
+	# Perform a GET request. The URL below returns JSON as of writing.
+	var error = http_request.request("https://api.github.com/repos/bitwes/Gut/releases/latest")
+
+
+func _on_http_request_latest_version_completed(result, response_code, headers, body):
+	if not result == HTTPRequest.RESULT_SUCCESS:
+		return
+
+	var response = parse_json(body.get_string_from_utf8())
+	# Will print the user agent string used by the HTTPRequest node (as recognized by httpbin.org).
+	if response:
+		if response.get("html_url"):
+			latest_version = Array(response.html_url.split("/")).pop_back().right(1)
+			if latest_version != version:
+				should_display_latest_version = true
+
+
+const GUT_METADATA = "__gut_metadata_"
+
+enum DOUBLE_STRATEGY { FULL, PARTIAL }
+
+enum DIFF { DEEP, SHALLOW, SIMPLE }
+
+
+# ------------------------------------------------------------------------------
+# Blurb of text with GUT and Godot versions.
+# ------------------------------------------------------------------------------
+func get_version_text():
+	var v_info = Engine.get_version_info()
+	var gut_version_info = str("GUT version:  ", version)
+	var godot_version_info = str(
+		"Godot version:  ", v_info.major, ".", v_info.minor, ".", v_info.patch
+	)
+	return godot_version_info + "\n" + gut_version_info
+
+
+# ------------------------------------------------------------------------------
+# Returns a nice string for erroring out when we have a bad Godot version.
+# ------------------------------------------------------------------------------
+func get_bad_version_text():
+	var ver = PoolStringArray(req_godot).join(".")
+	var info = Engine.get_version_info()
+	var gd_version = str(info.major, ".", info.minor, ".", info.patch)
+	return (
+		"GUT "
+		+ version
+		+ " requires Godot "
+		+ ver
+		+ " or greater.  Godot version is "
+		+ gd_version
+	)
+
+
+# ------------------------------------------------------------------------------
+# Checks the Godot version against req_godot array.
+# ------------------------------------------------------------------------------
+func is_version_ok(engine_info = Engine.get_version_info(), required = req_godot):
+	var is_ok = null
+	var engine_array = [engine_info.major, engine_info.minor, engine_info.patch]
+
+	var idx = 0
+	while is_ok == null and idx < engine_array.size():
+		if int(engine_array[idx]) > int(required[idx]):
+			is_ok = true
+		elif int(engine_array[idx]) < int(required[idx]):
+			is_ok = false
+
+		idx += 1
+
+	# still null means each index was the same.
+	return nvl(is_ok, true)
+
+
+# ------------------------------------------------------------------------------
+# Everything should get a logger through this.
+#
+# When running in test mode this will always return a new logger so that errors
+# are not caused by getting bad warn/error/etc counts.
+# ------------------------------------------------------------------------------
+func get_logger():
+	if _test_mode:
+		return Logger.new()
+	else:
+		if _lgr == null:
+			_lgr = Logger.new()
+		return _lgr
+
+
+# ------------------------------------------------------------------------------
+# return if_null if value is null otherwise return value
+# ------------------------------------------------------------------------------
+func nvl(value, if_null):
+	if value == null:
+		return if_null
+	else:
+		return value
+
+
+# ------------------------------------------------------------------------------
+# returns true if the object has been freed, false if not
+#
+# From what i've read, the weakref approach should work.  It seems to work most
+# of the time but sometimes it does not catch it.  The str comparison seems to
+# fill in the gaps.  I've not seen any errors after adding that check.
+# ------------------------------------------------------------------------------
+func is_freed(obj):
+	var wr = weakref(obj)
+	return !(wr.get_ref() and str(obj) != "[Deleted Object]")
+
+
+# ------------------------------------------------------------------------------
+# Pretty self explanitory.
+# ------------------------------------------------------------------------------
+func is_not_freed(obj):
+	return !is_freed(obj)
+
+
+# ------------------------------------------------------------------------------
+# Checks if the passed in object is a GUT Double or Partial Double.
+# ------------------------------------------------------------------------------
+func is_double(obj):
+	var to_return = false
+	if typeof(obj) == TYPE_OBJECT and is_instance_valid(obj):
+		to_return = obj.has_method("__gut_instance_from_id")
+	return to_return
+
+
+# ------------------------------------------------------------------------------
+# Checks if the passed in is an instance of a class
+# ------------------------------------------------------------------------------
+func is_instance(obj):
+	return typeof(obj) == TYPE_OBJECT and !obj.has_method("new") and !obj.has_method("instance")
+
+
+# ------------------------------------------------------------------------------
+# Checks if the passed in is a GDScript
+# ------------------------------------------------------------------------------
+func is_gdscript(obj):
+	return typeof(obj) == TYPE_OBJECT and str(obj).begins_with("[GDScript:")
+
+
+# ------------------------------------------------------------------------------
+# Returns an array of values by calling get(property) on each element in source
+# ------------------------------------------------------------------------------
+func extract_property_from_array(source, property):
+	var to_return = []
+	for i in source.size():
+		to_return.append(source[i].get(property))
+	return to_return
+
+
+# ------------------------------------------------------------------------------
+# true if file exists, false if not.
+# ------------------------------------------------------------------------------
+func file_exists(path):
+	return _file_checker.file_exists(path)
+
+
+# ------------------------------------------------------------------------------
+# Write a file.
+# ------------------------------------------------------------------------------
+func write_file(path, content):
+	var f = File.new()
+	var result = f.open(path, f.WRITE)
+	if result == OK:
+		f.store_string(content)
+		f.close()
+
+	return result
+
+
+# ------------------------------------------------------------------------------
+# true if what is passed in is null or an empty string.
+# ------------------------------------------------------------------------------
+func is_null_or_empty(text):
+	return text == null or text == ""
+
+
+# ------------------------------------------------------------------------------
+# Get the name of a native class or null if the object passed in is not a
+# native class.
+# ------------------------------------------------------------------------------
+func get_native_class_name(thing):
+	var to_return = null
+	if is_native_class(thing):
+		var newone = thing.new()
+		to_return = newone.get_class()
+		if !newone is Reference:
+			newone.free()
+	return to_return
+
+
+# ------------------------------------------------------------------------------
+# Checks an object to see if it is a GDScriptNativeClass
+# ------------------------------------------------------------------------------
+func is_native_class(thing):
+	var it_is = false
+	if typeof(thing) == TYPE_OBJECT:
+		it_is = str(thing).begins_with("[GDScriptNativeClass:")
+	return it_is
+
+
+# ------------------------------------------------------------------------------
+# Returns the text of a file or an empty string if the file could not be opened.
+# ------------------------------------------------------------------------------
+func get_file_as_text(path):
+	var to_return = ""
+	var f = File.new()
+	var result = f.open(path, f.READ)
+	if result == OK:
+		to_return = f.get_as_text()
+		f.close()
+	return to_return
+
+
+# ------------------------------------------------------------------------------
+# Loops through an array of things and calls a method or checks a property on
+# each element until it finds the returned value.  The item in the array is
+# returned or null if it is not found.
+# ------------------------------------------------------------------------------
+func search_array(ar, prop_method, value):
+	var found = false
+	var idx = 0
+
+	while idx < ar.size() and !found:
+		var item = ar[idx]
+		if item.get(prop_method) != null:
+			if item.get(prop_method) == value:
+				found = true
+		elif item.has_method(prop_method):
+			if item.call(prop_method) == value:
+				found = true
+
+		if !found:
+			idx += 1
+
+	if found:
+		return ar[idx]
+	else:
+		return null
+
+
+func are_datatypes_same(got, expected):
+	return !(typeof(got) != typeof(expected) and got != null and expected != null)
+
+
+func pretty_print(dict):
+	print(str(JSON.print(dict, " ")))
+
+
+func get_script_text(obj):
+	return obj.get_script().get_source_code()
+
+
+func get_singleton_by_name(name):
+	var source = str("var singleton = ", name)
+	var script = GDScript.new()
+	script.set_source_code(source)
+	script.reload()
+	return script.new().singleton

plug.gd

@@ -1,5 +0,0 @@
-extends "res://addons/gd-plug/plug.gd"
-
-
-func _plugging():
-	plug("bitwes/Gut", {commit = "48775e3cb4b0871edbbca6d88876607d7c3cd9be"})

project.godot

@@ -8,6 +8,22 @@
 
 config_version=4
 
+_global_script_classes=[ {
+"base": "Reference",
+"class": "GutHookScript",
+"language": "GDScript",
+"path": "res://addons/gut/hook_script.gd"
+}, {
+"base": "Node",
+"class": "GutTest",
+"language": "GDScript",
+"path": "res://addons/gut/test.gd"
+} ]
+_global_script_class_icons={
+"GutHookScript": "",
+"GutTest": ""
+}
+
 [application]
 
 config/name="Godot Xterm"
@@ -20,7 +36,7 @@ window/vsync/use_vsync=false
 
 [editor_plugins]
 
-enabled=PoolStringArray( "godot_xterm", "gut" )
+enabled=PoolStringArray( "res://addons/godot_xterm/plugin.cfg" )
 
 [rendering]