trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/house/house_test.py

@@ -8,25 +8,25 @@ from house import rhyme, verse
 class VerseTest(unittest.TestCase):
     def test_verse_0(self):
         expected = 'This is the house that Jack built.'
-        self.assertEqual(expected, verse(0))
+        self.assertEqual(verse(0), expected)
 
     def test_verse_1(self):
         expected = 'This is the malt\n'\
                    'that lay in the house that Jack built.'
-        self.assertEqual(expected, verse(1))
+        self.assertEqual(verse(1), expected)
 
     def test_verse_2(self):
         expected = 'This is the rat\n'\
                    'that ate the malt\n'\
                    'that lay in the house that Jack built.'
-        self.assertEqual(expected, verse(2))
+        self.assertEqual(verse(2), expected)
 
     def test_verse_3(self):
         expected = 'This is the cat\n'\
                    'that killed the rat\n'\
                    'that ate the malt\n'\
                    'that lay in the house that Jack built.'
-        self.assertEqual(expected, verse(3))
+        self.assertEqual(verse(3), expected)
 
     def test_verse_11(self):
         expected = 'This is the horse and the hound and the horn\n'\
@@ -41,7 +41,7 @@ class VerseTest(unittest.TestCase):
                    'that killed the rat\n'\
                    'that ate the malt\n'\
                    'that lay in the house that Jack built.'
-        self.assertEqual(expected, verse(11))
+        self.assertEqual(verse(11), expected)
 
     def test_rhyme(self):
         expected = 'This is the house that Jack built.\n\n'\
@@ -122,7 +122,7 @@ class VerseTest(unittest.TestCase):
                    'that killed the rat\n'\
                    'that ate the malt\n'\
                    'that lay in the house that Jack built.'
-        self.assertEqual(expected, rhyme())
+        self.assertEqual(rhyme(), expected)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/kindergarten-garden/kindergarten_garden_test.py

@@ -4,34 +4,37 @@ from kindergarten_garden import Garden
 
 
 class KindergartenGardenTests(unittest.TestCase):
-
     def test_alices_garden(self):
-        self.assertEqual("Radishes Clover Grass Grass".split(),
-                         Garden("RC\nGG").plants("Alice"))
+        self.assertEqual(
+            Garden("RC\nGG").plants("Alice"),
+            "Radishes Clover Grass Grass".split())
 
     def test_bob_and_charlies_gardens(self):
         garden = Garden("VVCCGG\nVVCCGG")
-        self.assertEqual(["Clover"] * 4, garden.plants("Bob"))
-        self.assertEqual(["Grass"] * 4, garden.plants("Charlie"))
+        self.assertEqual(garden.plants("Bob"), ["Clover"] * 4)
+        self.assertEqual(garden.plants("Charlie"), ["Grass"] * 4)
 
     def test_full_garden(self):
         garden = Garden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV")
-        self.assertEqual("Violets Radishes Violets Radishes".split(),
-                         garden.plants("Alice"))
-        self.assertEqual("Clover Grass Clover Clover".split(),
-                         garden.plants("Bob"))
-        self.assertEqual("Grass Clover Clover Grass".split(),
-                         garden.plants("Kincaid"))
-        self.assertEqual("Grass Violets Clover Violets".split(),
-                         garden.plants("Larry"))
+        self.assertEqual(
+            garden.plants("Alice"),
+            "Violets Radishes Violets Radishes".split())
+        self.assertEqual(
+            garden.plants("Bob"), "Clover Grass Clover Clover".split())
+        self.assertEqual(
+            garden.plants("Kincaid"), "Grass Clover Clover Grass".split())
+        self.assertEqual(
+            garden.plants("Larry"), "Grass Violets Clover Violets".split())
 
     def test_disordered_test(self):
