trackler 2.0.8.27 → 2.0.8.28

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

@@ -1,5 +1,5 @@
-from datetime import date
 import unittest
+from datetime import date
 
 from meetup import meetup_day
 
@@ -11,56 +11,56 @@ except ImportError:
 
 class MeetupTest(unittest.TestCase):
     def test_monteenth_of_may_2013(self):
-        self.assertEqual(date(2013, 5, 13),
-                         meetup_day(2013, 5, 'Monday', 'teenth'))
+        self.assertEqual(
+            meetup_day(2013, 5, 'Monday', 'teenth'), date(2013, 5, 13))
 
     def test_saturteenth_of_february_2013(self):
-        self.assertEqual(date(2013, 2, 16),
-                         meetup_day(2013, 2, 'Saturday', 'teenth'))
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', 'teenth'), date(2013, 2, 16))
 
     def test_first_tuesday_of_may_2013(self):
-        self.assertEqual(date(2013, 5, 7),
-                         meetup_day(2013, 5, 'Tuesday', '1st'))
+        self.assertEqual(
+            meetup_day(2013, 5, 'Tuesday', '1st'), date(2013, 5, 7))
 
     def test_second_monday_of_april_2013(self):
-        self.assertEqual(date(2013, 4, 8),
-                         meetup_day(2013, 4, 'Monday', '2nd'))
+        self.assertEqual(
+            meetup_day(2013, 4, 'Monday', '2nd'), date(2013, 4, 8))
 
     def test_third_thursday_of_september_2013(self):
-        self.assertEqual(date(2013, 9, 19),
-                         meetup_day(2013, 9, 'Thursday', '3rd'))
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', '3rd'), date(2013, 9, 19))
 
     def test_fourth_sunday_of_march_2013(self):
-        self.assertEqual(date(2013, 3, 24),
-                         meetup_day(2013, 3, 'Sunday', '4th'))
+        self.assertEqual(
+            meetup_day(2013, 3, 'Sunday', '4th'), date(2013, 3, 24))
 
     def test_last_thursday_of_october_2013(self):
-        self.assertEqual(date(2013, 10, 31),
-                         meetup_day(2013, 10, 'Thursday', 'last'))
+        self.assertEqual(
+            meetup_day(2013, 10, 'Thursday', 'last'), date(2013, 10, 31))
 
     def test_last_wednesday_of_february_2012(self):
-        self.assertEqual(date(2012, 2, 29),
-                         meetup_day(2012, 2, 'Wednesday', 'last'))
+        self.assertEqual(
+            meetup_day(2012, 2, 'Wednesday', 'last'), date(2012, 2, 29))
 
     def test_last_wednesday_of_december_2014(self):
-        self.assertEqual(date(2014, 12, 31),
-                         meetup_day(2014, 12, 'Wednesday', 'last'))
+        self.assertEqual(
+            meetup_day(2014, 12, 'Wednesday', 'last'), date(2014, 12, 31))
 
     def test_last_sunday_of_only_four_week_february_2015(self):
-        self.assertEqual(date(2015, 2, 22),
-                         meetup_day(2015, 2, 'Sunday', 'last'))
+        self.assertEqual(
+            meetup_day(2015, 2, 'Sunday', 'last'), date(2015, 2, 22))
 
     def test_first_friday_of_december_2012(self):
-        self.assertEqual(date(2012, 12, 7),
-                         meetup_day(2012, 12, 'Friday', '1st'))
+        self.assertEqual(
+            meetup_day(2012, 12, 'Friday', '1st'), date(2012, 12, 7))
 
     def test_fifth_monday_of_march_2015(self):
