trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/grade-school/grade_school_test.py

@@ -1,6 +1,6 @@
+import unittest
 from collections import Sequence
 from types import GeneratorType
-import unittest
 
 from grade_school import School
 
@@ -14,40 +14,37 @@ class SchoolTest(unittest.TestCase):
 
     def test_an_empty_school(self):
         for n in range(1, 9):
-            self.assertCountEqual(set(), self.school.grade(n))
+            self.assertCountEqual(self.school.grade(n), set())
 
     def test_add_student(self):
         self.school.add("Aimee", 2)
-        self.assertCountEqual(("Aimee",), self.school.grade(2))
+        self.assertCountEqual(self.school.grade(2), ("Aimee", ))
 
     def test_add_more_students_in_same_class(self):
         self.school.add("James", 2)
         self.school.add("Blair", 2)
         self.school.add("Paul", 2)
-        self.assertCountEqual(("James", "Blair", "Paul"), self.school.grade(2))
+        self.assertCountEqual(self.school.grade(2), ("James", "Blair", "Paul"))
 
     def test_add_students_to_different_grades(self):
         self.school.add("Chelsea", 3)
         self.school.add("Logan", 7)
-        self.assertCountEqual(("Chelsea",), self.school.grade(3))
-        self.assertCountEqual(("Logan",), self.school.grade(7))
+        self.assertCountEqual(self.school.grade(3), ("Chelsea", ))
+        self.assertCountEqual(self.school.grade(7), ("Logan", ))
 
     def test_get_students_in_a_grade(self):
         self.school.add("Franklin", 5)
         self.school.add("Bradley", 5)
         self.school.add("Jeff", 1)
-        self.assertCountEqual(("Franklin", "Bradley"), self.school.grade(5))
+        self.assertCountEqual(self.school.grade(5), ("Franklin", "Bradley"))
 
     def test_get_students_in_a_non_existant_grade(self):
-        self.assertCountEqual(set(), self.school.grade(1))
+        self.assertCountEqual(self.school.grade(1), set())
 
     def test_sort_school(self):
+        students = [(3, ("Kyle", )), (4, ("Christopher", "Jennifer", )),
+                    (6, ("Kareem", ))]
 
-        students = [
-            (3, ("Kyle",)),
-            (4, ("Christopher", "Jennifer",)),
-            (6, ("Kareem",))
-        ]
         for grade, students_in_grade in students:
             for student in students_in_grade:
                 self.school.add(student, grade)
@@ -55,14 +52,15 @@ class SchoolTest(unittest.TestCase):
         result = self.school.sort()
 
         # Attempts to catch false positives
-        self.assertTrue(isinstance(result, Sequence) or
-                        isinstance(result, GeneratorType) or
-                        callable(getattr(result, '__reversed__', False)))
+        self.assertTrue(
+            isinstance(result, Sequence) or
+            isinstance(result, GeneratorType) or
+            callable(getattr(result, '__reversed__', False)))
 
-        result_list = list(result.items() if hasattr(result, "items")
-                           else result)
+        result_list = list(result.items()
+                           if hasattr(result, "items") else result)
 
-        self.assertEqual(result_list, students)
+        self.assertEqual(students, result_list)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/grains/grains_test.py

@@ -5,32 +5,32 @@ from grains import on_square, total_after
 
 class GrainsTest(unittest.TestCase):
     def test_square_1(self):
-        self.assertEqual(1, on_square(1))
-        self.assertEqual(1, total_after(1))
+        self.assertEqual(on_square(1), 1)
+        self.assertEqual(total_after(1), 1)
 
     def test_square_2(self):
-        self.assertEqual(2, on_square(2))
-        self.assertEqual(3, total_after(2))
+        self.assertEqual(on_square(2), 2)
+        self.assertEqual(total_after(2), 3)
 
     def test_square_3(self):
-        self.assertEqual(4, on_square(3))
-        self.assertEqual(7, total_after(3))
+        self.assertEqual(on_square(3), 4)
+        self.assertEqual(total_after(3), 7)
 
     def test_square_4(self):