-        garden = Garden("VCRRGVRG\nRVGCCGCV",
-                        students="Samantha Patricia Xander Roger".split())
-        self.assertEqual("Violets Clover Radishes Violets".split(),
-                         garden.plants("Patricia"))
-        self.assertEqual("Radishes Grass Clover Violets".split(),
-                         garden.plants("Xander"))
+        garden = Garden(
+            "VCRRGVRG\nRVGCCGCV",
+            students="Samantha Patricia Xander Roger".split())
+        self.assertEqual(
+            garden.plants("Patricia"),
+            "Violets Clover Radishes Violets".split())
+        self.assertEqual(
+            garden.plants("Xander"), "Radishes Grass Clover Violets".split())
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/largest-series-product/largest_series_product_test.py

@@ -13,61 +13,62 @@ from largest_series_product import largest_product
 
 class SeriesTest(unittest.TestCase):
     def test_largest_product_of_2(self):
-        self.assertEqual(72, largest_product("0123456789", 2))
+        self.assertEqual(largest_product("0123456789", 2), 72)
 
     def test_largest_product_of_2_unordered(self):
-        self.assertEqual(48, largest_product("576802143", 2))
+        self.assertEqual(largest_product("576802143", 2), 48)
 
     def test__largest_product_span_equals_length(self):
-        self.assertEqual(18, largest_product("29", 2))
+        self.assertEqual(largest_product("29", 2), 18)
 
     def test_largest_product_of_3(self):
-        self.assertEqual(504, largest_product("0123456789", 3))
+        self.assertEqual(largest_product("0123456789", 3), 504)
 
     def test_largest_product_of_3_unordered(self):
-        self.assertEqual(270, largest_product("1027839564", 3))
+        self.assertEqual(largest_product("1027839564", 3), 270)
 
     def test_largest_product_of_5(self):
-        self.assertEqual(15120, largest_product("0123456789", 5))
+        self.assertEqual(largest_product("0123456789", 5), 15120)
 
     def test_big_number(self):
         series = "73167176531330624919225119674426574742355349194934"
-        self.assertEqual(23520, largest_product(series, 6))
+        self.assertEqual(largest_product(series, 6), 23520)
 
     def test_another_big_number(self):
         series = "52677741234314237566414902593461595376319419139427"
-        self.assertEqual(28350, largest_product(series, 6))
+        self.assertEqual(largest_product(series, 6), 28350)
 
     def test_project_euler_big_number(self):
         series = (
-            "731671765313306249192251196744265747423553491949349698352031277450632623957"
-            "831801698480186947885184385861560789112949495459501737958331952853208805511"
-            "125406987471585238630507156932909632952274430435576689664895044524452316173"
-            "185640309871112172238311362229893423380308135336276614282806444486645238749"
-            "303589072962904915604407723907138105158593079608667017242712188399879790879"
-            "227492190169972088809377665727333001053367881220235421809751254540594752243"
-            "525849077116705560136048395864467063244157221553975369781797784617406495514"
-            "929086256932197846862248283972241375657056057490261407972968652414535100474"
-            "821663704844031998900088952434506585412275886668811642717147992444292823086"
-            "346567481391912316282458617866458359124566529476545682848912883142607690042"
-            "242190226710556263211111093705442175069416589604080719840385096245544436298"
-            "123098787992724428490918884580156166097919133875499200524063689912560717606"
-            "058861164671094050775410022569831552000559357297257163626956188267042825248"
-            "3600823257530420752963450"
-        )
-        self.assertEqual(23514624000, largest_product(series, 13))
+            "73167176531330624919225119674426574742355349194934969835203127745"
+            "06326239578318016984801869478851843858615607891129494954595017379"
+            "58331952853208805511125406987471585238630507156932909632952274430"
+            "43557668966489504452445231617318564030987111217223831136222989342"
+            "33803081353362766142828064444866452387493035890729629049156044077"
+            "23907138105158593079608667017242712188399879790879227492190169972"
+            "08880937766572733300105336788122023542180975125454059475224352584"
+            "90771167055601360483958644670632441572215539753697817977846174064"
+            "95514929086256932197846862248283972241375657056057490261407972968"
+            "65241453510047482166370484403199890008895243450658541227588666881"
+            "16427171479924442928230863465674813919123162824586178664583591245"
+            "66529476545682848912883142607690042242190226710556263211111093705"
+            "44217506941658960408071984038509624554443629812309878799272442849"
+            "09188845801561660979191338754992005240636899125607176060588611646"
+            "71094050775410022569831552000559357297257163626956188267042825248"
+            "3600823257530420752963450")
+        self.assertEqual(largest_product(series, 13), 23514624000)
 
     def test_all_digits_zero(self):
