trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/say/say_test.py

@@ -4,51 +4,49 @@ from say import say
 
 
 class SayTest(unittest.TestCase):
-
     def test_one(self):
-        self.assertEqual("one", say(1))
+        self.assertEqual(say(1), "one")
 
     def test_fourteen(self):
-        self.assertEqual("fourteen", say(14))
+        self.assertEqual(say(14), "fourteen")
 
     def test_twenty(self):
-        self.assertEqual("twenty", say(20))
+        self.assertEqual(say(20), "twenty")
 
     def test_twenty_two(self):
-        self.assertEqual("twenty-two", say(22))
+        self.assertEqual(say(22), "twenty-two")
 
     def test_one_hundred(self):
-        self.assertEqual("one hundred", say(100))
+        self.assertEqual(say(100), "one hundred")
 
     def test_one_hundred_twenty(self):
-        self.assertEqual("one hundred and twenty", say(120))
+        self.assertEqual(say(120), "one hundred and twenty")
 
     def test_one_hundred_twenty_three(self):
-        self.assertEqual("one hundred and twenty-three", say(123))
+        self.assertEqual(say(123), "one hundred and twenty-three")
 
     def test_one_thousand(self):
-        self.assertEqual("one thousand", say(1000))
+        self.assertEqual(say(1000), "one thousand")
 
     def test_one_thousand_two_hundred_thirty_four(self):
-        self.assertEqual("one thousand two hundred and thirty-four",
-                         say(1234))
+        self.assertEqual(say(1234), "one thousand two hundred and thirty-four")
 
     def test_eight_hundred_and_ten_thousand(self):
-        self.assertEqual("eight hundred and ten thousand", say(810000))
+        self.assertEqual(say(810000), "eight hundred and ten thousand")
 
     def test_one_million(self):
-        self.assertEqual("one million", say(1e6))
+        self.assertEqual(say(1e6), "one million")
 
     def test_one_million_two(self):
-        self.assertEqual("one million and two", say(1000002))
+        self.assertEqual(say(1000002), "one million and two")
 
     def test_1002345(self):
         self.assertEqual(
-            "one million two thousand three hundred and forty-five",
-            say(1002345))
+            say(1002345),
+            "one million two thousand three hundred and forty-five")
 
     def test_one_billion(self):
-        self.assertEqual("one billion", say(1e9))
+        self.assertEqual(say(1e9), "one billion")
 
     def test_number_to_large(self):
         with self.assertRaises(AttributeError):
@@ -59,14 +57,14 @@ class SayTest(unittest.TestCase):
             say(-42)
 
     def test_zero(self):
-        self.assertEqual("zero", say(0))
+        self.assertEqual(say(0), "zero")
 
     def test_987654321123(self):
-        self.assertEqual("nine hundred and eighty-seven billion " +
-                         "six hundred and fifty-four million " +
-                         "three hundred and twenty-one thousand " +
-                         "one hundred and twenty-three",
-                         say(987654321123))
+        self.assertEqual(
+            say(987654321123), ("nine hundred and eighty-seven billion "
+                                "six hundred and fifty-four million "
+                                "three hundred and twenty-one thousand "
+                                "one hundred and twenty-three"))
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/scrabble-score/scrabble_score_test.py

@@ -5,25 +5,25 @@ from scrabble_score import score
 
 class WordTest(unittest.TestCase):
     def test_invalid_word_scores_zero(self):
-        self.assertEqual(0, score(''))
-        self.assertEqual(0, score(' \t\n'))
-        self.assertEqual(0, score('hous3'))
-        self.assertEqual(0, score('wo rd'))
+        self.assertEqual(score(''), 0)
+        self.assertEqual(score(' \t\n'), 0)
+        self.assertEqual(score('hous3'), 0)
+        self.assertEqual(score('wo rd'), 0)
 
     def test_scores_very_short_word(self):