-        self.assertEqual(8, on_square(4))
-        self.assertEqual(15, total_after(4))
+        self.assertEqual(on_square(4), 8)
+        self.assertEqual(total_after(4), 15)
 
     def test_square_16(self):
-        self.assertEqual(32768, on_square(16))
-        self.assertEqual(65535, total_after(16))
+        self.assertEqual(on_square(16), 32768)
+        self.assertEqual(total_after(16), 65535)
 
     def test_square_32(self):
-        self.assertEqual(2147483648, on_square(32))
-        self.assertEqual(4294967295, total_after(32))
+        self.assertEqual(on_square(32), 2147483648)
+        self.assertEqual(total_after(32), 4294967295)
 
     def test_square_64(self):
-        self.assertEqual(9223372036854775808, on_square(64))
-        self.assertEqual(18446744073709551615, total_after(64))
+        self.assertEqual(on_square(64), 9223372036854775808)
+        self.assertEqual(total_after(64), 18446744073709551615)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/grep/grep_test.py

@@ -3,7 +3,6 @@ import unittest
 
 from grep import grep
 
-
 ILIADFILENAME = 'iliad.txt'
 ILIADCONTENTS = '''Achilles sing, O Goddess! Peleus' son;
 His wrath pernicious, who ten thousand woes
@@ -51,7 +50,6 @@ def create_file(name, contents):
 
 
 class GrepTest(unittest.TestCase):
-
     @classmethod
     def setUpClass(self):
         create_file(ILIADFILENAME, ILIADCONTENTS)
@@ -67,67 +65,57 @@ class GrepTest(unittest.TestCase):
     def test_one_file_one_match_no_flags(self):
         self.assertMultiLineEqual(
             grep("Agamemnon", [ILIADFILENAME]),
-            "Of Atreus, Agamemnon, King of men.\n"
-        )
+            "Of Atreus, Agamemnon, King of men.\n")
 
     def test_one_file_one_match_print_line_numbers_flag(self):
         self.assertMultiLineEqual(
             grep("Forbidden", [PARADISELOSTFILENAME], "-n"),
-            "2:Of that Forbidden Tree, whose mortal tast\n"
-        )
+            "2:Of that Forbidden Tree, whose mortal tast\n")
 
     def test_one_file_one_match_case_insensitive_flag(self):
         self.assertMultiLineEqual(
             grep("FORBIDDEN", [PARADISELOSTFILENAME], "-i"),
-            "Of that Forbidden Tree, whose mortal tast\n"
-        )
+            "Of that Forbidden Tree, whose mortal tast\n")
 
     def test_one_file_one_match_print_file_names_flag(self):
         self.assertMultiLineEqual(
             grep("Forbidden", [PARADISELOSTFILENAME], "-l"),
-            PARADISELOSTFILENAME + '\n'
-        )
+            PARADISELOSTFILENAME + '\n')
 
     def test_one_file_one_match_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
-            grep("With loss of Eden, till one greater Man", [PARADISELOSTFILENAME], "-x"),
-            "With loss of Eden, till one greater Man\n"
-        )
+            grep("With loss of Eden, till one greater Man",
+                 [PARADISELOSTFILENAME], "-x"),
+            "With loss of Eden, till one greater Man\n")
 
     def test_one_file_one_match_multiple_flags(self):
         self.assertMultiLineEqual(
-            grep("OF ATREUS, Agamemnon, KIng of MEN.", [ILIADFILENAME], "-n -i -x"),
-            "9:Of Atreus, Agamemnon, King of men.\n"
-        )
+            grep("OF ATREUS, Agamemnon, KIng of MEN.", [ILIADFILENAME],
+                 "-n -i -x"), "9:Of Atreus, Agamemnon, King of men.\n")
 
     def test_one_file_several_matches_no_flags(self):
         self.assertMultiLineEqual(
             grep("may", [MIDSUMMERNIGHTFILENAME]),
             ("Nor how it may concern my modesty,\n"
              "But I beseech your grace that I may know\n"
-             "The worst that may befall me in this case,\n")
-        )
+             "The worst that may befall me in this case,\n"))
 
     def test_one_file_several_matches_print_line_numbers_flag(self):
         self.assertMultiLineEqual(
             grep("may", [MIDSUMMERNIGHTFILENAME], "-n"),
             ("3:Nor how it may concern my modesty,\n"
              "5:But I beseech your grace that I may know\n"
-             "6:The worst that may befall me in this case,\n")
-        )
+             "6:The worst that may befall me in this case,\n"))
 
     def test_one_file_several_matches_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
-            grep("may", [MIDSUMMERNIGHTFILENAME], "-x"),
-            ""
-        )
+            grep("may", [MIDSUMMERNIGHTFILENAME], "-x"), "")
 
     def test_one_file_several_matches_case_insensitive_flag(self):
         self.assertMultiLineEqual(
             grep("ACHILLES", [ILIADFILENAME], "-i"),
             ("Achilles sing, O Goddess! Peleus' son;\n"
-             "The noble Chief Achilles from the son\n")
-        )
+             "The noble Chief Achilles from the son\n"))
 
     def test_one_file_several_matches_inverted_flag(self):
         self.assertMultiLineEqual(
@@ -136,89 +124,88 @@ class GrepTest(unittest.TestCase):
              "With loss of Eden, till one greater Man\n"
              "Restore us, and regain the blissful Seat,\n"
              "Sing Heav'nly Muse, that on the secret top\n"
-             "That Shepherd, who first taught the chosen Seed\n")
-        )
+             "That Shepherd, who first taught the chosen Seed\n"))
 
     def test_one_file_no_matches_various_flags(self):
         self.assertMultiLineEqual(
-            grep("Gandalf", [ILIADFILENAME], "-n -l -x -i"),
-            ""
-        )
+            grep("Gandalf", [ILIADFILENAME], "-n -l -x -i"), "")
 
     def test_multiple_files_one_match_no_flags(self):
         self.assertMultiLineEqual(
-            grep("Agamemnon", [ILIADFILENAME, MIDSUMMERNIGHTFILENAME, PARADISELOSTFILENAME]),
-            "iliad.txt:Of Atreus, Agamemnon, King of men.\n"
-        )
+            grep(
+                "Agamemnon",
+                [ILIADFILENAME, MIDSUMMERNIGHTFILENAME, PARADISELOSTFILENAME]),
+            "iliad.txt:Of Atreus, Agamemnon, King of men.\n")
 
     def test_multiple_files_several_matches_no_flags(self):
         self.assertMultiLineEqual(
-            grep("may", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]),
+            grep("may",
+                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"]),
             ("midsummer-night.txt:Nor how it may concern my modesty,\n"
              "midsummer-night.txt:But I beseech your grace that I may know\n"
-             "midsummer-night.txt:The worst that may befall me in this case,\n")
-        )
+             "midsummer-night.txt:The worst that may befall me in this case,\n"
+             ))
 
     def test_multiple_files_several_matches_print_line_numbers_flag(self):
         self.assertMultiLineEqual(
-            grep("that", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"], "-n"),
+            grep("that",
+                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
+                 "-n"),
             ("midsummer-night.txt:5:But I beseech your grace that I may know\n"
-             "midsummer-night.txt:6:The worst that may befall me in this case,\n"
-             "paradise-lost.txt:2:Of that Forbidden Tree, whose mortal tast\n"
-             "paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top\n")
-        )
+             "midsummer-night.txt:6:The worst that may befall me in this case,"
+             "\nparadise-lost.txt:2:Of that Forbidden Tree, whose mortal tast"
+             "\nparadise-lost.txt:6:Sing Heav'nly Muse, that on the secret top"
+             "\n"))
 
     def test_multiple_files_one_match_print_file_names_flag(self):
         self.assertMultiLineEqual(
-            grep("who", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"], "-l"),
-            ILIADFILENAME + '\n' + PARADISELOSTFILENAME + '\n'
-        )
+            grep("who",
+                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
+                 "-l"), ILIADFILENAME + '\n' + PARADISELOSTFILENAME + '\n')
 
     def test_multiple_files_several_matches_case_insensitive_flag(self):
         self.assertMultiLineEqual(
-            grep("TO", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"], "-i"),
+            grep("TO",
+                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
+                 "-i"),
             ("iliad.txt:Caused to Achaia's host, sent many a soul\n"
              "iliad.txt:Illustrious into Ades premature,\n"
              "iliad.txt:And Heroes gave (so stood the will of Jove)\n"
              "iliad.txt:To dogs and to all ravening fowls a prey,\n"
              "midsummer-night.txt:I do entreat your grace to pardon me.\n"
-             "midsummer-night.txt:In such a presence here to plead my thoughts;\n"
-             "midsummer-night.txt:If I refuse to wed Demetrius.\n"
-             "paradise-lost.txt:Brought Death into the World, and all our woe,\n"
-             "paradise-lost.txt:Restore us, and regain the blissful Seat,\n"
-             "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top\n")
-        )
+             "midsummer-night.txt:In such a presence here to plead my thoughts"
+             ";\nmidsummer-night.txt:If I refuse to wed Demetrius.\n"
+             "paradise-lost.txt:Brought Death into the World, and all our woe,"
+             "\nparadise-lost.txt:Restore us, and regain the blissful Seat,\n"
+             "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top\n"))
 
     def test_multiple_files_several_matches_inverted_flag(self):
         self.assertMultiLineEqual(
-            grep("a", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"], "-v"),
-            ("iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
-             "iliad.txt:The noble Chief Achilles from the son\n"
-             "midsummer-night.txt:If I refuse to wed Demetrius.\n")
-        )
+            grep(
+                "a", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
+                "-v"), ("iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
+                        "iliad.txt:The noble Chief Achilles from the son\n"
+                        "midsummer-night.txt:If I refuse to wed Demetrius.\n"))
 
     def test_multiple_files_one_match_match_entire_lines_flag(self):
         self.assertMultiLineEqual(
             grep("But I beseech your grace that I may know",
                  ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
                  "-x"),
-            "midsummer-night.txt:But I beseech your grace that I may know\n"
-        )
+            "midsummer-night.txt:But I beseech your grace that I may know\n")
 
     def test_multiple_files_one_match_multiple_flags(self):
         self.assertMultiLineEqual(
             grep("WITH LOSS OF EDEN, TILL ONE GREATER MAN",
                  ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
                  "-n -i -x"),
-            "paradise-lost.txt:4:With loss of Eden, till one greater Man\n"
-        )
+            "paradise-lost.txt:4:With loss of Eden, till one greater Man\n")
 
     def test_multiple_files_no_matches_various_flags(self):
         self.assertMultiLineEqual(
-            grep("Frodo", ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
-                 "-n -l -x -i"),
-            ""
-        )
+            grep("Frodo",
+                 ["iliad.txt", "midsummer-night.txt", "paradise-lost.txt"],
+                 "-n -l -x -i"), "")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/hamming/hamming_test.py

@@ -8,43 +8,43 @@ import hamming
 class HammingTest(unittest.TestCase):
 
     def test_identical_strands(self):
-        self.assertEqual(0, hamming.distance("A", "A"))
+        self.assertEqual(hamming.distance("A", "A"), 0)
 
     def test_long_identical_strands(self):
-        self.assertEqual(0, hamming.distance("GGACTGA", "GGACTGA"))
+        self.assertEqual(hamming.distance("GGACTGA", "GGACTGA"), 0)
 
     def test_complete_distance_in_single_nucleotide_strands(self):
-        self.assertEqual(1, hamming.distance("A", "G"))
+        self.assertEqual(hamming.distance("A", "G"), 1)
 
     def test_complete_distance_in_small_strands(self):
-        self.assertEqual(2, hamming.distance("AG", "CT"))
+        self.assertEqual(hamming.distance("AG", "CT"), 2)
 
     def test_small_distance_in_small_strands(self):
-        self.assertEqual(1, hamming.distance("AT", "CT"))
+        self.assertEqual(hamming.distance("AT", "CT"), 1)
 
     def test_small_distance(self):
-        self.assertEqual(1, hamming.distance("GGACG", "GGTCG"))
+        self.assertEqual(hamming.distance("GGACG", "GGTCG"), 1)
 
     def test_small_distance_in_long_strands(self):
-        self.assertEqual(2, hamming.distance("ACCAGGG", "ACTATGG"))
+        self.assertEqual(hamming.distance("ACCAGGG", "ACTATGG"), 2)
 
     def test_non_unique_character_in_first_strand(self):
-        self.assertEqual(1, hamming.distance("AGA", "AGG"))
+        self.assertEqual(hamming.distance("AGA", "AGG"), 1)
 
     def test_non_unique_character_in_second_strand(self):
-        self.assertEqual(1, hamming.distance("AGG", "AGA"))
+        self.assertEqual(hamming.distance("AGG", "AGA"), 1)
 
     def test_same_nucleotides_in_different_positions(self):
-        self.assertEqual(2, hamming.distance("TAG", "GAT"))
+        self.assertEqual(hamming.distance("TAG", "GAT"), 2)
 
     def test_large_distance(self):
-        self.assertEqual(4, hamming.distance("GATACA", "GCATAA"))
+        self.assertEqual(hamming.distance("GATACA", "GCATAA"), 4)
 
     def test_large_distance_in_off_by_one_strand(self):
-        self.assertEqual(9, hamming.distance("GGACGGATTCTG", "AGGACGGATTCT"))
+        self.assertEqual(hamming.distance("GGACGGATTCTG", "AGGACGGATTCT"), 9)
 
     def test_empty_strands(self):
-        self.assertEqual(0, hamming.distance("", ""))
+        self.assertEqual(hamming.distance("", ""), 0)
 
     def test_disallow_first_strand_longer(self):
         with self.assertRaises(ValueError):

data/tracks/python/exercises/hello-world/hello_world_test.py

@@ -6,9 +6,8 @@ import hello_world
 # test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
 
 class HelloWorldTests(unittest.TestCase):
-
     def test_hello(self):
-        self.assertEqual('Hello, World!', hello_world.hello())
+        self.assertEqual(hello_world.hello(), 'Hello, World!')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/hexadecimal/hexadecimal_test.py

@@ -7,33 +7,32 @@ from hexadecimal import hexa
 
 
 class HexadecimalTest(unittest.TestCase):
-
     def test_valid_hexa1(self):
-        self.assertEqual(1, hexa('1'))
+        self.assertEqual(hexa('1'), 1)
 
     def test_valid_hexa2(self):
-        self.assertEqual(12, hexa('c'))
+        self.assertEqual(hexa('c'), 12)
 
     def test_valid_hexa3(self):
-        self.assertEqual(16, hexa('10'))
+        self.assertEqual(hexa('10'), 16)
 
     def test_valid_hexa4(self):
-        self.assertEqual(175, hexa('af'))
+        self.assertEqual(hexa('af'), 175)
 
     def test_valid_hexa5(self):
-        self.assertEqual(256, hexa('100'))
+        self.assertEqual(hexa('100'), 256)
 
     def test_valid_hexa6(self):
-        self.assertEqual(105166, hexa('19ACE'))
+        self.assertEqual(hexa('19ACE'), 105166)
 
     def test_valid_hexa7(self):
-        self.assertEqual(0, hexa('000000'))
+        self.assertEqual(hexa('000000'), 0)
 
     def test_valid_hexa8(self):
-        self.assertEqual(16776960, hexa('ffff00'))
+        self.assertEqual(hexa('ffff00'), 16776960)
 
     def test_valid_hexa9(self):
-        self.assertEqual(65520, hexa('00fff0'))
+        self.assertEqual(hexa('00fff0'), 65520)
 
     def test_invalid_hexa(self):
         with self.assertRaises(ValueError):