-        self.assertEqual(0, largest_product("0000", 2))
+        self.assertEqual(largest_product("0000", 2), 0)
 
     def test_all_spans_contain_zero(self):
-        self.assertEqual(0, largest_product("99099", 3))
+        self.assertEqual(largest_product("99099", 3), 0)
 
     def test_identity_with_empty_string(self):
-        self.assertEqual(1, largest_product("", 0))
+        self.assertEqual(largest_product("", 0), 1)
 
     def test_identity_with_nonempty_string(self):
-        self.assertEqual(1, largest_product("123", 0))
+        self.assertEqual(largest_product("123", 0), 1)
 
     def test_span_long_than_number(self):
         with self.assertRaises(ValueError):

data/tracks/python/exercises/linked-list/linked_list_test.py

@@ -4,63 +4,62 @@ from linked_list import LinkedList
 
 
 class LinkedListTests(unittest.TestCase):
-
     def setUp(self):
         self.list = LinkedList()
 
     def test_push_pop(self):
         self.list.push(10)
         self.list.push(20)
-        self.assertEqual(20, self.list.pop())
-        self.assertEqual(10, self.list.pop())
+        self.assertEqual(self.list.pop(), 20)
+        self.assertEqual(self.list.pop(), 10)
 
     def test_push_shift(self):
         self.list.push(10)
         self.list.push(20)
-        self.assertEqual(10, self.list.shift())
-        self.assertEqual(20, self.list.shift())
+        self.assertEqual(self.list.shift(), 10)
+        self.assertEqual(self.list.shift(), 20)
 
     def test_unshift_shift(self):
         self.list.unshift(10)
         self.list.unshift(20)
-        self.assertEqual(20, self.list.shift())
-        self.assertEqual(10, self.list.shift())
+        self.assertEqual(self.list.shift(), 20)
+        self.assertEqual(self.list.shift(), 10)
 
     def test_unshift_pop(self):
         self.list.unshift(10)
         self.list.unshift(20)
-        self.assertEqual(10, self.list.pop())
-        self.assertEqual(20, self.list.pop())
+        self.assertEqual(self.list.pop(), 10)
+        self.assertEqual(self.list.pop(), 20)
 
     def test_all(self):
         self.list.push(10)
         self.list.push(20)
-        self.assertEqual(20, self.list.pop())
+        self.assertEqual(self.list.pop(), 20)
         self.list.push(30)
-        self.assertEqual(10, self.list.shift())
+        self.assertEqual(self.list.shift(), 10)
         self.list.unshift(40)
         self.list.push(50)
-        self.assertEqual(40, self.list.shift())
-        self.assertEqual(50, self.list.pop())
-        self.assertEqual(30, self.list.shift())
+        self.assertEqual(self.list.shift(), 40)
+        self.assertEqual(self.list.pop(), 50)
+        self.assertEqual(self.list.shift(), 30)
 
     @unittest.skip("extra-credit")
     def test_length(self):
         self.list.push(10)
         self.list.push(20)
-        self.assertEqual(2, len(self.list))
+        self.assertEqual(len(self.list), 2)
         self.list.shift()
-        self.assertEqual(1, len(self.list))
+        self.assertEqual(len(self.list), 1)
         self.list.pop()
-        self.assertEqual(0, len(self.list))
+        self.assertEqual(len(self.list), 0)
 
     @unittest.skip("extra-credit")
     def test_iterator(self):
         self.list.push(10)
         self.list.push(20)
         iterator = iter(self.list)
