[WIP] Full-scale test update

exercises/acronym/acronym_test.py

@@ -3,7 +3,7 @@
 from acronym import abbreviate
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
 class AcronymTest(unittest.TestCase):
     def test_basic(self):
@@ -16,12 +16,9 @@ def test_punctuation(self):
         self.assertEqual(abbreviate('First In, First Out'), 'FIFO')
 
     def test_all_caps_words(self):
-        self.assertEqual(abbreviate('PHP: Hypertext Preprocessor'), 'PHP')
-
-    def test_non_acronym_all_caps_word(self):
         self.assertEqual(abbreviate('GNU Image Manipulation Program'), 'GIMP')
 
-    def test_hyphenated(self):
+    def test_punctuation_without_whitespace(self):
         self.assertEqual(
             abbreviate('Complementary metal-oxide semiconductor'), 'CMOS')
 

exercises/all-your-base/all_your_base.py

@@ -1,2 +1,2 @@
-def rebase(from_base, digits, to_base):
+def rebase(input_base, digits, output_base):
     pass

exercises/all-your-base/all_your_base_test.py

@@ -3,7 +3,7 @@
 from all_your_base import rebase
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.3.0
 
 class AllYourBaseTests(unittest.TestCase):
 
@@ -43,15 +43,15 @@ def test_multiple_zeroes(self):
     def test_leading_zeros(self):
         self.assertEqual(rebase(7, [0, 6, 0], 10), [4, 2])
 
-    def test_first_base_is_one(self):
+    def test_input_base_is_one(self):
         with self.assertRaisesWithMessage(ValueError):
-            rebase(1, [], 10)
+            rebase(1, [0], 10)
 
-    def test_first_base_is_zero(self):
+    def test_input_base_is_zero(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(0, [], 10)
 
-    def test_first_base_is_negative(self):
+    def test_input_base_is_negative(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(-2, [1], 10)
 
@@ -63,15 +63,15 @@ def test_invalid_positive_digit(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1, 2, 1, 0, 1, 0], 10)
 
-    def test_second_base_is_one(self):
+    def test_output_base_is_one(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1, 0, 1, 0, 1, 0], 1)
 
-    def test_second_base_is_zero(self):
+    def test_output_base_is_zero(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(10, [7], 0)
 
-    def test_second_base_is_negative(self):
+    def test_output_base_is_negative(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1], -7)
 

exercises/allergies/allergies_test.py

@@ -7,7 +7,7 @@
     unittest.TestCase.assertCountEqual = unittest.TestCase.assertItemsEqual
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class AllergiesTests(unittest.TestCase):
     def test_no_allergies_means_not_allergic(self):

exercises/alphametics/alphametics_test.py

@@ -66,6 +66,47 @@ def test_puzzle_with_10_letters(self):
              "S": 6,
              "T": 9})
 
+    def test_puzzle_with_10_letters_and_41_addends(self):
+        self.assertEqual(
+            solve(
+                "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I"
+                " + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS"
+                " + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES"
+                " + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE"
+                " + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE"
+                " + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE +"
+                " HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES"
+                " + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER"
+                " + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS +"
+                " SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST +"
+                " HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF"
+                " + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE"
+                " + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL +"
+                " ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR"
+                " + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS"
+                " + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE +"
+                " HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR"
+                " + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE +"
+                " THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL"
+                " + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF +"
+                " THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO"
+                " + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS +"
+                " LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST +"
+                " SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR +"
+                " AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE =="
+                " FORTRESSES"
+            ),
+            {"A": 1,
+             "E": 0,
+             "F": 5,
+             "H": 8,
+             "I": 7,
+             "L": 2,
+             "O": 6,
+             "R": 3,
+             "S": 4,
+             "T": 9})
+
 
 if __name__ == '__main__':
     unittest.main()

exercises/anagram/anagram_test.py

@@ -3,20 +3,13 @@
 from anagram import detect_anagrams
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class AnagramTests(unittest.TestCase):
     def test_no_matches(self):
         candidates = ["hello", "world", "zombies", "pants"]
         self.assertEqual(detect_anagrams("diaper", candidates), [])
 
