trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/queen-attack/queen_attack_test.py

@@ -13,7 +13,7 @@ class QueenAttackTest(unittest.TestCase):
                '______B_',
                '________',
                '________']
-        self.assertEqual(ans, board((2, 3), (5, 6)))
+        self.assertEqual(board((2, 3), (5, 6)), ans)
 
     def test_board2(self):
         ans = ['______W_',
@@ -24,31 +24,31 @@ class QueenAttackTest(unittest.TestCase):
                '________',
                '________',
                '________']
-        self.assertEqual(ans, board((0, 6), (1, 7)))
+        self.assertEqual(board((0, 6), (1, 7)), ans)
 
     def test_attack_true1(self):
-        self.assertEqual(True, can_attack((2, 3), (5, 6)))
+        self.assertTrue(can_attack((2, 3), (5, 6)))
 
     def test_attack_true2(self):
-        self.assertEqual(True, can_attack((2, 6), (5, 3)))
+        self.assertTrue(can_attack((2, 6), (5, 3)))
 
     def test_attack_true3(self):
-        self.assertEqual(True, can_attack((2, 4), (2, 7)))
+        self.assertTrue(can_attack((2, 4), (2, 7)))
 
     def test_attack_true4(self):
-        self.assertEqual(True, can_attack((5, 4), (2, 4)))
+        self.assertTrue(can_attack((5, 4), (2, 4)))
 
     def test_attack_true5(self):
-        self.assertEqual(True, can_attack((1, 1), (6, 6)))
+        self.assertTrue(can_attack((1, 1), (6, 6)))
 
     def test_attack_true6(self):
-        self.assertEqual(True, can_attack((0, 6), (1, 7)))
+        self.assertTrue(can_attack((0, 6), (1, 7)))
 
     def test_attack_false1(self):
-        self.assertEqual(False, can_attack((4, 2), (0, 5)))
+        self.assertFalse(can_attack((4, 2), (0, 5)))
 
     def test_attack_false2(self):
-        self.assertEqual(False, can_attack((2, 3), (4, 7)))
+        self.assertFalse(can_attack((2, 3), (4, 7)))
 
     # If either board or can_attack are called with an invalid board position
     # they should raise a ValueError with a meaningful error message.

data/tracks/python/exercises/rail-fence-cipher/example.py

@@ -14,4 +14,5 @@ def encode(msg, rails):
 def decode(msg, rails):
     fence = fence_pattern(rails, len(msg))
     fence_msg = zip(msg, sorted(fence))
-    return ''.join(char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))
+    return ''.join(
+        char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))

data/tracks/python/exercises/rail-fence-cipher/rail_fence_cipher_test.py

@@ -4,31 +4,32 @@ from rail_fence_cipher import encode, decode
 
 
 class RailFenceTests(unittest.TestCase):
-
     def test_encode_with_two_rails(self):
-        self.assertMultiLineEqual('XXXXXXXXXOOOOOOOOO',
-                                  encode('XOXOXOXOXOXOXOXOXO', 2))
+        self.assertMultiLineEqual(
+            encode('XOXOXOXOXOXOXOXOXO', 2), 'XXXXXXXXXOOOOOOOOO')
 
     def test_encode_with_three_rails(self):
-        self.assertMultiLineEqual('WECRLTEERDSOEEFEAOCAIVDEN',
-                                  encode('WEAREDISCOVEREDFLEEATONCE', 3))
+        self.assertMultiLineEqual(
+            encode('WEAREDISCOVEREDFLEEATONCE', 3),
+            'WECRLTEERDSOEEFEAOCAIVDEN')
 
     def test_encode_with_middle_stop(self):
-        self.assertMultiLineEqual('ESXIEECSR', encode('EXERCISES', 4))
+        self.assertMultiLineEqual(encode('EXERCISES', 4), 'ESXIEECSR')
 
     def test_decode_with_three_rails(self):