-        self.assertEqual(1, score('a'))
+        self.assertEqual(score('a'), 1)
 
     def test_scores_other_very_short_word(self):
-        self.assertEqual(4, score('f'))
+        self.assertEqual(score('f'), 4)
 
     def test_simple_word_scores_the_number_of_letters(self):
-        self.assertEqual(6, score("street"))
+        self.assertEqual(score("street"), 6)
 
     def test_complicated_word_scores_more(self):
-        self.assertEqual(22, score("quirky"))
+        self.assertEqual(score("quirky"), 22)
 
     def test_scores_are_case_insensitive(self):
-        self.assertEqual(41, score("OxyphenButazone"))
+        self.assertEqual(score("OxyphenButazone"), 41)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/secret-handshake/secret_handshake_test.py

@@ -5,44 +5,45 @@ from secret_handshake import handshake, code
 
 class HandshakeTest(unittest.TestCase):
     def test_shake_int(self):
-        self.assertEqual(['wink', 'jump'], handshake(9))
+        self.assertEqual(handshake(9), ['wink', 'jump'])
 
     def test_shake_bin1(self):
-        self.assertEqual(['close your eyes', 'double blink'], handshake('10110'))
+        self.assertEqual(
+            handshake('10110'), ['close your eyes', 'double blink'])
 
     def test_shake_bin2(self):
-        self.assertEqual(['wink', 'close your eyes'], handshake('101'))
+        self.assertEqual(handshake('101'), ['wink', 'close your eyes'])
 
     def test_shake_negative_int(self):
-        self.assertEqual([], handshake(-9))
+        self.assertEqual(handshake(-9), [])
 
     def test_shake_bin_invalid(self):
-        self.assertEqual([], handshake('121'))
+        self.assertEqual(handshake('121'), [])
 
     def test_unknown_action(self):
-        self.assertEqual('0', code(['wink', 'sneeze']))
+        self.assertEqual(code(['wink', 'sneeze']), '0')
 
     def test_code1(self):
-        self.assertEqual('1100', code(['close your eyes', 'jump']))
+        self.assertEqual(code(['close your eyes', 'jump']), '1100')
 
     def test_code2(self):
-        self.assertEqual('11', code(['wink', 'double blink']))
+        self.assertEqual(code(['wink', 'double blink']), '11')
 
     def test_code3(self):
-        self.assertEqual('11010', code(['jump', 'double blink']))
+        self.assertEqual(code(['jump', 'double blink']), '11010')
 
     def test_composition1(self):
-        self.assertEqual('11011', code(handshake(27)))
+        self.assertEqual(code(handshake(27)), '11011')
 
     def test_composition2(self):
-        self.assertEqual('1', code(handshake(1)))
+        self.assertEqual(code(handshake(1)), '1')
 
     def test_composition3(self):
-        self.assertEqual('111', code(handshake('111')))
+        self.assertEqual(code(handshake('111')), '111')
 
     def test_composition4(self):
         inp = ['wink', 'double blink', 'jump']
-        self.assertEqual(inp, handshake(code(inp)))
+        self.assertEqual(handshake(code(inp)), inp)
 
 
 if __name__ == '__main__':

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

@@ -1,6 +1,6 @@
 def slices(series, length):
     numbers = [int(digit) for digit in series]
     if not 1 <= length <= len(numbers):
-        raise ValueError("Invalid slice length for this series: " + str(length))
-    return [numbers[i:i + length]
-            for i in range(len(numbers) - length + 1)]
+        raise ValueError("Invalid slice length for this series: " + str(
+            length))
+    return [numbers[i:i + length] for i in range(len(numbers) - length + 1)]

data/tracks/python/exercises/series/series_test.py

@@ -11,26 +11,30 @@ from series import slices
 
 class SeriesTest(unittest.TestCase):
     def test_slices_of_one(self):
-        self.assertEqual([[0], [1], [2], [3], [4]],
-                         slices("01234", 1))
+        self.assertEqual(
+            slices("01234", 1),
+            [[0], [1], [2], [3], [4]], )
 
     def test_slices_of_two(self):
