forth: add test template (exercism#2115)

* forth: add test template Resolves: exercism#1949 * forth: restore Exception diversity (exercism#1949)

Author: dvermd

exercises/forth/.meta/template.j2

@@ -0,0 +1,21 @@
+{%- extends"master_template.j2" -%}
+{%setimports = ["evaluate", "StackUnderflowError"] %}
+
+{%macrotest_case(case) -%}
+ def test_{{case["description"] | to_snake }}(self):
+{%- ifcaseiserror_case%}
+{%- ifcase["expected"]["error"] == "divide by zero"%}
+ #{{case["expected"]["error"] }}
+ with self.assertRaisesWithMessage(ZeroDivisionError):
+{%- else%}
+{%- if"stack"incase["expected"]["error"] %}
+ with self.assertRaisesWithMessage(StackUnderflowError):
+{%- else%}
+ with self.assertRaisesWithMessage(ValueError):
+{%- endif%}
+{%- endif%}
+{{case["property"] }}({{case["input"]["instructions"] }})
+{%- else%}
+ self.assertEqual({{case["property"] }}({{case["input"]["instructions"] }}),{{case["expected"] }})
+{%- endif%}
+{%- endmacro%}

exercises/forth/forth_test.py

@@ -2,299 +2,199 @@
 
 fromforthimportevaluate, StackUnderflowError
 
-
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.7.1
 
-classForthUtilities(unittest.TestCase):
-# Utility functions
-defassertRaisesWithMessage(self, exception):
-returnself.assertRaisesRegex(exception, r".+")
 
+classForthTest(unittest.TestCase):
+
+# parsing and numbers
 
-classForthParsingTest(ForthUtilities):
-deftest_numbers_just_get_pushed_to_stack(self):
-input_data= ["1 2 3 4 5"]
-expected= [1, 2, 3, 4, 5]
-self.assertEqual(evaluate(input_data), expected)
+deftest_numbers_just_get_pushed_onto_the_stack(self):
+self.assertEqual(evaluate(["1 2 3 4 5"]), [1, 2, 3, 4, 5])
 
+# addition
 
-classForthAdditionTest(ForthUtilities):
 deftest_can_add_two_numbers(self):
-input_data= ["1 2 +"]
-expected= [3]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 +"]), [3])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["+"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["+"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 +"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 +"])
 
+# subtraction
 
-classForthSubtractionTest(ForthUtilities):
 deftest_can_subtract_two_numbers(self):
-input_data= ["3 4 -"]
-expected= [-1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["3 4 -"]), [-1])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["-"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["-"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 -"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 -"])
 
+# multiplication
 
-classForthMultiplicationTest(ForthUtilities):
 deftest_can_multiply_two_numbers(self):
-input_data= ["2 4 *"]
-expected= [8]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["2 4 *"]), [8])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["*"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["*"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 *"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 *"])
 
+# division
 
-classForthDivisionTest(ForthUtilities):
 deftest_can_divide_two_numbers(self):
-input_data= ["12 3 /"]
-expected= [4]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["12 3 /"]), [4])
 
 deftest_performs_integer_division(self):
-input_data= ["8 3 /"]
-expected= [2]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["8 3 /"]), [2])
 
 deftest_errors_if_dividing_by_zero(self):
-input_data= ["4 0 /"]
+# divide by zero
 withself.assertRaisesWithMessage(ZeroDivisionError):
-evaluate(input_data)
+evaluate(["4 0 /"])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["/"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["/"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 /"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 /"])
 
+# combined arithmetic
 
-classForthCombinedArithmeticTest(ForthUtilities):
 deftest_addition_and_subtraction(self):
-input_data= ["1 2 + 4 -"]
-expected= [-1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 + 4 -"]), [-1])
 
 deftest_multiplication_and_division(self):
-input_data= ["2 4 * 3 /"]
-expected= [2]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["2 4 * 3 /"]), [2])
 
+# dup
 
-classForthDupTest(ForthUtilities):
 deftest_copies_a_value_on_the_stack(self):
-input_data= ["1 dup"]
-expected= [1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 dup"]), [1, 1])
 
 deftest_copies_the_top_value_on_the_stack(self):
-input_data= ["1 2 dup"]
-expected= [1, 2, 2]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 dup"]), [1, 2, 2])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["dup"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["dup"])
 
+# drop
 
-classForthDropTest(ForthUtilities):
 deftest_removes_the_top_value_on_the_stack_if_it_is_the_only_one(self):
-input_data= ["1 drop"]
-expected= []
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 drop"]), [])
 
-deftest_removes_the_top_value_on_the_stack_if_it_not_the_only_one(self):
-input_data= ["3 4 drop"]
-expected= [3]
-self.assertEqual(evaluate(input_data), expected)
+deftest_removes_the_top_value_on_the_stack_if_it_is_not_the_only_one(self):
+self.assertEqual(evaluate(["1 2 drop"]), [1])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["drop"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["drop"])
 
+# swap
 
-classForthSwapTest(ForthUtilities):
-deftest_swaps_only_two_values_on_stack(self):
-input_data= ["1 2 swap"]
-expected= [2, 1]
-self.assertEqual(evaluate(input_data), expected)
+deftest_swaps_the_top_two_values_on_the_stack_if_they_are_the_only_ones(self):
+self.assertEqual(evaluate(["1 2 swap"]), [2, 1])
 
-deftest_swaps_two_two_values_on_stack(self):
-input_data= ["1 2 3 swap"]
-expected= [1, 3, 2]
-self.assertEqual(evaluate(input_data), expected)
+deftest_swaps_the_top_two_values_on_the_stack_if_they_are_not_the_only_ones(self):
+self.assertEqual(evaluate(["1 2 3 swap"]), [1, 3, 2])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["swap"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["swap"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 swap"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 swap"])
 
+# over
 
-classForthOverTest(ForthUtilities):
 deftest_copies_the_second_element_if_there_are_only_two(self):
-input_data= ["1 2 over"]
-expected= [1, 2, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 over"]), [1, 2, 1])
 
 deftest_copies_the_second_element_if_there_are_more_than_two(self):
-input_data= ["1 2 3 over"]
-expected= [1, 2, 3, 2]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 3 over"]), [1, 2, 3, 2])
 
 deftest_errors_if_there_is_nothing_on_the_stack(self):
-input_data= ["over"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["over"])
 
 deftest_errors_if_there_is_only_one_value_on_the_stack(self):
-input_data= ["1 over"]
 withself.assertRaisesWithMessage(StackUnderflowError):
-evaluate(input_data)
+evaluate(["1 over"])
 
+# user-defined words
 
-classForthUserDefinedWordsTest(ForthUtilities):
 deftest_can_consist_of_built_in_words(self):
-input_data= [
-": dup-twice dup dup ;",
-"1 dup-twice"
- ]
-expected= [1, 1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": dup-twice dup dup ;", "1 dup-twice"]), [1, 1, 1])
 
 deftest_execute_in_the_right_order(self):
