Custom set add test template (#2128)

* Partially implement test template for custom-set

* Partially implement test template for custom-set

* Add more functionality

* Fix bugs

* Fix bugs

* Add template for add

* Fix bugs

* Add a macro for empty list

* Refactor

Author: tqa236

config/generator_macros.j2

@@ -43,3 +43,11 @@ from {{ exercise | to_snake }} import ({% if imports -%}
 if __name__ == '__main__':
     unittest.main()
 {%- endmacro %}
+
+{% macro empty_set(set, list, class_name) -%}
+{%- if list|length > 0 -%}
+{{ set }} = {{ class_name }}({{ list }})
+{%- else -%}
+{{ set }} = {{ class_name }}()
+{%- endif %}
+{%- endmacro %}

exercises/custom-set/.meta/template.j2

@@ -0,0 +1,48 @@
+{%- import "generator_macros.j2" as macros with context -%}
+{% set class_name = exercise | camel_case -%}
+{{ macros.header([class_name]) }}
+
+class {{ class_name }}Test(unittest.TestCase):
+    {% for case in cases -%}
+    {% for subcase in case["cases"] -%}
+    def test_{{ subcase["description"] | to_snake }}(self):
+        {% set expected = subcase["expected"] -%}
+        {% set property = subcase["property"] -%}
+        {% if "set" in subcase["input"] -%}
+        {% set list = subcase["input"]["set"] -%}
+        {{ macros.empty_set("sut", list, class_name) }}
+        {% else -%}
+        {% set list1 = subcase["input"]["set1"] -%}
+        {{ macros.empty_set("set1", list1, class_name) }}
+        {% set list2 = subcase["input"]["set2"] -%}
+        {{ macros.empty_set("set2", list2, class_name) }}
+        {% endif -%}
+        {% if expected is iterable -%}
+        {{ macros.empty_set("expected", expected, class_name) }}
+        {% elif expected == true -%}
+        {%- set flag = "" -%}
+        {% else -%}
+        {%- set flag = "Not" -%}
+        {% endif -%}
+        {% if property == "add" -%}
+        sut.{{ property }}({{ subcase["input"]["element"] }})
+        self.assertEqual(sut, expected)
+        {% elif property == "contains" -%}
+        self.assert{{ flag }}In({{ subcase["input"]["element"] }}, sut)
+        {% elif property == "difference" -%}
+        self.assertEqual(set1 - set2, expected)
+        {% elif property == "empty" -%}
+        self.assertIs(sut.is{{ property }}(), {{ expected }})
+        {% elif property == "equal" -%}
+        self.assert{{ flag }}Equal(set1, set2)
+        {% elif property == "intersection" -%}
+        self.assertEqual(set1.{{ property }}(set2), expected)
+        {% elif property == "union" -%}
+        self.assertEqual(set1 + set2, expected)
+        {% else -%}
+        self.assertIs(set1.is{{ property }}(set2), {{ expected }})
+        {% endif %}
+    {% endfor %}
+    {% endfor %}
+
+{{ macros.footer() }}

exercises/custom-set/custom_set_test.py

@@ -2,9 +2,9 @@
 
 from custom_set import CustomSet
 
-
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
+
 class CustomSetTest(unittest.TestCase):
     def test_sets_with_no_elements_are_empty(self):
         sut = CustomSet()
@@ -14,69 +14,69 @@ def test_sets_with_elements_are_not_empty(self):
         sut = CustomSet([1])
         self.assertIs(sut.isempty(), False)
 
-    def test_empty_set_contains_nothing(self):
+    def test_nothing_is_contained_in_an_empty_set(self):
         sut = CustomSet()
         self.assertNotIn(1, sut)
 
-    def test_set_contains_when_element_in_set(self):
-        sut = CustomSet([1])
+    def test_when_the_element_is_in_the_set(self):
+        sut = CustomSet([1, 2, 3])
         self.assertIn(1, sut)
 
-    def test_set_does_not_contains_when_element_not_in_set(self):
+    def test_when_the_element_is_not_in_the_set(self):
         sut = CustomSet([1, 2, 3])
         self.assertNotIn(4, sut)
 
-    def test_empty_set_is_subset_of_another_empty_set(self):
+    def test_empty_set_is_a_subset_of_another_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet()
         self.assertIs(set1.issubset(set2), True)
 
-    def test_empty_set_is_subset_of_non_empty_set(self):
+    def test_empty_set_is_a_subset_of_non_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([1])
         self.assertIs(set1.issubset(set2), True)
 
-    def test_non_empty_set_is_not_subet_of_empty_set(self):
+    def test_non_empty_set_is_not_a_subset_of_empty_set(self):
         set1 = CustomSet([1])
         set2 = CustomSet()
         self.assertIs(set1.issubset(set2), False)
 
-    def test_set_is_subset_of_set_with_exact_same_elements(self):
+    def test_set_is_a_subset_of_set_with_exact_same_elements(self):
         set1 = CustomSet([1, 2, 3])
         set2 = CustomSet([1, 2, 3])
         self.assertIs(set1.issubset(set2), True)
 
-    def test_set_is_subset_of_larger_set_with_same_elements(self):
+    def test_set_is_a_subset_of_larger_set_with_same_elements(self):
         set1 = CustomSet([1, 2, 3])
         set2 = CustomSet([4, 1, 2, 3])
         self.assertIs(set1.issubset(set2), True)
 
-    def test_set_not_subset_of_set_that_does_not_contain_its_elements(self):
+    def test_set_is_not_a_subset_of_set_that_does_not_contain_its_elements(self):
         set1 = CustomSet([1, 2, 3])
         set2 = CustomSet([4, 1, 3])
         self.assertIs(set1.issubset(set2), False)
 
-    def test_empty_set_disjoint_with_itself(self):
+    def test_the_empty_set_is_disjoint_with_itself(self):
         set1 = CustomSet()
         set2 = CustomSet()
         self.assertIs(set1.isdisjoint(set2), True)
 
-    def test_empty_set_disjoint_with_non_empty_set(self):
+    def test_empty_set_is_disjoint_with_non_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([1])
         self.assertIs(set1.isdisjoint(set2), True)
 
-    def test_non_empty_set_disjoint_with_empty_set(self):
+    def test_non_empty_set_is_disjoint_with_empty_set(self):
         set1 = CustomSet([1])
         set2 = CustomSet()
         self.assertIs(set1.isdisjoint(set2), True)
 
-    def test_sets_not_disjoint_if_element_is_shared(self):
+    def test_sets_are_not_disjoint_if_they_share_an_element(self):
         set1 = CustomSet([1, 2])
         set2 = CustomSet([2, 3])
         self.assertIs(set1.isdisjoint(set2), False)
 
-    def test_sets_disjoint_if_not_elements_are_shared(self):
+    def test_sets_are_disjoint_if_they_share_no_elements(self):
         set1 = CustomSet([1, 2])
         set2 = CustomSet([3, 4])
         self.assertIs(set1.isdisjoint(set2), True)
@@ -86,17 +86,17 @@ def test_empty_sets_are_equal(self):
         set2 = CustomSet()
         self.assertEqual(set1, set2)
 
-    def test_empty_set_not_equal_to_non_empty_set(self):
+    def test_empty_set_is_not_equal_to_non_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([1, 2, 3])
         self.assertNotEqual(set1, set2)
 
-    def test_non_empty_set_not_equal_to_empty_set(self):
+    def test_non_empty_set_is_not_equal_to_empty_set(self):
         set1 = CustomSet([1, 2, 3])
         set2 = CustomSet()
         self.assertNotEqual(set1, set2)
 
-    def test_sets_with_same_exact_same_elements_are_equal(self):
+    def test_sets_with_the_same_elements_are_equal(self):
         set1 = CustomSet([1, 2])
         set2 = CustomSet([2, 1])
         self.assertEqual(set1, set2)
@@ -113,89 +113,93 @@ def test_set_is_not_equal_to_larger_set_with_same_elements(self):
 
     def test_add_to_empty_set(self):
         sut = CustomSet()
-        sut.add(1)
-        expected = CustomSet([1])
+        expected = CustomSet([3])
+        sut.add(3)
         self.assertEqual(sut, expected)
 
     def test_add_to_non_empty_set(self):
         sut = CustomSet([1, 2, 4])
-        sut.add(3)
         expected = CustomSet([1, 2, 3, 4])
+        sut.add(3)
         self.assertEqual(sut, expected)
 
-    def test_adding_existing_element_does_not_change_set(self):
+    def test_adding_an_existing_element_does_not_change_the_set(self):
         sut = CustomSet([1, 2, 3])
-        sut.add(3)
         expected = CustomSet([1, 2, 3])
+        sut.add(3)
         self.assertEqual(sut, expected)
 
-    def test_intersection_of_two_empty_sets_is_empty_set(self):
+    def test_intersection_of_two_empty_sets_is_an_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet()
         expected = CustomSet()
         self.assertEqual(set1.intersection(set2), expected)
 
-    def test_intersection_of_empty_set_and_non_empty_set_is_empty_set(self):
+    def test_intersection_of_an_empty_set_and_non_empty_set_is_an_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([3, 2, 5])
         expected = CustomSet()
         self.assertEqual(set1.intersection(set2), expected)
 
-    def test_intersection_of_non_empty_set_and_empty_set_is_empty_set(self):
+    def test_intersection_of_a_non_empty_set_and_an_empty_set_is_an_empty_set(self):
         set1 = CustomSet([1, 2, 3, 4])
         set2 = CustomSet()
         expected = CustomSet()
         self.assertEqual(set1.intersection(set2), expected)
 
-    def test_intersection_of_sets_with_no_shared_elements_is_empty_set(self):
+    def test_intersection_of_two_sets_with_no_shared_elements_is_an_empty_set(self):
         set1 = CustomSet([1, 2, 3])
         set2 = CustomSet([4, 5, 6])
         expected = CustomSet()
         self.assertEqual(set1.intersection(set2), expected)
 
-    def test_intersection_contains_shared_elements_only(self):
+    def test_intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements(
+        self
+    ):
         set1 = CustomSet([1, 2, 3, 4])
         set2 = CustomSet([3, 2, 5])
         expected = CustomSet([2, 3])
         self.assertEqual(set1.intersection(set2), expected)
 
-    def test_difference_of_two_empty_sets_is_empty_set(self):
+    def test_difference_of_two_empty_sets_is_an_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet()
         expected = CustomSet()
         self.assertEqual(set1 - set2, expected)
 
-    def test_difference_of_empty_set_and_non_empty_set_is_empty_set(self):
+    def test_difference_of_empty_set_and_non_empty_set_is_an_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([3, 2, 5])
         expected = CustomSet()
         self.assertEqual(set1 - set2, expected)
 
-    def test_difference_of_non_empty_set_and_empty_set_is_non_empty_set(self):
+    def test_difference_of_a_non_empty_set_and_an_empty_set_is_the_non_empty_set(self):
         set1 = CustomSet([1, 2, 3, 4])
         set2 = CustomSet()
         expected = CustomSet([1, 2, 3, 4])
         self.assertEqual(set1 - set2, expected)
 
-    def test_difference_of_non_empty_sets_elements_in_first_set_only(self):
+    def test_difference_of_two_non_empty_sets_is_a_set_of_elements_that_are_only_in_the_first_set(
+        self
+    ):
         set1 = CustomSet([3, 2, 1])
         set2 = CustomSet([2, 4])
         expected = CustomSet([1, 3])
         self.assertEqual(set1 - set2, expected)
 
-    def test_union_of_empty_sets_is_empty_set(self):
+    def test_union_of_empty_sets_is_an_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet()
         expected = CustomSet()
         self.assertEqual(set1 + set2, expected)
 
-    def test_union_of_empty_set_and_non_empty_set_is_the_non_empty_set(self):
+    def test_union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set(self):
         set1 = CustomSet()
         set2 = CustomSet([2])
         expected = CustomSet([2])
         self.assertEqual(set1 + set2, expected)
 
-    def test_union_of_non_empty_set_and_empty_set_is_the_non_empty_set(self):
+    def test_union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set(self):
         set1 = CustomSet([1, 3])
         set2 = CustomSet()
         expected = CustomSet([1, 3])
@@ -204,9 +208,9 @@ def test_union_of_non_empty_set_and_empty_set_is_the_non_empty_set(self):
     def test_union_of_non_empty_sets_contains_all_unique_elements(self):
         set1 = CustomSet([1, 3])
         set2 = CustomSet([2, 3])
-        expected = CustomSet([1, 2, 3])
+        expected = CustomSet([3, 2, 1])
         self.assertEqual(set1 + set2, expected)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()