-        self.assertEqual([[9, 7], [7, 8], [8, 6], [6, 7],
-                          [7, 5], [5, 6], [6, 4]],
-                         slices("97867564", 2))
+        self.assertEqual(
+            slices("97867564", 2),
+            [[9, 7], [7, 8], [8, 6], [6, 7], [7, 5], [5, 6], [6, 4]], )
 
     def test_slices_of_three(self):
-        self.assertEqual([[9, 7, 8], [7, 8, 6], [8, 6, 7],
-                          [6, 7, 5], [7, 5, 6], [5, 6, 4]],
-                         slices("97867564", 3))
+        self.assertEqual(
+            slices("97867564", 3),
+            [[9, 7, 8], [7, 8, 6], [8, 6, 7], [6, 7, 5], [7, 5, 6], [5, 6, 4]],
+        )
 
     def test_slices_of_four(self):
-        self.assertEqual([[0, 1, 2, 3], [1, 2, 3, 4]],
-                         slices("01234", 4))
+        self.assertEqual(
+            slices("01234", 4),
+            [[0, 1, 2, 3], [1, 2, 3, 4]], )
 
     def test_slices_of_five(self):
-        self.assertEqual([[0, 1, 2, 3, 4]],
-                         slices("01234", 5))
+        self.assertEqual(
+            slices("01234", 5),
+            [[0, 1, 2, 3, 4]], )
 
     def test_overly_long_slice(self):
         with self.assertRaises(ValueError):

data/tracks/python/exercises/simple-cipher/simple_cipher_test.py

@@ -4,64 +4,66 @@ from simple_cipher import Caesar, Cipher
 
 
 class CipherTest(unittest.TestCase):
-
     def test_caesar_encode1(self):
-        self.assertEqual('lwlvdzhvrphsurjudpplqjlqsbwkrq',
-                         Caesar().encode('itisawesomeprogramminginpython'))
+        self.assertEqual(Caesar().encode('itisawesomeprogramminginpython'),
+                         'lwlvdzhvrphsurjudpplqjlqsbwkrq')
 
     def test_caesar_encode2(self):
-        self.assertEqual('yhqlylglylfl', Caesar().encode('venividivici'))
+        self.assertEqual(Caesar().encode('venividivici'), 'yhqlylglylfl')
 
     def test_caesar_encode3(self):
-        self.assertEqual('wzdvwkhqljkwehiruhfkulvwpdv',
-                         Caesar().encode('\'Twas the night before Christmas'))
+        self.assertEqual(Caesar().encode('\'Twas the night before Christmas'),
+                         'wzdvwkhqljkwehiruhfkulvwpdv')
 
     def test_caesar_encode_with_numbers(self):
-        self.assertEqual('jr', Caesar().encode('1, 2, 3, Go!'))
+        self.assertEqual(Caesar().encode('1, 2, 3, Go!'), 'jr')
 
     def test_caesar_decode(self):
-        self.assertEqual('venividivici', Caesar().decode('yhqlylglylfl'))
+        self.assertEqual(Caesar().decode('yhqlylglylfl'), 'venividivici')
 
     def test_cipher_encode1(self):
         c = Cipher('a')
-        self.assertEqual('itisawesomeprogramminginpython',
-                         c.encode('itisawesomeprogramminginpython'))
+        self.assertEqual(
+            c.encode('itisawesomeprogramminginpython'),
+            'itisawesomeprogramminginpython')
 
     def test_cipher_encode2(self):
         c = Cipher('aaaaaaaaaaaaaaaaaaaaaa')
-        self.assertEqual('itisawesomeprogramminginpython',
-                         c.encode('itisawesomeprogramminginpython'))
+        self.assertEqual(
+            c.encode('itisawesomeprogramminginpython'),
+            'itisawesomeprogramminginpython')
 
     def test_cipher_encode3(self):
         c = Cipher('dddddddddddddddddddddd')