-    def test_detects_simple_anagram(self):
-        candidates = ["tan", "stand", "at"]
-        self.assertEqual(detect_anagrams("ant", candidates), ["tan"])
-
-    def test_does_not_detect_false_positives(self):
-        self.assertEqual(detect_anagrams("galea", ["eagle"]), [])
-
     def test_detects_two_anagrams(self):
         candidates = ["stream", "pigeon", "maters"]
         self.assertEqual(
@@ -37,10 +30,6 @@ def test_detects_three_anagrams(self):
             detect_anagrams("allergy", candidates),
             ["gallery", "regally", "largely"])
 
-    def test_does_not_detect_identical_words(self):
-        candidates = ["corn", "dark", "Corn", "rank", "CORN", "cron", "park"]
-        self.assertEqual(detect_anagrams("corn", candidates), ["cron"])
-
     def test_does_not_detect_non_anagrams_with_identical_checksum(self):
         self.assertEqual(detect_anagrams("mass", ["last"]), [])
 
@@ -59,9 +48,6 @@ def test_detects_anagrams_using_case_insensitive_possible_matches(self):
         self.assertEqual(
             detect_anagrams("orchestra", candidates), ["Carthorse"])
 
-    def test_does_not_detect_a_word_as_its_own_anagram(self):
-        self.assertEqual(detect_anagrams("banana", ["Banana"]), [])
-
     def test_does_not_detect_a_anagram_if_the_original_word_is_repeated(self):
         self.assertEqual(detect_anagrams("go", ["go Go GO"]), [])
 

exercises/atbash-cipher/atbash_cipher_test.py

@@ -3,7 +3,7 @@
 from atbash_cipher import decode, encode
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class AtbashCipherTest(unittest.TestCase):
     def test_encode_no(self):

exercises/binary-search/binary_search_test.py

@@ -3,7 +3,7 @@
 from binary_search import binary_search
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class BinarySearchTests(unittest.TestCase):
     def test_finds_value_in_array_with_one_element(self):

exercises/book-store/book_store_test.py

@@ -3,75 +3,54 @@
 from book_store import calculate_total
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
 class BookStoreTests(unittest.TestCase):
     def test_only_a_single_book(self):
-        self.assertAlmostEqual(calculate_total([1]), 8.00,
-                               places=2)
+        self.assertEqual(calculate_total([1]), 800)
 
     def test_two_of_the_same_book(self):
-        self.assertAlmostEqual(calculate_total([2, 2]), 16.00,
-                               places=2)
+        self.assertEqual(calculate_total([2, 2]), 1600)
 
     def test_empty_basket(self):
-        self.assertAlmostEqual(calculate_total([]), 0.00,
-                               places=2)
+        self.assertEqual(calculate_total([]), 0)
 
     def test_two_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2]), 15.20,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2]), 1520)
 
     def test_three_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2, 3]), 21.60,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2, 3]), 2160)
 
     def test_four_different_books(self):
-        self.assertAlmostEqual(calculate_total([1, 2, 3, 4]), 25.60,
-                               places=2)
+        self.assertEqual(calculate_total([1, 2, 3, 4]), 2560)
 
     def test_five_different_books(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 2, 3, 4, 5]), 30.00,
-            places=2)
+        self.assertEqual(calculate_total([1, 2, 3, 4, 5]), 3000)
 
     def test_two_groups_of_4_is_cheaper_than_group_of_5_plus_group_of_3(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 5]), 51.20,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 5]), 5120)
 
     def test_group_of_4_plus_group_of_2_is_cheaper_than_2_groups_of_3(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 4]), 40.80,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 4]), 4080)
 
     def test_two_each_of_first_4_books_and_1_copy_each_of_rest(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5]), 55.60,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5]), 5560)
 
     def test_two_copies_of_each_book(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), 60.00,
-            places=2)
+        self.assertEqual(calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5]), 6000)
 
     def test_three_copies_of_first_book_and_2_each_of_remaining(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]),
-            68.00,
-            places=2)
+        self.assertEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]), 6800)
 
     def test_three_each_of_first_2_books_and_2_each_of_remaining_books(self):