-        self.assertEqual(10, next(iterator))
-        self.assertEqual(20, next(iterator))
+        self.assertEqual(next(iterator), 10)
+        self.assertEqual(next(iterator), 20)
 
 
 if __name__ == '__main__':

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

@@ -9,112 +9,117 @@ class ListOpsTest(unittest.TestCase):
     # tests for map
     def test_map_square(self):
         self.assertEqual(
-            [1, 4, 9, 16, 25, 36, 49, 64, 81, 100],
-            list_ops.map_clone(
-                lambda x: x**2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+            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])
 
     def test_map_cube(self):
         self.assertEqual(
-            [-1, 8, -27, 64, -125, 216, -343, 512, -729, 1000],
-            list_ops.map_clone(
-                lambda x: x**3, [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
+            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_map_absolute(self):
         self.assertEqual(
-            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
-            list_ops.map_clone(
-                lambda x: abs(x), [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
+            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_map_empty(self):
-        self.assertEqual([], list_ops.map_clone(operator.index, []))
+        self.assertEqual(list_ops.map_clone(operator.index, []), [])
 
     # tests for length
     def test_pos_leng(self):
-        self.assertEqual(10, list_ops.length([-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]))
+        self.assertEqual(
+            list_ops.length([-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]), 10)
 
     def test_empty_len(self):
-        self.assertEqual(0, list_ops.length([]))
+        self.assertEqual(list_ops.length([]), 0)
 
     # tests for filter
     def test_filter_odd(self):
         self.assertEqual(
-            [1, 3, 5],
-            list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]))
+            list_ops.filter_clone(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6]),
+            [1, 3, 5])
 
     def test_filter_even(self):
         self.assertEqual(
-            [2, 4, 6],
-            list_ops.filter_clone(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
+            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([1, 2, 3], list_ops.reverse([3, 2, 1]))
+        self.assertEqual(list_ops.reverse([3, 2, 1]), [1, 2, 3])
 
     def test_reverse_mixed_types(self):
         self.assertEqual(
-            [1, "cat", 4.0, "xyz"],
-            list_ops.reverse(["xyz", 4.0, "cat", 1]))
+            list_ops.reverse(["xyz", 4.0, "cat", 1]), [1, "cat", 4.0, "xyz"])
 
     def test_reverse_empty(self):
-        self.assertEqual([], list_ops.reverse([]))
+        self.assertEqual(list_ops.reverse([]), [])
 
     # tests for append
     def test_append_tuple(self):
         self.assertEqual(
-            ["10", "python", "hello"],
-            list_ops.append(["10", "python"], "hello"))
+            list_ops.append(["10", "python"], "hello"),
+            ["10", "python", "hello"])
 
     def test_append_range(self):
-        self.assertEqual([100, range(1000)], list_ops.append([100], range(1000)))
+        self.assertEqual(
+            list_ops.append([100], range(1000)), [100, range(1000)])
 
     def test_append_to_empty(self):
-        self.assertEqual([42], list_ops.append([], 42))
+        self.assertEqual(list_ops.append([], 42), [42])
 
     # tests for foldl
     def test_foldl_sum(self):
-        self.assertEqual(21, list_ops.foldl(operator.add, [1, 2, 3, 4, 5, 6], 0))
+        self.assertEqual(
+            list_ops.foldl(operator.add, [1, 2, 3, 4, 5, 6], 0), 21)
 
     def test_foldl_product(self):
-        self.assertEqual(720, list_ops.foldl(operator.mul, [1, 2, 3, 4, 5, 6], 1))
+        self.assertEqual(
+            list_ops.foldl(operator.mul, [1, 2, 3, 4, 5, 6], 1), 720)
 
     def test_foldl_div(self):
-        self.assertEqual(0, list_ops.foldl(operator.floordiv, [1, 2, 3, 4, 5, 6], 1))
+        self.assertEqual(
+            list_ops.foldl(operator.floordiv, [1, 2, 3, 4, 5, 6], 1), 0)
 
     def test_foldl_sub(self):
-        self.assertEqual(-15, list_ops.foldl(operator.sub, [1, 2, 3, 4, 5], 0))
+        self.assertEqual(list_ops.foldl(operator.sub, [1, 2, 3, 4, 5], 0), -15)
 
     # tests for foldr
     def test_foldr_sub(self):
-        self.assertEqual(3, list_ops.foldr(operator.sub, [1, 2, 3, 4, 5], 0))
+        self.assertEqual(list_ops.foldr(operator.sub, [1, 2, 3, 4, 5], 0), 3)
 
     def test_foldr_add_str(self):
         self.assertEqual(
-            "exercism!",
-            list_ops.foldr(operator.add, ["e", "x", "e", "r", "c", "i", "s", "m"], "!"))
+            list_ops.foldr(operator.add,
+                           ["e", "x", "e", "r", "c", "i", "s", "m"], "!"),
+            "exercism!")
 
     # tests for flatten
     def test_flatten_nested(self):
-        self.assertEqual([1, 2, 3, 4], list_ops.flat([[[1, 2], [3]], [[4]]]))
+        self.assertEqual(list_ops.flat([[[1, 2], [3]], [[4]]]), [1, 2, 3, 4])
 
     def test_flatten_once(self):
-        self.assertEqual(["x", "y", "z"], list_ops.flat([["x", "y", "z"]]))
+        self.assertEqual(list_ops.flat([["x", "y", "z"]]), ["x", "y", "z"])
 
     def test_flatten_empty(self):
-        self.assertEqual([], list_ops.flat([]))
+        self.assertEqual(list_ops.flat([]), [])
 
     # tests for concat
     def test_concat_two(self):
         self.assertEqual(
-            [1, 3, 5, 8, 9, 4, 5, 6],
-            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6]))
+            list_ops.concat([1, 3, 5, 8], [9, 4, 5, 6]),
+            [1, 3, 5, 8, 9, 4, 5, 6])
 
     def test_concat_nothing(self):
         self.assertEqual(
-            ["orange", "apple", "banana"],
-            list_ops.concat(['orange', 'apple', 'banana'], None))
+            list_ops.concat(['orange', 'apple', 'banana'], None),
+            ["orange", "apple", "banana"])
 
     def test_concat_empty(self):