-        self.assertMultiLineEqual('THEDEVILISINTHEDETAILS',
-                                  decode('TEITELHDVLSNHDTISEIIEA', 3))
+        self.assertMultiLineEqual(
+            decode('TEITELHDVLSNHDTISEIIEA', 3), 'THEDEVILISINTHEDETAILS')
 
     def test_decode_with_five_rails(self):
-        self.assertMultiLineEqual('EXERCISMISAWESOME',
-                                  decode('EIEXMSMESAORIWSCE', 5))
+        self.assertMultiLineEqual(
+            decode('EIEXMSMESAORIWSCE', 5), 'EXERCISMISAWESOME')
 
     def test_decode_with_six_rails(self):
         self.assertMultiLineEqual(
-            '112358132134558914423337761098715972584418167651094617711286',
-            decode('133714114238148966225439541018335470986172518171757571896261', 6)
-        )
+            decode(
+                '133714114238148966225439541018335470986172518171757571896261',
+                6),
+            '112358132134558914423337761098715972584418167651094617711286')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/raindrops/raindrops_test.py

@@ -5,52 +5,52 @@ from raindrops import raindrops
 
 class RaindropsTest(unittest.TestCase):
     def test_1(self):
-        self.assertEqual("1", raindrops(1))
+        self.assertEqual(raindrops(1), "1")
 
     def test_3(self):
-        self.assertEqual("Pling", raindrops(3))
+        self.assertEqual(raindrops(3), "Pling")
 
     def test_5(self):
-        self.assertEqual("Plang", raindrops(5))
+        self.assertEqual(raindrops(5), "Plang")
 
     def test_7(self):
-        self.assertEqual("Plong", raindrops(7))
+        self.assertEqual(raindrops(7), "Plong")
 
     def test_6(self):
-        self.assertEqual("Pling", raindrops(6))
+        self.assertEqual(raindrops(6), "Pling")
 
     def test_9(self):
-        self.assertEqual("Pling", raindrops(9))
+        self.assertEqual(raindrops(9), "Pling")
 
     def test_10(self):
-        self.assertEqual("Plang", raindrops(10))
+        self.assertEqual(raindrops(10), "Plang")
 
     def test_14(self):
-        self.assertEqual("Plong", raindrops(14))
+        self.assertEqual(raindrops(14), "Plong")
 
     def test_15(self):
-        self.assertEqual("PlingPlang", raindrops(15))
+        self.assertEqual(raindrops(15), "PlingPlang")
 
     def test_21(self):
-        self.assertEqual("PlingPlong", raindrops(21))
+        self.assertEqual(raindrops(21), "PlingPlong")
 
     def test_25(self):
-        self.assertEqual("Plang", raindrops(25))
+        self.assertEqual(raindrops(25), "Plang")
 
     def test_35(self):
-        self.assertEqual("PlangPlong", raindrops(35))
+        self.assertEqual(raindrops(35), "PlangPlong")
 
     def test_49(self):
-        self.assertEqual("Plong", raindrops(49))
+        self.assertEqual(raindrops(49), "Plong")
 
     def test_52(self):
-        self.assertEqual("52", raindrops(52))
+        self.assertEqual(raindrops(52), "52")
 
     def test_105(self):
-        self.assertEqual("PlingPlangPlong", raindrops(105))
+        self.assertEqual(raindrops(105), "PlingPlangPlong")
 
     def test_12121(self):
-        self.assertEqual("12121", raindrops(12121))
+        self.assertEqual(raindrops(12121), "12121")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/rectangles/rectangles_test.py

@@ -5,21 +5,21 @@ from rectangles import count
 
 class WordTest(unittest.TestCase):
     def test_zero_area_1(self):
-        self.assertEqual(0, count())
+        self.assertEqual(count(), 0)
 
     def test_zero_area_2(self):
         lines = ""
-        self.assertEqual(0, count(lines))
+        self.assertEqual(count(lines), 0)
 
     def test_empty_area(self):
         lines = " "
