trackler 2.2.1.48 → 2.2.1.49

data/tracks/python/exercises/clock/example.py

@@ -13,7 +13,7 @@ class Clock(object):
     def __eq__(self, other):
         return repr(self) == repr(other)
 
-    def add(self, minutes):
+    def __add__(self, minutes):
         self.minute += minutes
         return self.cleanup()
 

data/tracks/python/exercises/list-ops/example.py

@@ -1,25 +1,21 @@
-def map_clone(function, xs):
-    return [function(elem) for elem in xs]
+def append(xs, ys):
+    return concat([xs, ys])
 
 
-def length(xs):
-    return sum(1 for _ in xs)
+def concat(lists):
+    return [elem for lst in lists for elem in lst]
 
 
 def filter_clone(function, xs):
     return [x for x in xs if function(x)]
 
 
-def reverse(xs):
-    if not xs:
-        return []
-    else:
-        return xs[::-1]
+def length(xs):
+    return sum(1 for _ in xs)
 
 
-def append(xs, y):
-    xs[len(xs):] = [y]
-    return xs
+def map_clone(function, xs):
+    return [function(elem) for elem in xs]
 
 
 def foldl(function, xs, acc):
@@ -36,20 +32,5 @@ def foldr(function, xs, acc):
         return function(xs[0], foldr(function, xs[1:], acc))
 
 
-def flat(xs):
-    out = []
-    for item in xs:
-        if isinstance(item, list):
-            out.extend(flat(item))
-        else:
-            out.append(item)
-    return out
-
-
-def concat(xs, ys):
-    if not ys:
-        return xs
-    else:
-        for item in ys:
-            xs.append(item)
-        return xs
+def reverse(xs):
+    return xs[::-1]

data/tracks/python/exercises/list-ops/list_ops.py

@@ -1,34 +1,30 @@
-def map_clone():
+def append(xs, ys):
     pass
 
 
-def length():
+def concat(lists):
     pass
 
 
-def filter_clone():
+def filter_clone(function, xs):
     pass
 
 
-def reverse():
+def length(xs):
     pass
 
 
-def append():
+def map_clone(function, xs):
     pass
 
 
-def foldl():
+def foldl(function, xs, acc):
     pass
 
 
-def foldr():
+def foldr(function, xs, acc):
     pass
 
 
-def flat():
-    pass
-
-
-def concat():
+def reverse(xs):
     pass

data/tracks/python/exercises/list-ops/list_ops_test.py

@@ -4,122 +4,91 @@ import operator
 import list_ops
 
 
+# Tests adapted from problem-specifications//canonical-data.json @ v2.0.0
+
 class ListOpsTest(unittest.TestCase):
 
