complex-numbers: add test template (#2140)

* complex-numbers: add test template

Resolves #1937

* complex-numbers: remove commented code

Resolves #1937

* refactor for readability

Author: dvermd

exercises/complex-numbers/.meta/additional_tests.json

@@ -0,0 +1,31 @@
+{
+  "cases": [
+    {
+      "description": "equality of complex numbers",
+      "property": "eq",
+      "input": {
+        "z1": [1, 2],
+        "z2": [1, 2]
+      },
+      "expected": true
+    },
+    {
+      "description": "inequality of real part",
+      "property": "eq",
+      "input": {
+        "z1": [1, 2],
+        "z2": [2, 2]
+      },
+      "expected": false
+    },
+    {
+      "description": "inequality of imaginary part",
+      "property": "eq",
+      "input": {
+        "z1": [1, 2],
+        "z2": [1, 1]
+      },
+      "expected": false
+    }
+  ]
+}

exercises/complex-numbers/.meta/template.j2

@@ -0,0 +1,62 @@
+from __future__ import division
+import math
+
+{% extends "master_template.j2" -%}
+{%- set imports = ["ComplexNumber"] -%}
+
+{%- macro translate_math(item) -%}
+{{ item | replace("pi", "math.pi") | replace("e", "math.e") | replace("ln", "math.log") }}
+{%- endmacro %}
+
+{%- macro formatValue(val) -%}
+{% if val is iterable and val is not string -%}
+    ComplexNumber({% for part in val %}{{ translate_math(part) }},{% endfor %})
+{%- else -%}
+    {{ translate_math(val) }}
+{%- endif -%}
+{%- endmacro -%}
+
+{%- macro smartAssert(case) -%}
+self.assert
+{%- if case["property"] in ["exp", "div"] -%}Almost
+{%- elif case["property"] == "eq" and not case["expected"] -%}Not
+{%- endif -%}Equal
+{%- endmacro -%}
+
+{%- macro operator(prop) -%}
+{% if prop == "add" -%}+
+{%- elif prop == "sub" -%}-
+{%- elif prop == "mul" -%}*
+{%- elif prop == "div" -%}/
+{%- endif -%}
+{%- endmacro -%}
+
+{% macro test_case(case) -%}
+    def test_{{ case["description"] | to_snake }}(self):
+        {% set input = case["input"] -%}
+        {%- set prop = case["property"] -%}
+        {%- set is_callable = prop not in ["real", "imaginary"] -%}
+        {%- set is_builtin = prop in ["abs"] -%}
+        {%- set expected = formatValue(case["expected"]) -%}
+        {%- if input|length == 1 -%}
+            {%- set z = formatValue(input["z"]) -%}
+            {% if is_builtin -%}
+                {%- set actual = prop ~ "(" ~ z ~ ")" -%}
+            {%- else -%}
+                {%- set actual = z ~ "." ~ prop -%}
+                {%- if is_callable -%}
+                    {%- set actual = actual ~ "()" -%}
+                {%- endif -%}
+            {%- endif -%}
+        {%- else -%}
+            {%- set z1 = formatValue(input["z1"]) -%}
+            {%- set z2 = formatValue(input["z2"]) -%}
+            {%- if prop == "eq" -%}
+                {%- set actual = z1 -%}
+                {%- set expected = z2 -%}
+            {%- else -%}
+                {%- set actual = z1 ~ operator(prop) ~ z2 -%}
+            {% endif -%}
+        {%- endif -%}
+        {{ smartAssert(case) }}({{ actual }}, {{expected}})
+{%- endmacro %}

exercises/complex-numbers/complex_numbers_test.py

@@ -1,192 +1,163 @@
 from __future__ import division
+import math
 
 import unittest
 
-import math
-
 from complex_numbers import ComplexNumber
 
-
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
+
 class ComplexNumbersTest(unittest.TestCase):
 
+    # Real part
+
     def test_real_part_of_a_purely_real_number(self):
-        input_number = ComplexNumber(1, 0)
-        self.assertEqual(input_number.real, 1)
+        self.assertEqual(ComplexNumber(1, 0).real, 1)
 
     def test_real_part_of_a_purely_imaginary_number(self):
-        input_number = ComplexNumber(0, 1)
-        self.assertEqual(input_number.real, 0)
+        self.assertEqual(ComplexNumber(0, 1).real, 0)
 
     def test_real_part_of_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 2)