-        self.assertEqual([], list_ops.concat([], []))
+        self.assertEqual(list_ops.concat([], []), [])
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/matrix/matrix_test.py

@@ -6,27 +6,27 @@ from matrix import Matrix
 class MatrixTest(unittest.TestCase):
     def test_extract_a_row(self):
         matrix = Matrix("1 2\n10 20")
-        self.assertEqual([1, 2], matrix.rows[0])
+        self.assertEqual(matrix.rows[0], [1, 2])
 
     def test_extract_same_row_again(self):
         matrix = Matrix("9 7\n8 6")
-        self.assertEqual([9, 7], matrix.rows[0])
+        self.assertEqual(matrix.rows[0], [9, 7])
 
     def test_extract_other_row(self):
         matrix = Matrix("9 8 7\n19 18 17")
-        self.assertEqual([19, 18, 17], matrix.rows[1])
+        self.assertEqual(matrix.rows[1], [19, 18, 17])
 
     def test_extract_other_row_again(self):
         matrix = Matrix("1 4 9\n16 25 36")
-        self.assertEqual([16, 25, 36], matrix.rows[1])
+        self.assertEqual(matrix.rows[1], [16, 25, 36])
 
     def test_extract_a_column(self):
         matrix = Matrix("1 2 3\n4 5 6\n7 8 9\n8 7 6")
-        self.assertEqual([1, 4, 7, 8], matrix.columns[0])
+        self.assertEqual(matrix.columns[0], [1, 4, 7, 8])
 
     def test_extract_another_column(self):
         matrix = Matrix("89 1903 3\n18 3 1\n9 4 800")
-        self.assertEqual([1903, 3, 4], matrix.columns[1])
+        self.assertEqual(matrix.columns[1], [1903, 3, 4])
 
 
 if __name__ == '__main__':