diff --git a/config.json b/config.json
index e38f4e1..16c414f 100644
--- a/config.json
+++ b/config.json
@@ -317,6 +317,14 @@
         "prerequisites": [],
         "difficulty": 4
       },
+      {
+        "slug": "secret-handshake",
+        "name": "Secret Handshake",
+        "uuid": "f2b5bfc1-420b-47a3-9955-a8a9a85b76a5",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
+      },
       {
         "slug": "sieve",
         "name": "Sieve",
diff --git a/exercises/practice/secret-handshake/.docs/instructions.md b/exercises/practice/secret-handshake/.docs/instructions.md
new file mode 100644
index 0000000..d2120b9
--- /dev/null
+++ b/exercises/practice/secret-handshake/.docs/instructions.md
@@ -0,0 +1,48 @@
+# Instructions
+
+Your task is to convert a number between 1 and 31 to a sequence of actions in the secret handshake.
+
+The sequence of actions is chosen by looking at the rightmost five digits of the number once it's been converted to binary.
+Start at the right-most digit and move left.
+
+The actions for each number place are:
+
+```plaintext
+00001 = wink
+00010 = double blink
+00100 = close your eyes
+01000 = jump
+10000 = Reverse the order of the operations in the secret handshake.
+```
+
+Let's use the number `9` as an example:
+
+- 9 in binary is `1001`.
+- The digit that is farthest to the right is 1, so the first action is `wink`.
+- Going left, the next digit is 0, so there is no double-blink.
+- Going left again, the next digit is 0, so you leave your eyes open.
+- Going left again, the next digit is 1, so you jump.
+
+That was the last digit, so the final code is:
+
+```plaintext
+wink, jump
+```
+
+Given the number 26, which is `11010` in binary, we get the following actions:
+
+- double blink
+- jump
+- reverse actions
+
+The secret handshake for 26 is therefore:
+
+```plaintext
+jump, double blink
+```
+
+~~~~exercism/note
+If you aren't sure what binary is or how it works, check out [this binary tutorial][intro-to-binary].
+
+[intro-to-binary]: https://medium.com/basecs/bits-bytes-building-with-binary-13cb4289aafa
+~~~~
diff --git a/exercises/practice/secret-handshake/.docs/introduction.md b/exercises/practice/secret-handshake/.docs/introduction.md
new file mode 100644
index 0000000..176b92e
--- /dev/null
+++ b/exercises/practice/secret-handshake/.docs/introduction.md
@@ -0,0 +1,7 @@
+# Introduction
+
+You are starting a secret coding club with some friends and friends-of-friends.
+Not everyone knows each other, so you and your friends have decided to create a secret handshake that you can use to recognize that someone is a member.
+You don't want anyone who isn't in the know to be able to crack the code.
+
+You've designed the code so that one person says a number between 1 and 31, and the other person turns it into a series of actions.
diff --git a/exercises/practice/secret-handshake/.meta/config.json b/exercises/practice/secret-handshake/.meta/config.json
new file mode 100644
index 0000000..4dd6ce0
--- /dev/null
+++ b/exercises/practice/secret-handshake/.meta/config.json
@@ -0,0 +1,21 @@
+{
+  "authors": [
+    "IsaacG"
+  ],
+  "files": {
+    "solution": [
+      "secret_handshake.gd"
+    ],
+    "test": [
+      "secret_handshake_test.gd",
+      "run_tests",
+      "lib/test_runner.gd"
+    ],
+    "example": [
+      ".meta/example.gd"
+    ]
+  },
+  "blurb": "Given a decimal number, convert it to the appropriate sequence of events for a secret handshake.",
+  "source": "Bert, in Mary Poppins",
+  "source_url": "https://www.imdb.com/title/tt0058331/quotes/?item=qt0437047"
+}
diff --git a/exercises/practice/secret-handshake/.meta/example.gd b/exercises/practice/secret-handshake/.meta/example.gd
new file mode 100644
index 0000000..009c8cb
--- /dev/null
+++ b/exercises/practice/secret-handshake/.meta/example.gd
@@ -0,0 +1,10 @@
+const data = ["wink", "double blink", "close your eyes", "jump"]
+
+func commands(number: int):
+	var out = []
+	for i in range(len(data)):
+		if number & (1 << i) != 0:
+			out.append(data[i])
+	if number & (1 << len(data)) != 0:
+		out.reverse()
+	return out
diff --git a/exercises/practice/secret-handshake/.meta/template.j2 b/exercises/practice/secret-handshake/.meta/template.j2
new file mode 100644
index 0000000..ed3db07
--- /dev/null
+++ b/exercises/practice/secret-handshake/.meta/template.j2
@@ -0,0 +1,8 @@
+{% for case in cases %}
+func test_{{ case.func_name }}(solution_script):
+	var got = solution_script.{{ case.property }}({{ case.given }})
+	var want = {{ case.expected | togdscript }}
+	return [got, want]
+
+{% endfor %}
+
diff --git a/exercises/practice/secret-handshake/.meta/tests.toml b/exercises/practice/secret-handshake/.meta/tests.toml
new file mode 100644
index 0000000..f318e52
--- /dev/null
+++ b/exercises/practice/secret-handshake/.meta/tests.toml
@@ -0,0 +1,43 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[b8496fbd-6778-468c-8054-648d03c4bb23]
+description = "wink for 1"
+
+[83ec6c58-81a9-4fd1-bfaf-0160514fc0e3]
+description = "double blink for 10"
+
+[0e20e466-3519-4134-8082-5639d85fef71]
+description = "close your eyes for 100"
+
+[b339ddbb-88b7-4b7d-9b19-4134030d9ac0]
+description = "jump for 1000"
+
+[40499fb4-e60c-43d7-8b98-0de3ca44e0eb]
+description = "combine two actions"
+
+[9730cdd5-ef27-494b-afd3-5c91ad6c3d9d]
+description = "reverse two actions"
+
+[0b828205-51ca-45cd-90d5-f2506013f25f]
+description = "reversing one action gives the same action"
+
+[9949e2ac-6c9c-4330-b685-2089ab28b05f]
+description = "reversing no actions still gives no actions"
+
+[23fdca98-676b-4848-970d-cfed7be39f81]
+description = "all possible actions"
+
+[ae8fe006-d910-4d6f-be00-54b7c3799e79]
+description = "reverse all possible actions"
+
+[3d36da37-b31f-4cdb-a396-d93a2ee1c4a5]
+description = "do nothing for zero"
diff --git a/exercises/practice/secret-handshake/lib/test_runner.gd b/exercises/practice/secret-handshake/lib/test_runner.gd
new file mode 100644
index 0000000..9274583
--- /dev/null
+++ b/exercises/practice/secret-handshake/lib/test_runner.gd
@@ -0,0 +1,467 @@
+class_name TestRunner
+extends SceneTree
+
+class ErrorReader:
+	"""ErrorReader reads from a STDERR file (cmd 2>/file).
+
+	It filters out the less useful Godot output and handles retrieving lines iteratively.
+	"""
+
+	const EXPECTED_GODOT_ERRORS = [
+		"ERROR: Could not create directory: /root/.local\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Error attempting to create data dir: /root/.local/share/godot/app_userdata/[unnamed project].\n   at: ensure_user_data_dir (core/os/os.cpp:344)\n",
+		"ERROR: Could not create editor data directory: /root/.local/share/godot\n   at: EditorPaths (editor/editor_paths.cpp:183)\n",
+		"ERROR: Could not create directory: /root/.config\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Could not create editor config directory: /root/.config/godot\n   at: EditorPaths (editor/editor_paths.cpp:198)\n",
+		"ERROR: Could not create directory: /root/.cache\n   at: make_dir_recursive (core/io/dir_access.cpp:180)\n",
+		"ERROR: Could not create editor cache directory: /root/.cache/godot\n   at: EditorPaths (editor/editor_paths.cpp:219)\n",
+		"ERROR: Can't save resource to empty path. Provide non-empty path or a Resource with non-empty resource_path.\n   at: save (core/io/resource_saver.cpp:105)\n",
+		"ERROR: Error saving editor settings to \n   at: save (editor/editor_settings.cpp:1013)\n",
+	]
+	var already_processed_bytes: int = 0
+	var filename: String = ""
+	var color_sequence = RegEx.create_from_string("\\e\\[\\d[\\d;]*m")
+
+	func _init(filename: String) -> void:
+		self.already_processed_bytes = 0
+		self.filename = filename
+		if not self.filename.is_empty() and ResourceLoader.exists(self.filename):
+			self.get_error_message()
+
+	func check() -> Error:
+		if not FileAccess.file_exists(self.filename):
+			push_error("STDERR must be redirected to '%s' when using '--json'" % self.filename)
+			return ERR_FILE_NOT_FOUND
+		if OS.get_stderr_type() != OS.STD_HANDLE_FILE:
+			push_error("STDERR must be redirected to '%s' when using '--json'" % self.filename)
+			return ERR_FILE_NOT_FOUND
+		return OK
+
+	func get_error_message() -> String:
+		"""
+		Checks the contents of the STDERR file, where error output from the
+		currently running test suite should be stored. If there is any relevant output
+		there, this method will return it. If the file is empty, an empty string is returned.
+
+		This method will remove previously read output from the returned message. It should
+		be called after executing every test, to ensure that the message contains only output
+		relevant for the given test.
+
+		NOTE: running a Godot instance without full access to certain folders in the
+		home directory (`~/.config`, `~/.local`, `~/.cache`) will result in additional
+		errors. This happens when GDScript test runner is executed in Docker. However,
+		these errors do not stop the execution of the program, so they can be ignored.
+		This method filters them out, leaving only the errors caused by the actual tests.
+		"""
+		if self.filename.is_empty():
+			return ""
+
+		var error_output = FileAccess.get_file_as_string(self.filename)
+		error_output = error_output.erase(0, self.already_processed_bytes)
+		self.already_processed_bytes += len(error_output)
+
+		# By default, Godot's error messages are printed with colors. To include the output in the
+		# `results.json` file, color markers need to be removed first.
+		error_output = self.color_sequence.sub(error_output, "", true)
+
+		# Filter out the expected error messages
+		for expected_error in EXPECTED_GODOT_ERRORS:
+			error_output = error_output.replace(expected_error, "")
+
+		return error_output
+
+
+class ResultWriter:
+
+	var json_file: String = ""
+	var stderr: ErrorReader = null
+
+	func _init(json_file: String, stderr: ErrorReader) -> void:
+		self.json_file = json_file
+		self.stderr = stderr
+
+	func delete_existing() -> Error:
+		"""
+		Removes the previous `results.json` file, to ensure that the current test suite will not use it.
+		"""
+		if self.json_file.is_empty():
+			return OK
+		if FileAccess.file_exists(self.json_file):
+			DirAccess.remove_absolute(self.json_file)
+		var error_message: String = self.stderr.get_error_message()
+		if not error_message.is_empty():
+			push_error(error_message)
+			return FAILED
+		return OK
+
+	func write(results: Dictionary) -> Error:
+		"""
+		If output_dir_path is empty, outputs friendly-formatted test results to
+		stdout.
+
+		Otherwise, writes JSON results to results.json in the given path.
+		"""
+		if self.json_file.is_empty():
+			return print_friendly_results(results)
+		else:
+			return write_results_file(results)
+
+	func print_friendly_results(results: Dictionary) -> Error:
+		"""
+		Prints rich results to stdout.
+		"""
+		var rich_results = [""]
+		if results.status == "pass":
+			rich_results.push_back("[color=yellow]Exercise passed!  Nicely done![/color]")
+		else:
+			rich_results.push_back("Exercise has at least one failed test:")
+			for test in results.tests:
+				if test.status == "pass":
+					rich_results.push_back(" %s [color=yellow]passed ✔[/color]" % test.name)
+				else:
+					rich_results.push_back(" %s [color=pink]failed: %s[/color]" % [test.name, test.message])
+		print_rich("\n".join(rich_results))
+		return OK
+
+	func write_results_file(results: Dictionary) -> Error:
+		"""
+		Saves a dictionary as a `results.json` file in the output directory. The file
+		is indented with 4 spaces, keys are not sorted.
+
+		The `results` dictionary represents the full output of a single exercise's
+		test suite, according to the Test Runner Interface documentation:
+
+		https://exercism.org/docs/building/tooling/test-runners/interface
+
+		This method automatically adds `'version' = 2` to the results.
+		"""
+		# Due to keys not being sorted, `version` should be inserted first
+		var full_results = {"version": 2}
+		full_results.merge(results)
+
+		var pretty_results = JSON.stringify(full_results, "  ", false)
+
+		var results_json = FileAccess.open(self.json_file, FileAccess.WRITE)
+		if results_json == null:
+			var err = FileAccess.get_open_error()
+			push_error("Failed to write the file: %s (%s)" % [self.json_file, error_string(err)])
+			return err
+
+		results_json.store_string(pretty_results + "\n")
+		return OK
+
+
+class ArgParser:
+	"""ArgParser reads the cmdline and parses inputs and options."""
+
+	var solution_script_path: String = ""
+	var test_suite_script_path: String = ""
+	var run_all: bool = false
+	var json: bool = false
+	var json_file: String = ""
+
+	func usage(message: String) -> void:
+		print("Usage:")
+		print("test_runner [--all] [--json filename.json] <slug> <solution_directory>")
+		if not message.is_empty():
+			print()
+			print(message)
+
+	func parse_args() -> Error:
+		"""
+		Validates the number of args passed to the script and sets values of the following
+		global variables, based on the given args:
+		* `solution_script_path`
+		* `test_suite_script_path`
+		"""
+		var args = OS.get_cmdline_user_args()
+		var positional: Array = []
+
+		var idx := 0
+		while idx < len(args):
+			var arg = args[idx]
+			if arg == "--all":
+				run_all = true
+			elif arg.begins_with("--json"):
+				if arg.contains("="):
+					var parts = arg.split("=", true, 1)
+					if parts[0] == "--json":
+						self.json = true
+						self.json_file = parts[1]
+					else:
+						usage("Invalid flag %s" % arg)
+						return ERR_INVALID_PARAMETER
+				elif idx + 1 < len(args):
+					self.json = true
+					self.json_file = args[idx + 1]
+					idx += 1
+				else:
+					usage("Flag %s is missing a filename" % arg)
+					return ERR_INVALID_PARAMETER
+			elif arg.begins_with("--"):
+				usage("Invalid flag %s" % arg)
+				return ERR_INVALID_PARAMETER
+			else:
+				positional.append(arg)
+			idx += 1
+
+		if len(positional) != 2:
+			usage("Expecting 2 positional args but got %d" % len(positional))
+			return ERR_INVALID_PARAMETER
+
+		var slug = positional[0]
+		var solution_dir_path = positional[1]
+
+		# Test folders use dashes, but test files use underscores
+		var gdscript_path = solution_dir_path.path_join(slug.replace("-", "_"))
+
+		self.solution_script_path = gdscript_path + ".gd"
+		self.test_suite_script_path = gdscript_path + "_test.gd"
+
+		return OK
+
+	func files() -> Array:
+		return [self.solution_script_path, self.test_suite_script_path]
+
+
+class Runner:
+
+	var test_suite: Object = null
+	var solution: Object = null
+	var stderr: ErrorReader = null
+	var result_writer: ResultWriter = null
+
+	func _init(test_suite: Object, solution: Object, stderr: ErrorReader, result_writer: ResultWriter) -> void:
+		self.test_suite = test_suite
+		self.solution = solution
+		self.stderr = stderr
+		self.result_writer = result_writer
+
+	func extract_methods() -> Dictionary:
+		"""Extract the source code of a method from a script."""
+		var in_func: bool = false
+		var parts = []
+		var methods: Dictionary = {}
+		var name: String = ""
+		var func_re: RegEx = RegEx.create_from_string('^func ([^(]+)\\(')
+		for line in self.test_suite.get_script().source_code.split("\n"):
+			if not in_func:
+				var matched = func_re.search(line)
+				if matched:
+					in_func = true
+					name = matched.get_strings()[1]
+					parts = []
+			elif not line.begins_with("\t") and not line.begins_with(" "):
+				if in_func:
+					in_func = false
+					methods[name] = "\n".join(parts)
+			else:
+				parts.append(line)
+
+		return methods
+
+	func get_failed_test_message(actual, expected) -> String:
+		"""
+		Generates a message for a failed test. If given values are strings,
+		this method will wrap them in single quotes, to distinguish from
+		other types, like integers (e.g. '3' vs 3).
+
+		This method should be used if the actual and expected values for a
+		given test are different, or if they have different types.
+		"""
+		var values = []
+
+		for value in [actual, expected]:
+			var formatted_value = str(value)
+			if typeof(value) == TYPE_STRING:
+				formatted_value = "'{0}'".format([formatted_value])
+			values.append(formatted_value)
+
+		return "Expected output was {1}, actual output was {0}.".format(values)
+
+	func run_tests() -> Array:
+		"""
+		Runs the given test suite agains the given solution script. Returns an Array
+		representing the results of each test case, in the same order that they are defined
+		in the test suite. Each test result is a Dictionary containing 3 values:
+
+		* `name`: the name of the test case
+		* `status`: 'pass', 'fail', or 'error'
+		* `message`: null if the test passed, otherwise it contains the details of the failure/error
+
+		This method will look for methods starting with `test_` in the test script, and
+		then call them with the solution script as the only argument. The `test_` method's
+		name will be used as the `name` value for each test result.
+
+		If any stderr output was generated during the execution of the `test_` method,
+		`status` will be set to 'error'. The test will also receive an 'error' status
+		if calling the `test_` method returned null (which indicates execution issues).
+
+		Otherwise, the `test_` method should return an Array of 2 elements: the actual value,
+		and the expected value. The values will be compared and if they are the same, the test will
+		pass. Otherwise, it will fail, with a relevant message being set by this method.
+		"""
+		var test_results = []
+		var test_codes = self.extract_methods()
+
+		for method in self.test_suite.get_method_list():
+			if not method["name"].begins_with("test_"):
+				continue
+			var test_method_name = method["name"]
+			print("-> " + test_method_name)
+			var test_method = self.test_suite.get(test_method_name)
+
+			var output = test_method.call(self.solution)
+			var error_message = self.stderr.get_error_message()
+
+			if output == null:
+				test_results.append({
+					"name": test_method_name,
+					"status": "error",
+					"message": error_message,
+				})
+			else:
+				var actual = output[0]
+				var expected = output[1]
+
+				var passed = (
+					typeof(actual) == typeof(expected) and
+					actual == expected and
+					error_message.is_empty()
+				)
+
+				var status = "error"
+				if error_message.is_empty():
+					status = "pass" if passed else "fail"
+					error_message = null if passed else self.get_failed_test_message(
+						actual, expected
+					)
+
+				var test_code = test_codes[method["name"]]
+				# The code would be cleaner if the test suite actually checked the values.
+				# Instead, the test suite returns an array with two values which are compared (above).
+				# This `replace()` hides some of that implementation detail by communicating that the
+				# array elements are being compared for equality.
+				test_code = test_code.replace("return [", "assert_equal [")
+				test_code = test_code.replace("\t", "    ")
+				test_code = test_code.dedent().strip_edges()
+
+				test_results.append({
+					"name": test_method_name,
+					"status": status,
+					"message": error_message,
+					"test_code": test_code,
+				})
+
+		return test_results
+
+	func run(run_all: bool) -> void:
+		"""
+		Executes the current suite against the current solution. Stores the results in the
+		`results.json` file in the output dir.
+		"""
+		var test_results = run_tests()
+		var results = {}
+
+		# Check if any tests were executed
+		if len(test_results) == 0:
+			results = {"status": "error", "message": "No tests were executed.", "tests": []}
+		else:
+			results = {"status": "pass", "tests": test_results}
+
+			# If any of the tests failed, change the global status to `fail`
+			for test_result in test_results:
+				if test_result["status"] != "pass":
+					results["status"] = "fail"
+					break
+
+			if not run_all and results["status"] != "pass":
+				var success_count: int = 0
+				for test_result in test_results:
+					if test_result["status"] == "pass":
+						success_count += 1
+
+				var has_failure = false
+				var filtered_results = []
+				for test_result in test_results:
+					if test_result["status"] == "pass":
+						filtered_results.append(test_result)
+					elif not has_failure:
+						has_failure = true
+						test_result["message"] = "Passes %d/%d tests. First failure: %s" % [
+							success_count, len(test_results), test_result["message"],
+						]
+						filtered_results.append(test_result)
+				results["tests"] = filtered_results
+
+		self.result_writer.write(results)
+
+
+func load_script(solution_script_path: String) -> Object:
+	"""Load a script. This helper is needed to catch failures without aborting the error handling."""
+	return load(solution_script_path).new()
+
+
+func load_solution_script(solution_script_path: String, result_writer: ResultWriter, stderr: ErrorReader) -> Array:
+	"""
+	Loads the solution script and saves it in a global variable. In case of any
+	issues, this method will save the `results.json` file with `error` status.
+	"""
+	# Make sure the STDERR file is empty.
+	stderr.get_error_message()
+	var solution_script = load_script(solution_script_path)
+
+	if solution_script == null:
+		var message: String = "The solution file could not be parsed."
+		# Extract the error message, up until the "Failed to load" line
+		# which is specific to the test runner, not the user's solution.
+		var error_message: String = stderr.get_error_message()
+		if not error_message.is_empty():
+			var msg = []
+			var stop = 'ERROR: Failed to load script "%s" with error "Parse error".' % solution_script_path
+			for line in error_message.split("\n"):
+				if line == stop:
+					break
+				msg.append(line)
+			message += "\n" + "\n".join(msg)
+		var results = {"status": "error", "message": message, "tests": []}
+		result_writer.write(results)
+		return [null, ERR_PARSE_ERROR]
+
+	return [solution_script, OK]
+
+
+func _init():
+	# Calling `quit(1)` doesn't stop the program immediately, so a `return` is necessary.
+	# That's why errors are checked directly in `_init()`, instead of calling `quit(1)`
+	# in each method.
+	var args = ArgParser.new()
+	if args.parse_args() != OK:
+		quit(1)
+		return
+	for file in args.files():
+		if not ResourceLoader.exists(file):
+			push_error("File %s not found." % file)
+			quit(1)
+			return
+
+	var stderr = ErrorReader.new("/tmp/stderr")
+	if args.json and stderr.check() != OK:
+		quit(1)
+		return
+
+	var result_writer = ResultWriter.new(args.json_file, stderr)
+	if result_writer.delete_existing() != OK:
+		quit(1)
+		return
+
+	var r = load_solution_script(args.solution_script_path, result_writer, stderr)
+	if r[1] != OK:
+		quit(1)
+		return
+	var solution = r[0]
+
+	var test_suite = load(args.test_suite_script_path).new()
+
+	Runner.new(test_suite, solution, stderr, result_writer).run(args.run_all)
+	quit()
diff --git a/exercises/practice/secret-handshake/run_tests b/exercises/practice/secret-handshake/run_tests
new file mode 100755
index 0000000..ed18a90
--- /dev/null
+++ b/exercises/practice/secret-handshake/run_tests
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+slug=${PWD##*/}
+[[ -f "${slug//-/_}.gd" ]] || die "Error! solution file is missing"
+[[ -f "${slug//-/_}_test.gd" ]] || die "Error! test file is missing"
+exec godot --headless --script ./lib/test_runner.gd -- "${slug}" "${PWD}"
diff --git a/exercises/practice/secret-handshake/secret_handshake.gd b/exercises/practice/secret-handshake/secret_handshake.gd
new file mode 100644
index 0000000..33b0248
--- /dev/null
+++ b/exercises/practice/secret-handshake/secret_handshake.gd
@@ -0,0 +1,2 @@
+func commands(number: int):
+	pass
diff --git a/exercises/practice/secret-handshake/secret_handshake_test.gd b/exercises/practice/secret-handshake/secret_handshake_test.gd
new file mode 100644
index 0000000..272d771
--- /dev/null
+++ b/exercises/practice/secret-handshake/secret_handshake_test.gd
@@ -0,0 +1,64 @@
+func test_wink_for_1(solution_script):
+	var got = solution_script.commands(1)
+	var want = ["wink"]
+	return [got, want]
+
+
+func test_double_blink_for_10(solution_script):
+	var got = solution_script.commands(2)
+	var want = ["double blink"]
+	return [got, want]
+
+
+func test_close_your_eyes_for_100(solution_script):
+	var got = solution_script.commands(4)
+	var want = ["close your eyes"]
+	return [got, want]
+
+
+func test_jump_for_1000(solution_script):
+	var got = solution_script.commands(8)
+	var want = ["jump"]
+	return [got, want]
+
+
+func test_combine_two_actions(solution_script):
+	var got = solution_script.commands(3)
+	var want = ["wink", "double blink"]
+	return [got, want]
+
+
+func test_reverse_two_actions(solution_script):
+	var got = solution_script.commands(19)
+	var want = ["double blink", "wink"]
+	return [got, want]
+
+
+func test_reversing_one_action_gives_the_same_action(solution_script):
+	var got = solution_script.commands(24)
+	var want = ["jump"]
+	return [got, want]
+
+
+func test_reversing_no_actions_still_gives_no_actions(solution_script):
+	var got = solution_script.commands(16)
+	var want = []
+	return [got, want]
+
+
+func test_all_possible_actions(solution_script):
+	var got = solution_script.commands(15)
+	var want = ["wink", "double blink", "close your eyes", "jump"]
+	return [got, want]
+
+
+func test_reverse_all_possible_actions(solution_script):
+	var got = solution_script.commands(31)
+	var want = ["jump", "close your eyes", "double blink", "wink"]
+	return [got, want]
+
+
+func test_do_nothing_for_zero(solution_script):
+	var got = solution_script.commands(0)
+	var want = []
+	return [got, want]