-        self.assertEqual(input_number.real, 1)
+        self.assertEqual(ComplexNumber(1, 2).real, 1)
+
+    # Imaginary part
 
     def test_imaginary_part_of_a_purely_real_number(self):
-        input_number = ComplexNumber(1, 0)
-        self.assertEqual(input_number.imaginary, 0)
+        self.assertEqual(ComplexNumber(1, 0).imaginary, 0)
 
     def test_imaginary_part_of_a_purely_imaginary_number(self):
-        input_number = ComplexNumber(0, 1)
-        self.assertEqual(input_number.imaginary, 1)
+        self.assertEqual(ComplexNumber(0, 1).imaginary, 1)
 
     def test_imaginary_part_of_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 2)
-        self.assertEqual(input_number.imaginary, 2)
+        self.assertEqual(ComplexNumber(1, 2).imaginary, 2)
 
-    def test_equality_of_complex_numbers(self):
-        self.assertEqual(ComplexNumber(1, 2), ComplexNumber(1, 2))
+    def test_imaginary_unit(self):
+        self.assertEqual(
+            ComplexNumber(0, 1) * ComplexNumber(0, 1), ComplexNumber(-1, 0)
+        )
 
-    def test_inequality_of_complex_numbers(self):
-        number = ComplexNumber(1, 2)
-        number_different_real_part = ComplexNumber(2, 2)
-        number_different_imaginary_part = ComplexNumber(1, 1)
-        self.assertNotEqual(number, number_different_real_part)
-        self.assertNotEqual(number, number_different_imaginary_part)
+    # Arithmetic
 
-    def test_imaginary_unit(self):
-        first_input = ComplexNumber(0, 1)
-        second_input = ComplexNumber(0, 1)
-        expected = ComplexNumber(-1, 0)
-        self.assertEqual(first_input * second_input, expected)
+    # Addition
 
     def test_add_purely_real_numbers(self):
-        first_input = ComplexNumber(1, 0)
-        second_input = ComplexNumber(2, 0)
-        expected = ComplexNumber(3, 0)
-        self.assertEqual(first_input + second_input, expected)
+        self.assertEqual(ComplexNumber(1, 0) + ComplexNumber(2, 0), ComplexNumber(3, 0))
 
     def test_add_purely_imaginary_numbers(self):
-        first_input = ComplexNumber(0, 1)
-        second_input = ComplexNumber(0, 2)
-        expected = ComplexNumber(0, 3)
-        self.assertEqual(first_input + second_input, expected)
+        self.assertEqual(ComplexNumber(0, 1) + ComplexNumber(0, 2), ComplexNumber(0, 3))
 
     def test_add_numbers_with_real_and_imaginary_part(self):
-        first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(3, 4)
-        expected = ComplexNumber(4, 6)
-        self.assertEqual(first_input + second_input, expected)
+        self.assertEqual(ComplexNumber(1, 2) + ComplexNumber(3, 4), ComplexNumber(4, 6))
+
+    # Subtraction
 
     def test_subtract_purely_real_numbers(self):
-        first_input = ComplexNumber(1, 0)
-        second_input = ComplexNumber(2, 0)
-        expected = ComplexNumber(-1, 0)
-        self.assertEqual(first_input - second_input, expected)
+        self.assertEqual(
+            ComplexNumber(1, 0) - ComplexNumber(2, 0), ComplexNumber(-1, 0)
+        )
 
     def test_subtract_purely_imaginary_numbers(self):