-        self.assertEqual(0, count(lines))
+        self.assertEqual(count(lines), 0)
 
     def test_one_rectangle(self):
         lines = ["+-+",
                  "| |",
                  "+-+"]
-        self.assertEqual(1, count(lines))
+        self.assertEqual(count(lines), 1)
 
     def test_two_rectangles_no_shared_parts(self):
         lines = ["  +-+",
@@ -27,7 +27,7 @@ class WordTest(unittest.TestCase):
                  "+-+-+",
                  "| |  ",
                  "+-+  "]
-        self.assertEqual(2, count(lines))
+        self.assertEqual(count(lines), 2)
 
     def test_five_rectangles_three_regions(self):
         lines = ["  +-+",
@@ -35,7 +35,7 @@ class WordTest(unittest.TestCase):
                  "+-+-+",
                  "| | |",
                  "+-+-+"]
-        self.assertEqual(5, count(lines))
+        self.assertEqual(count(lines), 5)
 
     def test_incomplete_rectangles(self):
         lines = ["  +-+",
@@ -43,7 +43,7 @@ class WordTest(unittest.TestCase):
                  "+-+-+",
                  "| | -",
                  "+-+-+"]
-        self.assertEqual(1, count(lines))
+        self.assertEqual(count(lines), 1)
 
     def test_complicated(self):
         lines = ["+------+----+",
@@ -51,7 +51,7 @@ class WordTest(unittest.TestCase):
                  "+---+--+    |",
                  "|   |       |",
                  "+---+-------+"]
-        self.assertEqual(3, count(lines))
+        self.assertEqual(count(lines), 3)
 
     def test_not_so_complicated(self):
         lines = ["+------+----+",
@@ -59,7 +59,7 @@ class WordTest(unittest.TestCase):
                  "+------+    |",
                  "|   |       |",
                  "+---+-------+"]
-        self.assertEqual(2, count(lines))
+        self.assertEqual(count(lines), 2)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/rna-transcription/rna_transcription_test.py

@@ -7,28 +7,28 @@ from rna_transcription import to_rna
 
 class DNATests(unittest.TestCase):
     def test_transcribes_guanine_to_cytosine(self):
-        self.assertEqual('C', to_rna('G'))
+        self.assertEqual(to_rna('G'), 'C')
 
     def test_transcribes_cytosine_to_guanine(self):
-        self.assertEqual('G', to_rna('C'))
+        self.assertEqual(to_rna('C'), 'G')
 
     def test_transcribes_thymine_to_adenine(self):
-        self.assertEqual('A', to_rna('T'))
+        self.assertEqual(to_rna('T'), 'A')
 
     def test_transcribes_adenine_to_uracil(self):
-        self.assertEqual('U', to_rna('A'))
+        self.assertEqual(to_rna('A'), 'U')
 
     def test_transcribes_all_occurences(self):
-        self.assertMultiLineEqual('UGCACCAGAAUU', to_rna('ACGTGGTCTTAA'))
+        self.assertMultiLineEqual(to_rna('ACGTGGTCTTAA'), 'UGCACCAGAAUU')
 
     def test_correctly_handles_single_invalid_input(self):
-        self.assertEqual('', to_rna('U'))
+        self.assertEqual(to_rna('U'), '')
 
     def test_correctly_handles_completely_invalid_input(self):
-        self.assertMultiLineEqual('', to_rna('XXX'))
+        self.assertMultiLineEqual(to_rna('XXX'), '')
 
     def test_correctly_handles_partially_invalid_input(self):
-        self.assertMultiLineEqual('', to_rna('ACGTXXXCTTAA'))
+        self.assertMultiLineEqual(to_rna('ACGTXXXCTTAA'), '')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/robot-name/robot_name_test.py

@@ -1,7 +1,7 @@
 import unittest
+import random
 
 from robot_name import Robot
-import random
 
 
 class RobotTest(unittest.TestCase):

data/tracks/python/exercises/robot-simulator/robot_simulator_test.py