-        self.assertEqual(date(2015, 3, 30),
-                         meetup_day(2015, 3, 'Monday', '5th'))
+        self.assertEqual(
+            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')
+        self.assertRaises(MeetupDayException, meetup_day, 2015, 2, 'Monday',
+                          '5th')
 
 
 if __name__ == '__main__':

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

@@ -32,6 +32,8 @@ def verify_board(inp):
     if cset - set('+- *|'):
         raise ValueError("Invalid board")
     # Borders not as expected
-    if any(inp[i1] != '+' + '-' * (rowlen - 2) + '+' for i1 in [0, -1]) or \
-       any(inp[i1][i2] != '|' for i1 in range(1, collen - 1) for i2 in [0, -1]):
+    if any(inp[i1] != '+' + '-' * (rowlen - 2) + '+'
+           for i1 in [0, -1]) or any(inp[i1][i2] != '|'
+                                     for i1 in range(1, collen - 1)
+                                     for i2 in [0, -1]):
         raise ValueError("Invalid board")

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

@@ -29,7 +29,7 @@ class MinesweeperTest(unittest.TestCase):
                "|1*22*2|",
                "|111111|",
                "+------+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board2(self):
         inp = ["+-----+",
@@ -46,7 +46,7 @@ class MinesweeperTest(unittest.TestCase):
                "|12*4*|",
                "|1*3*2|",
                "+-----+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board3(self):
         inp = ["+-----+",
@@ -55,7 +55,7 @@ class MinesweeperTest(unittest.TestCase):
         out = ["+-----+",
                "|1*2*1|",
                "+-----+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board4(self):
         inp = ["+-+",
@@ -72,7 +72,7 @@ class MinesweeperTest(unittest.TestCase):
                "|1|",
                "| |",
                "+-+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board5(self):
         inp = ["+-+",
@@ -81,7 +81,7 @@ class MinesweeperTest(unittest.TestCase):
         out = ["+-+",
                "|*|",
                "+-+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board6(self):
         inp = ["+--+",
@@ -92,7 +92,7 @@ class MinesweeperTest(unittest.TestCase):
                "|**|",
                "|**|",
                "+--+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board7(self):
         inp = ["+--+",
@@ -103,7 +103,7 @@ class MinesweeperTest(unittest.TestCase):
                "|**|",
                "|**|",
                "+--+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board8(self):
         inp = ["+---+",
@@ -116,7 +116,7 @@ class MinesweeperTest(unittest.TestCase):
                "|*8*|",
                "|***|",
                "+---+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_board9(self):
         inp = ["+-----+",
@@ -133,7 +133,7 @@ class MinesweeperTest(unittest.TestCase):
                "|111  |",
                "|1*1  |",
                "+-----+"]
-        self.assertEqual(out, board(inp))
+        self.assertEqual(board(inp), out)
 
     def test_different_len(self):
         inp = ["+-+",

data/tracks/python/exercises/nucleotide-count/nucleotide_count_test.py

@@ -11,21 +11,21 @@ from nucleotide_count import count, nucleotide_counts
 
 class DNATest(unittest.TestCase):
     def test_empty_dna_string_has_no_adenosine(self):
-        self.assertEqual(0, count('', 'A'))
+        self.assertEqual(count('', 'A'), 0)
 
     def test_empty_dna_string_has_no_nucleotides(self):
         expected = {'A': 0, 'T': 0, 'C': 0, 'G': 0}
-        self.assertEqual(expected, nucleotide_counts(""))
+        self.assertEqual(nucleotide_counts(""), expected)
 
     def test_repetitive_cytidine_gets_counted(self):
-        self.assertEqual(5, count('CCCCC', 'C'))
+        self.assertEqual(count('CCCCC', 'C'), 5)
 
     def test_repetitive_sequence_has_only_guanosine(self):
         expected = {'A': 0, 'T': 0, 'C': 0, 'G': 8}
-        self.assertEqual(expected, nucleotide_counts('GGGGGGGG'))
+        self.assertEqual(nucleotide_counts('GGGGGGGG'), expected)
 
     def test_counts_only_thymidine(self):
-        self.assertEqual(1, count('GGGGGTAACCCGG', 'T'))
+        self.assertEqual(count('GGGGGTAACCCGG', 'T'), 1)
 
     def test_validates_nucleotides(self):
         with self.assertRaises(ValueError):
@@ -35,7 +35,7 @@ class DNATest(unittest.TestCase):
         dna = ('AGCTTTTCATTCTGACTGCAACGGGCAATATGTCT'
                'CTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC')
         expected = {'A': 20, 'T': 21, 'G': 17, 'C': 12}
-        self.assertEqual(expected, nucleotide_counts(dna))
+        self.assertEqual(nucleotide_counts(dna), expected)
 
 
 if __name__ == '__main__':

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

@@ -12,36 +12,35 @@ from ocr_numbers import grid, number
 
 
 class OcrTest(unittest.TestCase):
-
     def test_0(self):
-        self.assertEqual('0', number([" _ ",
-                                      "| |",
-                                      "|_|",
-                                      "   "]))
+        self.assertEqual(number([" _ ",
+                                 "| |",
+                                 "|_|",
+                                 "   "]), '0')
 
     def test_1(self):
-        self.assertEqual('1', number(["   ",
-                                      "  |",
-                                      "  |",
-                                      "   "]))
+        self.assertEqual(number(["   ",
+                                 "  |",
+                                 "  |",
+                                 "   "]), '1')
 
     def test_garbage(self):
-        self.assertEqual('?', number([" _ ",
-                                      " _|",
-                                      "  |",
-                                      "   "]))
+        self.assertEqual(number([" _ ",
+                                 " _|",
+                                 "  |",
+                                 "   "]), '?')
 
     def test_last_line_nonblank(self):
-        self.assertEqual('?', number(["   ",
-                                      "  |",
-                                      "  |",
-                                      "| |"]))
+        self.assertEqual(number(["   ",
+                                 "  |",
+                                 "  |",
+                                 "| |"]), '?')
 
     def test_unknown_char(self):
-        self.assertEqual('?', number([" - ",
-                                      " _|",
-                                      " X|",
-                                      "   "]))
+        self.assertEqual(number([" - ",
+                                 " _|",
+                                 " X|",
+                                 "   "]), '?')
 
     def test_too_short_row(self):
         self.assertRaises(ValueError, number, ["   ",
@@ -55,49 +54,64 @@ class OcrTest(unittest.TestCase):
                                                " X|"])
 
     def test_grid0(self):
-        self.assertEqual([" _ ",
-                          "| |",
-                          "|_|",
-                          "   "], grid('0'))
+        self.assertEqual(grid('0'), [" _ ",
+                                     "| |",
+                                     "|_|",
+                                     "   "])
 
     def test_grid1(self):
-        self.assertEqual(["   ",
-                          "  |",
-                          "  |",
-                          "   "], grid('1'))
+        self.assertEqual(grid('1'), ["   ",
+                                     "  |",
+                                     "  |",
+                                     "   "])
 
     def test_0010110(self):
-        self.assertEqual('0010110', number([" _  _     _        _ ",
-                                            "| || |  || |  |  || |",
-                                            "|_||_|  ||_|  |  ||_|",
-                                            "                     "]))
+        self.assertEqual(
+            number([
+                " _  _     _        _ ",
+                "| || |  || |  |  || |",
+                "|_||_|  ||_|  |  ||_|",
+                "                     "
+            ]), '0010110')
 
     def test_3186547290(self):
         digits = '3186547290'
-        self.assertEqual(digits, number([" _     _  _  _     _  _  _  _ ",
-                                         " _|  ||_||_ |_ |_|  | _||_|| |",
-                                         " _|  ||_||_| _|  |  ||_  _||_|",
-                                         "                              "]))
+        self.assertEqual(
+            number([
+                " _     _  _  _     _  _  _  _ ",
+                " _|  ||_||_ |_ |_|  | _||_|| |",
+                " _|  ||_||_| _|  |  ||_  _||_|",
+                "                              "
+            ]), digits)
 
     def test_Lost(self):
         digits = '4815162342'
-        self.assertEqual(digits, number(["    _     _     _  _  _     _ ",
-                                         "|_||_|  ||_   ||_  _| _||_| _|",
-                                         "  ||_|  | _|  ||_||_  _|  ||_ ",
-                                         "                              "]))
+        self.assertEqual(
+            number([
+                "    _     _     _  _  _     _ ",
+                "|_||_|  ||_   ||_  _| _||_| _|",
+                "  ||_|  | _|  ||_||_  _|  ||_ ",
+                "                              "
+            ]), digits)
 
     def test_garble_middle(self):
-        self.assertEqual('12?45', number(["    _  _     _ ",
-                                          "  | _|  ||_||_ ",
-                                          "  ||_  _|  | _|",
-                                          "               "]))
+        self.assertEqual(
+            number([
+                "    _  _     _ ",
+                "  | _|  ||_||_ ",
+                "  ||_  _|  | _|",
+                "               "
+            ]), '12?45')
 
     def test_grid3186547290(self):
         digits = '3186547290'
-        self.assertEqual([" _     _  _  _     _  _  _  _ ",
-                          " _|  ||_||_ |_ |_|  | _||_|| |",
-                          " _|  ||_||_| _|  |  ||_  _||_|",
-                          "                              "], grid(digits))
+        self.assertEqual(
+            grid(digits), [
+                " _     _  _  _     _  _  _  _ ",
+                " _|  ||_||_ |_ |_|  | _||_|| |",
+                " _|  ||_||_| _|  |  ||_  _||_|",
+                "                              "
+            ])
 
     def test_invalid_grid(self):
         self.assertRaises(ValueError, grid, '123a')

data/tracks/python/exercises/octal/octal_test.py

@@ -11,22 +11,22 @@ from octal import parse_octal
 
 class OctalTest(unittest.TestCase):
     def test_octal_1_is_decimal_1(self):
-        self.assertEqual(1, parse_octal("1"))
+        self.assertEqual(parse_octal("1"), 1)
 
     def test_octal_10_is_decimal_8(self):
-        self.assertEqual(8, parse_octal("10"))
+        self.assertEqual(parse_octal("10"), 8)
 
     def test_octal_17_is_decimal_15(self):
-        self.assertEqual(15, parse_octal("17"))
+        self.assertEqual(parse_octal("17"), 15)
 
     def test_octal_130_is_decimal_88(self):
-        self.assertEqual(88, parse_octal("130"))
+        self.assertEqual(parse_octal("130"), 88)
 
     def test_octal_2047_is_decimal_1063(self):
-        self.assertEqual(1063, parse_octal("2047"))
+        self.assertEqual(parse_octal("2047"), 1063)
 
     def test_octal_1234567_is_decimal_342391(self):
-        self.assertEqual(342391, parse_octal("1234567"))
+        self.assertEqual(parse_octal("1234567"), 342391)
 
     def test_8_is_seen_as_invalid(self):
         self.assertRaises(ValueError, parse_octal, "8")
@@ -38,7 +38,7 @@ class OctalTest(unittest.TestCase):
         self.assertRaises(ValueError, parse_octal, "6789")
 
     def test_valid_octal_formatted_string_011_is_decimal_9(self):
-        self.assertEqual(9, parse_octal("011"))
+        self.assertEqual(parse_octal("011"), 9)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/palindrome-products/palindrome_products_test.py

@@ -19,28 +19,28 @@ from palindrome_products import smallest_palindrome, largest_palindrome
 class PalindromesTests(unittest.TestCase):
     def test_largest_palindrome_from_single_digit_factors(self):
         value, factors = largest_palindrome(max_factor=9)
-        self.assertEqual(9, value)
+        self.assertEqual(value, 9)
         self.assertIn(set(factors), [{1, 9}, {3, 3}])
 
     def test_largest_palindrome_from_double_digit_factors(self):
         value, factors = largest_palindrome(max_factor=99, min_factor=10)
-        self.assertEqual(9009, value)
-        self.assertEqual({91, 99}, set(factors))
+        self.assertEqual(value, 9009)
+        self.assertEqual(set(factors), {91, 99})
 
     def test_smallest_palindrome_from_double_digit_factors(self):
         value, factors = smallest_palindrome(max_factor=99, min_factor=10)
-        self.assertEqual(121, value)
-        self.assertEqual({11}, set(factors))
+        self.assertEqual(value, 121)
+        self.assertEqual(set(factors), {11})
 
     def test_largest_palindrome_from_triple_digit_factors(self):
         value, factors = largest_palindrome(max_factor=999, min_factor=100)
-        self.assertEqual(906609, value)
-        self.assertEqual({913, 993}, set(factors))
+        self.assertEqual(value, 906609)
+        self.assertEqual(set(factors), {913, 993})
 
     def test_smallest_palindrome_from_triple_digit_factors(self):
         value, factors = smallest_palindrome(max_factor=999, min_factor=100)
-        self.assertEqual(10201, value)
-        self.assertEqual({101, 101}, set(factors))
+        self.assertEqual(value, 10201)
+        self.assertEqual(set(factors), {101, 101})
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/pascals-triangle/pascals_triangle_test.py

@@ -6,32 +6,32 @@ from pascals_triangle import triangle, row, is_triangle
 class PascalsTriangleTest(unittest.TestCase):
     def test_triangle1(self):
         ans = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1']
-        self.assertEqual(ans, triangle(4))
+        self.assertEqual(triangle(4), ans)
 
     def test_triangle2(self):
         ans = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1', '1 5 10 10 5 1',
                '1 6 15 20 15 6 1']
-        self.assertEqual(ans, triangle(6))
+        self.assertEqual(triangle(6), ans)
 
     def test_is_triangle_true(self):
         inp = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1', '1 5 10 10 5 1']
-        self.assertEqual(True, is_triangle(inp))
+        self.assertTrue(is_triangle(inp))
 
     def test_is_triangle_false(self):
         inp = ['1', '1 1', '1 2 1', '1 4 4 1']
-        self.assertEqual(False, is_triangle(inp))
+        self.assertFalse(is_triangle(inp))
 
     def test_row1(self):
         ans = '1'
-        self.assertEqual(ans, row(0))
+        self.assertEqual(row(0), ans)
 
     def test_row2(self):
         ans = '1 2 1'
-        self.assertEqual(ans, row(2))
+        self.assertEqual(row(2), ans)
 
     def test_row3(self):
         ans = '1 7 21 35 35 21 7 1'
-        self.assertEqual(ans, row(7))
+        self.assertEqual(row(7), ans)
 
 
 if __name__ == '__main__':