-    # tests for map
-    def test_map_square(self):
-        self.assertEqual(
-            list_ops.map_clone(lambda x: x**2,
-                               [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-            [1, 4, 9, 16, 25, 36, 49, 64, 81, 100])
+    # test for append
+    def test_append_empty_lists(self):
+        self.assertEqual(list_ops.append([], []), [])
 
-    def test_map_cube(self):
-        self.assertEqual(
-            list_ops.map_clone(lambda x: x**3,
-                               [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]),
-            [-1, 8, -27, 64, -125, 216, -343, 512, -729, 1000])
+    def test_append_empty_list_to_list(self):
+        self.assertEqual(list_ops.append([], [1, 2, 3, 4]), [1, 2, 3, 4])
 
-    def test_map_absolute(self):
-        self.assertEqual(
-            list_ops.map_clone(lambda x: abs(x),
-                               [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]),
-            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    def test_append_nonempty_lists(self):
+        self.assertEqual(list_ops.append([1, 2], [2, 3, 4, 5]),
+                         [1, 2, 2, 3, 4, 5])
 
-    def test_map_empty(self):
-        self.assertEqual(list_ops.map_clone(operator.index, []), [])
+    # tests for concat
+    def test_concat_empty_list(self):
+        self.assertEqual(list_ops.concat([]), [])
 
-    # tests for length
-    def test_pos_leng(self):
-        self.assertEqual(
-            list_ops.length([-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]), 10)
+    def test_concat_list_of_lists(self):
+        self.assertEqual(list_ops.concat([[1, 2], [3], [], [4, 5, 6]]),
+                         [1, 2, 3, 4, 5, 6])
 
-    def test_empty_len(self):
-        self.assertEqual(list_ops.length([]), 0)
+    # tests for filter_clone
+    def test_filter_empty_list(self):
+        self.assertEqual(list_ops.filter_clone(lambda x: x % 2 == 1, []), [])
 
-    # tests for filter
-    def test_filter_odd(self):
+    def test_filter_nonempty_list(self):
         self.assertEqual(
-            list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]),
+            list_ops.filter_clone(lambda x: x % 2 == 1, [1, 2, 3, 4, 5]),
             [1, 3, 5])
 
-    def test_filter_even(self):
-        self.assertEqual(
-            list_ops.filter_clone(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]),
-            [2, 4, 6])
-
-    # tests for reverse
-    def test_reverse_small(self):
-        self.assertEqual(list_ops.reverse([3, 2, 1]), [1, 2, 3])
-
-    def test_reverse_mixed_types(self):
-        self.assertEqual(
-            list_ops.reverse(["xyz", 4.0, "cat", 1]), [1, "cat", 4.0, "xyz"])
-
-    def test_reverse_empty(self):
-        self.assertEqual(list_ops.reverse([]), [])
+    # tests for length
+    def test_length_empty_list(self):
+        self.assertEqual(list_ops.length([]), 0)
 
-    # tests for append
-    def test_append_tuple(self):
-        self.assertEqual(
-            list_ops.append(["10", "python"], "hello"),
-            ["10", "python", "hello"])
+    def test_length_nonempty_list(self):
+        self.assertEqual(list_ops.length([1, 2, 3, 4]), 4)
 
-    def test_append_range(self):
-        self.assertEqual(
-            list_ops.append([100], range(1000)), [100, range(1000)])
+    # tests for map_clone
+    def test_map_empty_list(self):
+        self.assertEqual(list_ops.map_clone(lambda x: x + 1, []), [])
 
-    def test_append_to_empty(self):
-        self.assertEqual(list_ops.append([], 42), [42])
+    def test_map_nonempty_list(self):
+        self.assertEqual(list_ops.map_clone(lambda x: x + 1, [1, 3, 5, 7]),
+                         [2, 4, 6, 8])
 
     # tests for foldl
-    def test_foldl_sum(self):
-        self.assertEqual(
-            list_ops.foldl(operator.add, [1, 2, 3, 4, 5, 6], 0), 21)
+    def test_foldl_empty_list(self):
+        self.assertEqual(list_ops.foldl(operator.mul, [], 2), 2)
 
-    def test_foldl_product(self):
-        self.assertEqual(
-            list_ops.foldl(operator.mul, [1, 2, 3, 4, 5, 6], 1), 720)
+    def test_foldl_nonempty_list_addition(self):
+        self.assertEqual(list_ops.foldl(operator.add, [1, 2, 3, 4], 5), 15)
 
-    def test_foldl_div(self):
-        self.assertEqual(
-            list_ops.foldl(operator.floordiv, [1, 2, 3, 4, 5, 6], 1), 0)
-
-    def test_foldl_sub(self):
-        self.assertEqual(list_ops.foldl(operator.sub, [1, 2, 3, 4, 5], 0), -15)
+    def test_foldl_nonempty_list_floordiv(self):
+        self.assertEqual(list_ops.foldl(operator.floordiv, [2, 5], 5), 0)
 
     # tests for foldr