@@ -4,16 +4,15 @@ from robot_simulator import Robot, NORTH, EAST, SOUTH, WEST
 
 
 class RobotTests(unittest.TestCase):
-
     def test_init(self):
         robot = Robot()
-        self.assertEqual((0, 0), robot.coordinates)
-        self.assertEqual(NORTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (0, 0))
+        self.assertEqual(robot.bearing, NORTH)
 
     def test_setup(self):
         robot = Robot(SOUTH, -1, 1)
-        self.assertEqual((-1, 1), robot.coordinates)
-        self.assertEqual(SOUTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (-1, 1))
+        self.assertEqual(robot.bearing, SOUTH)
 
     def test_turn_right(self):
         robot = Robot()
@@ -30,44 +29,44 @@ class RobotTests(unittest.TestCase):
     def test_advance_positive_north(self):
         robot = Robot(NORTH, 0, 0)
         robot.advance()
-        self.assertEqual((0, 1), robot.coordinates)
-        self.assertEqual(NORTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (0, 1))
+        self.assertEqual(robot.bearing, NORTH)
 
     def test_advance_positive_east(self):
         robot = Robot(EAST, 0, 0)
         robot.advance()
-        self.assertEqual((1, 0), robot.coordinates)
-        self.assertEqual(EAST, robot.bearing)
+        self.assertEqual(robot.coordinates, (1, 0))
+        self.assertEqual(robot.bearing, EAST)
 
     def test_advance_negative_south(self):
         robot = Robot(SOUTH, 0, 0)
         robot.advance()
-        self.assertEqual((0, -1), robot.coordinates)
-        self.assertEqual(SOUTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (0, -1))
+        self.assertEqual(robot.bearing, SOUTH)
 
     def test_advance_positive_west(self):
         robot = Robot(WEST, 0, 0)
         robot.advance()
-        self.assertEqual((-1, 0), robot.coordinates)
-        self.assertEqual(WEST, robot.bearing)
+        self.assertEqual(robot.coordinates, (-1, 0))
+        self.assertEqual(robot.bearing, WEST)
 
     def test_simulate_prog1(self):
         robot = Robot(NORTH, 0, 0)
         robot.simulate("LAAARALA")
-        self.assertEqual((-4, 1), robot.coordinates)
-        self.assertEqual(WEST, robot.bearing)
+        self.assertEqual(robot.coordinates, (-4, 1))
+        self.assertEqual(robot.bearing, WEST)
 
     def test_simulate_prog2(self):
         robot = Robot(EAST, 2, -7)
         robot.simulate("RRAAAAALA")
-        self.assertEqual((-3, -8), robot.coordinates)
-        self.assertEqual(SOUTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (-3, -8))
+        self.assertEqual(robot.bearing, SOUTH)
 
     def test_simulate_prog3(self):
         robot = Robot(SOUTH, 8, 4)
         robot.simulate("LAAARRRALLLL")
-        self.assertEqual((11, 5), robot.coordinates)
-        self.assertEqual(NORTH, robot.bearing)
+        self.assertEqual(robot.coordinates, (11, 5))
+        self.assertEqual(robot.bearing, NORTH)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/roman-numerals/roman_numerals_test.py

@@ -27,7 +27,7 @@ class RomanTest(unittest.TestCase):
 
     def test_numerals(self):
         for arabic, numeral in self.numerals.items():
-            self.assertEqual(numeral, roman_numerals.numeral(arabic))
+            self.assertEqual(roman_numerals.numeral(arabic), numeral)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/run-length-encoding/run_length_encoding_test.py

@@ -4,49 +4,48 @@ from run_length_encoding import encode, decode
 
 
 class WordCountTests(unittest.TestCase):
-
     def test_encode_empty_string(self):
-        self.assertMultiLineEqual('', encode(''))
+        self.assertMultiLineEqual(encode(''), '')
 
     def test_encode_single_characters_only_are_encoded_without_count(self):