-        first_input = ComplexNumber(0, 1)
-        second_input = ComplexNumber(0, 2)
-        expected = ComplexNumber(0, -1)
-        self.assertEqual(first_input - second_input, expected)
+        self.assertEqual(
+            ComplexNumber(0, 1) - ComplexNumber(0, 2), ComplexNumber(0, -1)
+        )
 
     def test_subtract_numbers_with_real_and_imaginary_part(self):
-        first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(3, 4)
-        expected = ComplexNumber(-2, -2)
-        self.assertEqual(first_input - second_input, expected)
+        self.assertEqual(
+            ComplexNumber(1, 2) - ComplexNumber(3, 4), ComplexNumber(-2, -2)
+        )
+
+    # Multiplication
 
     def test_multiply_purely_real_numbers(self):
-        first_input = ComplexNumber(1, 0)
-        second_input = ComplexNumber(2, 0)
-        expected = ComplexNumber(2, 0)
-        self.assertEqual(first_input * second_input, expected)
+        self.assertEqual(ComplexNumber(1, 0) * ComplexNumber(2, 0), ComplexNumber(2, 0))
 
     def test_multiply_purely_imaginary_numbers(self):
-        first_input = ComplexNumber(0, 1)
-        second_input = ComplexNumber(0, 2)
-        expected = ComplexNumber(-2, 0)
-        self.assertEqual(first_input * second_input, expected)
+        self.assertEqual(
+            ComplexNumber(0, 1) * ComplexNumber(0, 2), ComplexNumber(-2, 0)
+        )
 
     def test_multiply_numbers_with_real_and_imaginary_part(self):
-        first_input = ComplexNumber(1, 2)
-        second_input = ComplexNumber(3, 4)
-        expected = ComplexNumber(-5, 10)
-        self.assertEqual(first_input * second_input, expected)
+        self.assertEqual(
+            ComplexNumber(1, 2) * ComplexNumber(3, 4), ComplexNumber(-5, 10)
+        )
+
+    # Division
 
     def test_divide_purely_real_numbers(self):
-        input_number = ComplexNumber(1.0, 0.0)
-        expected = ComplexNumber(0.5, 0.0)
-        divider = ComplexNumber(2.0, 0.0)
-        self.assertEqual(input_number / divider, expected)
+        self.assertAlmostEqual(
+            ComplexNumber(1, 0) / ComplexNumber(2, 0), ComplexNumber(0.5, 0)
+        )
 
     def test_divide_purely_imaginary_numbers(self):
-        input_number = ComplexNumber(0, 1)
-        expected = ComplexNumber(0.5, 0)
-        divider = ComplexNumber(0, 2)
-        self.assertEqual(input_number / divider, expected)
+        self.assertAlmostEqual(
+            ComplexNumber(0, 1) / ComplexNumber(0, 2), ComplexNumber(0.5, 0)
+        )
 
     def test_divide_numbers_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 2)
-        expected = ComplexNumber(0.44, 0.08)
-        divider = ComplexNumber(3, 4)
-        self.assertEqual(input_number / divider, expected)
+        self.assertAlmostEqual(
+            ComplexNumber(1, 2) / ComplexNumber(3, 4), ComplexNumber(0.44, 0.08)
+        )
+
+    # Absolute value
 
     def test_absolute_value_of_a_positive_purely_real_number(self):
         self.assertEqual(abs(ComplexNumber(5, 0)), 5)
 
     def test_absolute_value_of_a_negative_purely_real_number(self):
         self.assertEqual(abs(ComplexNumber(-5, 0)), 5)
 
-    def test_absolute_value_of_imaginary_number_positive_imaginary_part(self):
+    def test_absolute_value_of_a_purely_imaginary_number_with_positive_imaginary_part(
+        self
+    ):
         self.assertEqual(abs(ComplexNumber(0, 5)), 5)
 