-        self.assertEqual('yhqlylglylfl', c.encode('venividivici'))
+        self.assertEqual(c.encode('venividivici'), 'yhqlylglylfl')
 
     def test_cipher_encode4(self):
         key = ('duxrceqyaimciuucnelkeoxjhdyduucpmrxmaivacmybmsdrzwqxvbxsy'
                'gzsabdjmdjabeorttiwinfrpmpogvabiofqexnohrqu')
         c = Cipher(key)
-        self.assertEqual('gccwkixcltycv', c.encode('diffiehellman'))
+        self.assertEqual(c.encode('diffiehellman'), 'gccwkixcltycv')
 
     def test_cipher_encode_short_key(self):
         c = Cipher('abcd')
-        self.assertEqual('abcdabcd', c.encode('aaaaaaaa'))
+        self.assertEqual(c.encode('aaaaaaaa'), 'abcdabcd')
 
     def test_cipher_compositiion1(self):
         key = ('duxrceqyaimciuucnelkeoxjhdyduucpmrxmaivacmybmsdrzwqxvbxsy'
                'gzsabdjmdjabeorttiwinfrpmpogvabiofqexnohrqu')
         plaintext = 'adaywithoutlaughterisadaywasted'
         c = Cipher(key)
-        self.assertEqual(plaintext, c.decode(c.encode(plaintext)))
+        self.assertEqual(c.decode(c.encode(plaintext)), plaintext)
 
     def test_cipher_compositiion2(self):
         plaintext = 'adaywithoutlaughterisadaywasted'
         c = Cipher()
-        self.assertEqual(plaintext, c.decode(c.encode(plaintext)))
+        self.assertEqual(c.decode(c.encode(plaintext)), plaintext)
 
     def test_cipher_random_key(self):
         c = Cipher()
-        self.assertTrue(len(c.key) >= 100,
-                        'A random key must be generated when no key is given!')
+        self.assertTrue(
+            len(c.key) >= 100,
+            'A random key must be generated when no key is given!')
         self.assertTrue(c.key.islower() and c.key.isalpha(),
                         'All items in the key must be chars and lowercase!')
 

data/tracks/python/exercises/space-age/space_age_test.py

@@ -6,46 +6,46 @@ from space_age import SpaceAge
 class SpaceAgeTest(unittest.TestCase):
     def test_age_in_seconds(self):
         age = SpaceAge(1e6)
-        self.assertEqual(1e6, age.seconds)
+        self.assertEqual(age.seconds, 1e6)
 
     def test_age_in_earth_years(self):
         age = SpaceAge(1e9)
-        self.assertEqual(31.69, age.on_earth())
+        self.assertEqual(age.on_earth(), 31.69)
 
     def test_age_in_mercury_years(self):
         age = SpaceAge(2134835688)
-        self.assertEqual(67.65, age.on_earth())
-        self.assertEqual(280.88, age.on_mercury())
+        self.assertEqual(age.on_earth(), 67.65)
+        self.assertEqual(age.on_mercury(), 280.88)
 
     def test_age_in_venus_years(self):
         age = SpaceAge(189839836)
-        self.assertEqual(6.02, age.on_earth())
-        self.assertEqual(9.78, age.on_venus())
+        self.assertEqual(age.on_earth(), 6.02)
+        self.assertEqual(age.on_venus(), 9.78)
 
     def test_age_on_mars(self):
         age = SpaceAge(2329871239)
-        self.assertEqual(73.83, age.on_earth())
-        self.assertEqual(39.25, age.on_mars())
+        self.assertEqual(age.on_earth(), 73.83)
+        self.assertEqual(age.on_mars(), 39.25)
 
     def test_age_on_jupiter(self):
         age = SpaceAge(901876382)