-    def test_foldr_sub(self):
-        self.assertEqual(list_ops.foldr(operator.sub, [1, 2, 3, 4, 5], 0), 3)
+    def test_foldr_empty_list(self):
+        self.assertEqual(list_ops.foldr(operator.mul, [], 2), 2)
+
+    def test_foldr_nonempty_list_addition(self):
+        self.assertEqual(list_ops.foldr(operator.add, [1, 2, 3, 4], 5), 15)
+
+    def test_foldr_nonempty_list_floordiv(self):
+        self.assertEqual(list_ops.foldr(operator.floordiv, [2, 5], 5), 2)
 
+    # additional test for foldr
     def test_foldr_add_str(self):
         self.assertEqual(
             list_ops.foldr(operator.add,
                            ["e", "x", "e", "r", "c", "i", "s", "m"], "!"),
             "exercism!")
 
-    # tests for flatten
-    def test_flatten_nested(self):
-        self.assertEqual(list_ops.flat([[[1, 2], [3]], [[4]]]), [1, 2, 3, 4])
-
-    def test_flatten_once(self):
-        self.assertEqual(list_ops.flat([["x", "y", "z"]]), ["x", "y", "z"])
+    # tests for reverse
+    def test_reverse_empty_list(self):
+        self.assertEqual(list_ops.reverse([]), [])
 
-    def test_flatten_empty(self):
-        self.assertEqual(list_ops.flat([]), [])
+    def test_reverse_nonempty_list(self):
+        self.assertEqual(list_ops.reverse([1, 3, 5, 7]), [7, 5, 3, 1])
 
-    # tests for concat
-    def test_concat_two(self):
-        self.assertEqual(
-            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6]),
-            [1, 3, 5, 8, 9, 4, 5, 6])
-
-    def test_concat_nothing(self):
+    # additional test for reverse
+    def test_reverse_mixed_types(self):
         self.assertEqual(
-            list_ops.concat(['orange', 'apple', 'banana'], None),
-            ["orange", "apple", "banana"])
-
-    def test_concat_empty(self):
-        self.assertEqual(list_ops.concat([], []), [])
+            list_ops.reverse(["xyz", 4.0, "cat", 1]), [1, "cat", 4.0, "xyz"])
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/meetup/meetup_test.py

@@ -399,8 +399,8 @@ class MeetupTest(unittest.TestCase):
             meetup_day(2015, 3, 'Monday', '5th'), date(2015, 3, 30))
 
     def test_nonexistent_fifth_monday_of_february_2015(self):
-        self.assertRaises(MeetupDayException, meetup_day, 2015, 2, 'Monday',
-                          '5th')
+        with self.assertRaises(MeetupDayException):
+            meetup_day(2015, 2, 'Monday', '5th')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/minesweeper/minesweeper_test.py

@@ -141,19 +141,22 @@ class MinesweeperTest(unittest.TestCase):
                "|*  |",
                "|  |",
                "+-+"]
-        self.assertRaises(ValueError, board, inp)
+        with self.assertRaises(ValueError):
+            board(inp)
 
     def test_faulty_border(self):
         inp = ["+-----+",
                "*   * |",
                "+-- --+"]
-        self.assertRaises(ValueError, board, inp)
+        with self.assertRaises(ValueError):
+            board(inp)
 
     def test_invalid_char(self):
         inp = ["+-----+",
                "|X  * |",
                "+-----+"]
-        self.assertRaises(ValueError, board, inp)
+        with self.assertRaises(ValueError):
+            board(inp)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/ocr-numbers/ocr_numbers_test.py

@@ -43,15 +43,17 @@ class OcrTest(unittest.TestCase):
                                  "   "]), '?')
 
     def test_too_short_row(self):
-        self.assertRaises(ValueError, number, ["   ",
-                                               " _|",
-                                               " |",
-                                               "   "])
+        with self.assertRaises(ValueError):
+            number(["   ",
+                    " _|",
+                    " |",
+                    "   "])
 
     def test_insufficient_rows(self):