-        self.assertMultiLineEqual('XYZ', encode('XYZ'))
+        self.assertMultiLineEqual(encode('XYZ'), 'XYZ')
 
     def test_encode_string_with_no_single_characters(self):
-        self.assertMultiLineEqual('2A3B4C', encode('AABBBCCCC'))
+        self.assertMultiLineEqual(encode('AABBBCCCC'), '2A3B4C')
 
     def test_encode_single_characters_mixed_with_repeated_characters(self):
         self.assertMultiLineEqual(
-            '12WB12W3B24WB',
-            encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB'))
+            encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB'),
+            '12WB12W3B24WB')
 
     def test_encode_multiple_whitespace_mixed_in_string(self):
-        self.assertMultiLineEqual('2 hs2q q2w2 ', encode('  hsqq qww  '))
+        self.assertMultiLineEqual(encode('  hsqq qww  '), '2 hs2q q2w2 ')
 
     def test_encode_lowercase_characters(self):
-        self.assertMultiLineEqual('2a3b4c', encode('aabbbcccc'))
+        self.assertMultiLineEqual(encode('aabbbcccc'), '2a3b4c')
 
     def test_decode_empty_string(self):
-        self.assertMultiLineEqual('', decode(''))
+        self.assertMultiLineEqual(decode(''), '')
 
     def test_decode_single_characters_only(self):
-        self.assertMultiLineEqual('XYZ', decode('XYZ'))
+        self.assertMultiLineEqual(decode('XYZ'), 'XYZ')
 
     def test_decode_string_with_no_single_characters(self):
-        self.assertMultiLineEqual('AABBBCCCC', decode('2A3B4C'))
+        self.assertMultiLineEqual(decode('2A3B4C'), 'AABBBCCCC')
 
     def test_decode_single_characters_with_repeated_characters(self):
         self.assertMultiLineEqual(
-            'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB',
-            decode('12WB12W3B24WB'))
+            decode('12WB12W3B24WB'),
+            'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB')
 
     def test_decode_multiple_whitespace_mixed_in_string(self):
-        self.assertMultiLineEqual('  hsqq qww  ', decode('2 hs2q q2w2 '))
+        self.assertMultiLineEqual(decode('2 hs2q q2w2 '), '  hsqq qww  ')
 
     def test_decode_lower_case_string(self):
-        self.assertMultiLineEqual('aabbbcccc', decode('2a3b4c'))
+        self.assertMultiLineEqual(decode('2a3b4c'), 'aabbbcccc')
 
     def test_combination(self):
-        self.assertMultiLineEqual('zzz ZZ  zZ', decode(encode('zzz ZZ  zZ')))
+        self.assertMultiLineEqual(decode(encode('zzz ZZ  zZ')), 'zzz ZZ  zZ')
 
 
 if __name__ == '__main__':

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

@@ -13,18 +13,18 @@ from saddle_points import saddle_points
 class SaddlePointTest(unittest.TestCase):
     def test_one_saddle(self):
         inp = [[9, 8, 7], [5, 3, 2], [6, 6, 7]]
-        self.assertEqual(set([(1, 0)]), saddle_points(inp))
+        self.assertEqual(saddle_points(inp), set([(1, 0)]))
 
     def test_no_saddle(self):
-        self.assertEqual(set(), saddle_points([[2, 1], [1, 2]]))
+        self.assertEqual(saddle_points([[2, 1], [1, 2]]), set())
 
     def test_mult_saddle(self):
         inp = [[5, 3, 5, 4], [6, 4, 7, 3], [5, 1, 5, 3]]
         ans = set([(0, 0), (0, 2), (2, 0), (2, 2)])
-        self.assertEqual(ans, saddle_points(inp))
+        self.assertEqual(saddle_points(inp), ans)
 
     def test_empty_matrix(self):
-        self.assertEqual(set(), saddle_points([]))
+        self.assertEqual(saddle_points([]), set())
 
     def test_irregular_matrix(self):
         inp = [[3, 2, 1], [0, 1], [2, 1, 0]]