-        self.assertEqual(28.58, age.on_earth())
-        self.assertEqual(2.41, age.on_jupiter())
+        self.assertEqual(age.on_earth(), 28.58)
+        self.assertEqual(age.on_jupiter(), 2.41)
 
     def test_age_on_saturn(self):
         age = SpaceAge(3e9)
-        self.assertEqual(95.06, age.on_earth())
-        self.assertEqual(3.23, age.on_saturn())
+        self.assertEqual(age.on_earth(), 95.06)
+        self.assertEqual(age.on_saturn(), 3.23)
 
     def test_age_on_uranus(self):
         age = SpaceAge(3210123456)
-        self.assertEqual(101.72, age.on_earth())
-        self.assertEqual(1.21, age.on_uranus())
+        self.assertEqual(age.on_earth(), 101.72)
+        self.assertEqual(age.on_uranus(), 1.21)
 
     def test_age_on_neptune(self):
         age = SpaceAge(8210123456)
-        self.assertEqual(260.16, age.on_earth())
-        self.assertEqual(1.58, age.on_neptune())
+        self.assertEqual(age.on_earth(), 260.16)
+        self.assertEqual(age.on_neptune(), 1.58)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/strain/strain_test.py

@@ -5,40 +5,41 @@ from strain import keep, discard
 
 class StrainTest(unittest.TestCase):
     def test_empty_sequence(self):
-        self.assertEqual([], keep([], lambda x: x % 2 == 0))
+        self.assertEqual(keep([], lambda x: x % 2 == 0), [])
 
     def test_empty_keep(self):
         inp = [2, 4, 6, 8, 10]
         out = []
-        self.assertEqual(out, keep(inp, lambda x: x % 2 == 1))
+        self.assertEqual(keep(inp, lambda x: x % 2 == 1), out)
 
     def test_empty_discard(self):
         inp = [2, 4, 6, 8, 10]
         out = []
-        self.assertEqual(out, discard(inp, lambda x: x % 2 == 0))
+        self.assertEqual(discard(inp, lambda x: x % 2 == 0), out)
 
     def test_keep_everything(self):
         inp = [2, 4, 6, 8, 10]
-        self.assertEqual(inp, keep(inp, lambda x: x % 2 == 0))
+        self.assertEqual(keep(inp, lambda x: x % 2 == 0), inp)
 
     def test_discard_endswith(self):
         inp = ['dough', 'cash', 'plough', 'though', 'through', 'enough']
         out = ['cash']
-        self.assertEqual(out, discard(inp, lambda x: str.endswith(x, 'ough')))
+        self.assertEqual(discard(inp, lambda x: str.endswith(x, 'ough')), out)
 
     def test_keep_z(self):
         inp = ['zebra', 'arizona', 'apple', 'google', 'mozilla']
         out = ['zebra', 'arizona', 'mozilla']
-        self.assertEqual(out, keep(inp, lambda x: 'z' in x))
+        self.assertEqual(keep(inp, lambda x: 'z' in x), out)
 
     def test_keep_discard(self):
         inp = ['1,2,3', 'one', 'almost!', 'love']
-        self.assertEqual([], discard(keep(inp, str.isalpha), str.isalpha))
+        self.assertEqual(discard(keep(inp, str.isalpha), str.isalpha), [])
 
     def test_keep_plus_discard(self):
         inp = ['1,2,3', 'one', 'almost!', 'love']
         out = ['one', 'love', '1,2,3', 'almost!']
-        self.assertEqual(out, keep(inp, str.isalpha) + discard(inp, str.isalpha))
+        self.assertEqual(
+            keep(inp, str.isalpha) + discard(inp, str.isalpha), out)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/sublist/sublist_test.py

@@ -5,82 +5,81 @@ from sublist import check_lists, SUBLIST, SUPERLIST, EQUAL, UNEQUAL
 
 class SublistTest(unittest.TestCase):
     def test_unique_return_vals(self):