-    def test_absolute_value_of_imaginary_number_negative_imaginary_part(self):
+    def test_absolute_value_of_a_purely_imaginary_number_with_negative_imaginary_part(
+        self
+    ):
         self.assertEqual(abs(ComplexNumber(0, -5)), 5)
 
     def test_absolute_value_of_a_number_with_real_and_imaginary_part(self):
         self.assertEqual(abs(ComplexNumber(3, 4)), 5)
 
+    # Complex conjugate
+
     def test_conjugate_a_purely_real_number(self):
-        input_number = ComplexNumber(5, 0)
-        expected = ComplexNumber(5, 0)
-        self.assertEqual(input_number.conjugate().real, expected.real)
-        self.assertEqual(input_number.conjugate().imaginary,
-                         expected.imaginary)
+        self.assertEqual(ComplexNumber(5, 0).conjugate(), ComplexNumber(5, 0))
 
     def test_conjugate_a_purely_imaginary_number(self):
-        input_number = ComplexNumber(0, 5)
-        expected = ComplexNumber(0, -5)
-        self.assertEqual(input_number.conjugate().real, expected.real)
-        self.assertEqual(input_number.conjugate().imaginary,
-                         expected.imaginary)
+        self.assertEqual(ComplexNumber(0, 5).conjugate(), ComplexNumber(0, -5))
 
     def test_conjugate_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(1, 1)
-        expected = ComplexNumber(1, -1)
-        self.assertEqual(input_number.conjugate().real, expected.real)
-        self.assertEqual(input_number.conjugate().imaginary,
-                         expected.imaginary)
-
-    def test_eulers_identity_formula(self):
-        input_number = ComplexNumber(0, math.pi)
-        expected = ComplexNumber(-1, 0)
-        actual = input_number.exp()
-        self.assertAlmostEqual(actual.real, expected.real)
-        self.assertAlmostEqual(actual.imaginary, expected.imaginary)
+        self.assertEqual(ComplexNumber(1, 1).conjugate(), ComplexNumber(1, -1))
+
+    # Complex exponential function
+
+    def test_euler_s_identity_formula(self):
+        self.assertAlmostEqual(ComplexNumber(0, math.pi).exp(), ComplexNumber(-1, 0))
 
     def test_exponential_of_0(self):
-        input_number = ComplexNumber(0, 0)
-        expected = ComplexNumber(1, 0)
-        actual = input_number.exp()
-        self.assertAlmostEqual(actual.real, expected.real)
-        self.assertAlmostEqual(actual.imaginary, expected.imaginary)
+        self.assertAlmostEqual(ComplexNumber(0, 0).exp(), ComplexNumber(1, 0))
 
     def test_exponential_of_a_purely_real_number(self):
-        input_number = ComplexNumber(1, 0)
-        expected = ComplexNumber(math.e, 0)
-        actual = input_number.exp()
-        self.assertAlmostEqual(actual.real, expected.real)
-        self.assertAlmostEqual(actual.imaginary, expected.imaginary)
+        self.assertAlmostEqual(ComplexNumber(1, 0).exp(), ComplexNumber(math.e, 0))
 
     def test_exponential_of_a_number_with_real_and_imaginary_part(self):
-        input_number = ComplexNumber(math.log(2), math.pi)
-        expected = ComplexNumber(-2, 0)
-        actual = input_number.exp()
-        self.assertAlmostEqual(actual.real, expected.real)
-        self.assertAlmostEqual(actual.imaginary, expected.imaginary)
+        self.assertAlmostEqual(
+            ComplexNumber(math.log(2), math.pi).exp(), ComplexNumber(-2, 0)
+        )
+
+    # Additional tests for this track
+
+    def test_equality_of_complex_numbers(self):
+        self.assertEqual(ComplexNumber(1, 2), ComplexNumber(1, 2))
+
+    def test_inequality_of_real_part(self):
+        self.assertNotEqual(ComplexNumber(1, 2), ComplexNumber(2, 2))
+
+    def test_inequality_of_imaginary_part(self):
+        self.assertNotEqual(ComplexNumber(1, 2), ComplexNumber(1, 1))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()