-        self.assertRaises(ValueError, number, ["   ",
-                                               " _|",
-                                               " X|"])
+        with self.assertRaises(ValueError):
+            number(["   ",
+                    " _|",
+                    " X|"])
 
     def test_grid0(self):
         self.assertEqual(grid('0'), [" _ ",
@@ -114,7 +116,8 @@ class OcrTest(unittest.TestCase):
             ])
 
     def test_invalid_grid(self):
-        self.assertRaises(ValueError, grid, '123a')
+        with self.assertRaises(ValueError):
+            grid('123a')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/pangram/pangram_test.py

@@ -7,39 +7,48 @@ from pangram import is_pangram
 
 class PangramTests(unittest.TestCase):
     def test_sentence_empty(self):
-        self.assertFalse(is_pangram(''))
+        self.assertIs(is_pangram(''), False)
 
     def test_pangram_with_only_lower_case(self):
-        self.assertTrue(
-            is_pangram('the quick brown fox jumps over the lazy dog'))
+        self.assertIs(
+            is_pangram('the quick brown fox jumps over the lazy dog'),
+            True)
 
     def test_missing_character_x(self):
-        self.assertFalse(
+        self.assertIs(
             is_pangram('a quick movement of the enemy will '
-                       'jeopardize five gunboats'))
+                       'jeopardize five gunboats'),
+            False)
 
     def test_another_missing_character_x(self):
-        self.assertFalse(
-            is_pangram('the quick brown fish jumps over the lazy dog'))
+        self.assertIs(
+            is_pangram('the quick brown fish jumps over the lazy dog'),
+            False)
 
     def test_pangram_with_underscores(self):
-        self.assertTrue(
-            is_pangram('the_quick_brown_fox_jumps_over_the_lazy_dog'))
+        self.assertIs(
+            is_pangram('the_quick_brown_fox_jumps_over_the_lazy_dog'),
+            True)
 
     def test_pangram_with_numbers(self):
-        self.assertTrue(
-            is_pangram('the 1 quick brown fox jumps over the 2 lazy dogs'))
+        self.assertIs(
+            is_pangram('the 1 quick brown fox jumps over the 2 lazy dogs'),
+            True)
 
     def test_missing_letters_replaced_by_numbers(self):
-        self.assertFalse(
-            is_pangram('7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'))
+        self.assertIs(
+            is_pangram('7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'),
+            False)
 
     def test_pangram_with_mixedcase_and_punctuation(self):
-        self.assertTrue(is_pangram('"Five quacking Zephyrs jolt my wax bed."'))
+        self.assertIs(
+            is_pangram('"Five quacking Zephyrs jolt my wax bed."'),
+            True)
 
     def test_upper_and_lower_case_versions_of_the_same_character(self):
-        self.assertFalse(
-            is_pangram('the quick brown fox jumped over the lazy FOX'))
+        self.assertIs(
+            is_pangram('the quick brown fox jumped over the lazy FOX'),
+            False)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/point-mutations/point_mutations.py

@@ -1,2 +1,2 @@
-def hamming_distance():
+def hamming_distance(dna_strand_1, dna_strand_2):
     pass

data/tracks/python/exercises/pythagorean-triplet/pythagorean_triplet_test.py

@@ -80,7 +80,8 @@ class PythagoreanTripletTest(unittest.TestCase):
         self.assertIs(is_triplet((924, 43, 925)), True)
 
     def test_odd_number(self):
-        self.assertRaises(ValueError, primitive_triplets, 5)
+        with self.assertRaises(ValueError):
+            primitive_triplets(5)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/saddle-points/saddle_points_test.py

@@ -28,7 +28,8 @@ class SaddlePointTest(unittest.TestCase):
 
     def test_irregular_matrix(self):
         inp = [[3, 2, 1], [0, 1], [2, 1, 0]]
-        self.assertRaises(ValueError, saddle_points, inp)
+        with self.assertRaises(ValueError):
+            saddle_points(inp)
 
 
 if __name__ == '__main__':