-        self.assertEqual(4, len(set([SUBLIST, SUPERLIST, EQUAL, UNEQUAL])))
+        self.assertEqual(len(set([SUBLIST, SUPERLIST, EQUAL, UNEQUAL])), 4)
 
     def test_empty_lists(self):
-        self.assertEqual(EQUAL, check_lists([], []))
+        self.assertEqual(check_lists([], []), EQUAL)
 
     def test_empty_list_within(self):
-        self.assertEqual(SUBLIST, check_lists([], [1, 2, 3]))
+        self.assertEqual(check_lists([], [1, 2, 3]), SUBLIST)
 
     def test_within_empty_list(self):
-        self.assertEqual(SUPERLIST, check_lists([1], []))
+        self.assertEqual(check_lists([1], []), SUPERLIST)
 
     def test_equal_lists(self):
         l1 = [0, 1, 2]
         l2 = [0, 1, 2]
-        self.assertEqual(EQUAL, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), EQUAL)
 
     def test_different_lists(self):
         l1 = list(range(1000000))
         l2 = list(range(1, 1000001))
-        self.assertEqual(UNEQUAL, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), UNEQUAL)
 
     def test_false_start(self):
         l1 = [1, 2, 5]
         l2 = [0, 1, 2, 3, 1, 2, 5, 6]
-        self.assertEqual(SUBLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUBLIST)
 
     def test_consecutive(self):
         l1 = [1, 1, 2]
         l2 = [0, 1, 1, 1, 2, 1, 2]
-        self.assertEqual(SUBLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUBLIST)
 
     def test_sublist_at_start(self):
         l1 = [0, 1, 2]
         l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(SUBLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUBLIST)
 
     def test_sublist_in_middle(self):
         l1 = [2, 3, 4]
         l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(SUBLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUBLIST)
 
     def test_sublist_at_end(self):
         l1 = [3, 4, 5]
         l2 = [0, 1, 2, 3, 4, 5]
-        self.assertEqual(SUBLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUBLIST)
 
     def test_at_start_of_superlist(self):
         l1 = [0, 1, 2, 3, 4, 5]
         l2 = [0, 1, 2]
-        self.assertEqual(SUPERLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUPERLIST)
 
     def test_in_middle_of_superlist(self):
         l1 = [0, 1, 2, 3, 4, 5]
         l2 = [2, 3]
-        self.assertEqual(SUPERLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUPERLIST)
 
     def test_at_end_of_superlist(self):
         l1 = [0, 1, 2, 3, 4, 5]
         l2 = [3, 4, 5]
-        self.assertEqual(SUPERLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUPERLIST)
 
     def test_large_lists(self):
         l1 = list(range(1000)) * 1000 + list(range(1000, 1100))
         l2 = list(range(900, 1050))
-        self.assertEqual(SUPERLIST, check_lists(l1, l2))
+        self.assertEqual(check_lists(l1, l2), SUPERLIST)
 
     def test_spread_sublist(self):
         multiples_of_3 = list(range(3, 200, 3))
         multiples_of_15 = list(range(15, 200, 15))
-        self.assertEqual(UNEQUAL,
-                         check_lists(multiples_of_15, multiples_of_3))
+        self.assertEqual(check_lists(multiples_of_15, multiples_of_3), UNEQUAL)
 
     def test_avoid_sets(self):
-        self.assertEqual(UNEQUAL, check_lists([1, 3], [1, 2, 3]))
-        self.assertEqual(UNEQUAL, check_lists([1, 2, 3], [1, 3]))
-        self.assertEqual(UNEQUAL, check_lists([1, 2, 3], [3, 2, 1]))
+        self.assertEqual(check_lists([1, 3], [1, 2, 3]), UNEQUAL)
+        self.assertEqual(check_lists([1, 2, 3], [1, 3]), UNEQUAL)
+        self.assertEqual(check_lists([1, 2, 3], [3, 2, 1]), UNEQUAL)
 
 
 if __name__ == '__main__':