-        self.assertAlmostEqual(
-            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]),
-            75.20,
-            places=2)
+        self.assertEqual(
+            calculate_total([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]), 7520)
 
     def test_four_groups_of_4_are_cheaper_than_2_groups_each_of_5_and_3(self):
-        self.assertAlmostEqual(
+        self.assertEqual(
             calculate_total([1, 1, 2, 2, 3, 3, 4, 5, 1, 1, 2, 2, 3, 3, 4, 5]),
-            102.40,
-            places=2)
+            10240)
 
 
 if __name__ == '__main__':

exercises/book-store/example.py

@@ -1,4 +1,4 @@
-BOOK_PRICE = 8
+BOOK_PRICE = 800
 
 
 def _group_price(size):

exercises/bowling/bowling_test.py

@@ -3,7 +3,7 @@
 from bowling import BowlingGame
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class BowlingTests(unittest.TestCase):
     def setUp(self):

exercises/bracket-push/bracket_push_test.py

@@ -3,7 +3,7 @@
 from bracket_push import check_brackets
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class BracketPushTests(unittest.TestCase):
     def test_paired_square_brackets(self):

exercises/change/change_test.py

@@ -2,8 +2,8 @@
 
 from change import find_minimum_coins
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class ChangeTest(unittest.TestCase):
     def test_single_coin_change(self):

exercises/circular-buffer/circular_buffer_test.py

@@ -7,7 +7,7 @@
 )
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class CircularBufferTest(unittest.TestCase):
     def test_read_empty_buffer(self):

exercises/clock/clock.py

@@ -2,5 +2,14 @@ class Clock(object):
     def __init__(self, hour, minute):
         pass
 
-    def __add__(self, other):
+    def __repr__(self):
+        pass
+
+    def __eq__(self, other):
+        pass
+
+    def __add__(self, minutes):
+        pass
+
+    def __sub__(self, minutes):
         pass

exercises/clock/clock_test.py

@@ -2,8 +2,8 @@
 
 from clock import Clock
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
 
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.2.1
 
 class ClockTest(unittest.TestCase):
     # Test creating a new clock with an initial time.
@@ -90,28 +90,28 @@ def test_add_more_than_two_days(self):
         self.assertEqual(str(Clock(1, 1) + 3500), '11:21')
 
     def test_subtract_minutes(self):
-        self.assertEqual(str(Clock(10, 3) + -3), '10:00')
+        self.assertEqual(str(Clock(10, 3) - 3), '10:00')
 
     def test_subtract_to_previous_hour(self):
-        self.assertEqual(str(Clock(10, 3) + -3), '10:00')
+        self.assertEqual(str(Clock(10, 3) - 3), '10:00')
 
     def test_subtract_more_than_an_hour(self):
-        self.assertEqual(str(Clock(10, 3) + -30), '09:33')
+        self.assertEqual(str(Clock(10, 3) - 30), '09:33')
 
     def test_subtract_across_midnight(self):
-        self.assertEqual(str(Clock(10, 3) + -70), '08:53')
+        self.assertEqual(str(Clock(10, 3) - 70), '08:53')
 
     def test_subtract_more_than_two_hours(self):
-        self.assertEqual(str(Clock(0, 0) + -160), '21:20')
+        self.assertEqual(str(Clock(0, 0) - 160), '21:20')
 
     def test_subtract_more_than_two_hours_with_borrow(self):
-        self.assertEqual(str(Clock(6, 15) + -160), '03:35')
+        self.assertEqual(str(Clock(6, 15) - 160), '03:35')
 
     def test_subtract_more_than_one_day(self):
-        self.assertEqual(str(Clock(5, 32) + -1500), '04:32')
+        self.assertEqual(str(Clock(5, 32) - 1500), '04:32')
 
     def test_subtract_more_than_two_days(self):
-        self.assertEqual(str(Clock(2, 20) + -3000), '00:20')
+        self.assertEqual(str(Clock(2, 20) - 3000), '00:20')
 
     # Construct two separate clocks, set times, test if they are equal.
     def test_clocks_with_same_time(self):