-input_data= [
-": countup 1 2 3 ;",
-"countup"
- ]
-expected= [1, 2, 3]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": countup 1 2 3 ;", "countup"]), [1, 2, 3])
 
 deftest_can_override_other_user_defined_words(self):
-input_data= [
-": foo dup ;",
-": foo dup dup ;",
-"1 foo"
- ]
-expected= [1, 1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(
+evaluate([": foo dup ;", ": foo dup dup ;", "1 foo"]), [1, 1, 1]
+ )
 
 deftest_can_override_built_in_words(self):
-input_data= [
-": swap dup ;",
-"1 swap"
- ]
-expected= [1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": swap dup ;", "1 swap"]), [1, 1])
 
 deftest_can_override_built_in_operators(self):
-input_data= [
-": + * ;",
-"3 4 +"
- ]
-expected= [12]
-self.assertEqual(evaluate(input_data), expected)
-
-deftest_can_use_different_words_with_same_name(self):
-input_data= [
-": foo 5 ;",
-": bar foo ;",
-": foo 6 ;",
-"bar foo"
- ]
-expected= [5, 6]
-self.assertEqual(evaluate(input_data), expected)
-
-deftest_can_define_word_that_uses_word_with_same_name(self):
-input_data= [
-": foo 10 ;",
-": foo foo 1 + ;",
-"foo"
- ]
-expected= [11]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": + * ;", "3 4 +"]), [12])
+
+deftest_can_use_different_words_with_the_same_name(self):
+self.assertEqual(
+evaluate([": foo 5 ;", ": bar foo ;", ": foo 6 ;", "bar foo"]), [5, 6]
+ )
+
+deftest_can_define_word_that_uses_word_with_the_same_name(self):
+self.assertEqual(evaluate([": foo 10 ;", ": foo foo 1 + ;", "foo"]), [11])
 
 deftest_cannot_redefine_numbers(self):
-input_data= [": 1 2 ;"]
 withself.assertRaisesWithMessage(ValueError):
-evaluate(input_data)
+evaluate([": 1 2 ;"])
 
 deftest_errors_if_executing_a_non_existent_word(self):
-input_data= ["foo"]
 withself.assertRaisesWithMessage(ValueError):
-evaluate(input_data)
+evaluate(["foo"])
 
+# case-insensitivity
 
-classForthCaseInsensitivityTest(ForthUtilities):
 deftest_dup_is_case_insensitive(self):
-input_data= ["1 DUP Dup dup"]
-expected= [1, 1, 1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 DUP Dup dup"]), [1, 1, 1, 1])
 
 deftest_drop_is_case_insensitive(self):
-input_data= ["1 2 3 4 DROP Drop drop"]
-expected= [1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 3 4 DROP Drop drop"]), [1])
 
 deftest_swap_is_case_insensitive(self):
-input_data= ["1 2 SWAP 3 Swap 4 swap"]
-expected= [2, 3, 4, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 SWAP 3 Swap 4 swap"]), [2, 3, 4, 1])
 
 deftest_over_is_case_insensitive(self):
-input_data= ["1 2 OVER Over over"]
-expected= [1, 2, 1, 2, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate(["1 2 OVER Over over"]), [1, 2, 1, 2, 1])
 
 deftest_user_defined_words_are_case_insensitive(self):
-input_data= [
-": foo dup ;",
-"1 FOO Foo foo"
- ]
-expected= [1, 1, 1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": foo dup ;", "1 FOO Foo foo"]), [1, 1, 1, 1])
 
 deftest_definitions_are_case_insensitive(self):
-input_data= [
-": SWAP DUP Dup dup ;",
-"1 swap"
- ]
-expected= [1, 1, 1, 1]
-self.assertEqual(evaluate(input_data), expected)
+self.assertEqual(evaluate([": SWAP DUP Dup dup ;", "1 swap"]), [1, 1, 1, 1])
+
+# Utility functions
+defassertRaisesWithMessage(self, exception):
+returnself.assertRaisesRegex(exception, r".+")
 
 
-if__name__=='__main__':
+if__name__=="__main__":
 unittest.main()