trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/phone-number/phone_number_test.py

@@ -6,35 +6,35 @@ from phone_number import Phone
 class PhoneTest(unittest.TestCase):
     def test_cleans_number(self):
         number = Phone("(123) 456-7890").number
-        self.assertEqual("1234567890", number)
+        self.assertEqual(number, "1234567890")
 
     def test_cleans_number_with_dots(self):
         number = Phone("123.456.7890").number
-        self.assertEqual("1234567890", number)
+        self.assertEqual(number, "1234567890")
 
     def test_valid_when_11_digits_and_first_is_1(self):
         number = Phone("11234567890").number
-        self.assertEqual("1234567890", number)
+        self.assertEqual(number, "1234567890")
 
     def test_invalid_when_11_digits(self):
         number = Phone("21234567890").number
-        self.assertEqual("0000000000", number)
+        self.assertEqual(number, "0000000000")
 
     def test_invalid_when_9_digits(self):
         number = Phone("123456789").number
-        self.assertEqual("0000000000", number)
+        self.assertEqual(number, "0000000000")
 
     def test_area_code(self):
         number = Phone("1234567890")
-        self.assertEqual("123", number.area_code())
+        self.assertEqual(number.area_code(), "123")
 
     def test_pretty_print(self):
         number = Phone("1234567890")
-        self.assertEqual("(123) 456-7890", number.pretty())
+        self.assertEqual(number.pretty(), "(123) 456-7890")
 
     def test_pretty_print_with_full_us_phone_number(self):
         number = Phone("11234567890")
-        self.assertEqual("(123) 456-7890", number.pretty())
+        self.assertEqual(number.pretty(), "(123) 456-7890")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/pig-latin/pig_latin_test.py

@@ -5,49 +5,49 @@ from pig_latin import translate
 
 class PigLatinTests(unittest.TestCase):
     def test_word_beginning_with_a(self):
-        self.assertEqual("appleay", translate("apple"))
+        self.assertEqual(translate("apple"), "appleay")
 
     def test_word_beginning_with_e(self):
-        self.assertEqual("earay", translate("ear"))
+        self.assertEqual(translate("ear"), "earay")
 
     def test_word_beginning_with_p(self):
-        self.assertEqual("igpay", translate("pig"))
+        self.assertEqual(translate("pig"), "igpay")
 
     def test_word_beginning_with_k(self):
-        self.assertEqual("oalakay", translate("koala"))
+        self.assertEqual(translate("koala"), "oalakay")
 
     def test_word_beginning_with_ch(self):
-        self.assertEqual("airchay", translate("chair"))
+        self.assertEqual(translate("chair"), "airchay")
 
     def test_word_beginning_with_qu(self):
-        self.assertEqual("eenquay", translate("queen"))
+        self.assertEqual(translate("queen"), "eenquay")
 
     def test_word_beginning_with_squ(self):
-        self.assertEqual("aresquay", translate("square"))
+        self.assertEqual(translate("square"), "aresquay")
 
     def test_word_beginning_with_th(self):
-        self.assertEqual("erapythay", translate("therapy"))
+        self.assertEqual(translate("therapy"), "erapythay")
 
     def test_word_beginning_with_thr(self):
-        self.assertEqual("ushthray", translate("thrush"))
+        self.assertEqual(translate("thrush"), "ushthray")
 
     def test_word_beginning_with_sch(self):
-        self.assertEqual("oolschay", translate("school"))
+        self.assertEqual(translate("school"), "oolschay")
 
     def test_translates_phrase(self):
-        self.assertEqual("ickquay astfay unray", translate("quick fast run"))
+        self.assertEqual(translate("quick fast run"), "ickquay astfay unray")
 
     def test_word_beginning_with_ye(self):
-        self.assertEqual("ellowyay", translate("yellow"))
+        self.assertEqual(translate("yellow"), "ellowyay")
 
     def test_word_beginning_with_yt(self):
-        self.assertEqual("yttriaay", translate("yttria"))
+        self.assertEqual(translate("yttria"), "yttriaay")
 
     def test_word_beginning_with_xe(self):
-        self.assertEqual("enonxay", translate("xenon"))
+        self.assertEqual(translate("xenon"), "enonxay")
 
     def test_word_beginning_with_xr(self):
-        self.assertEqual("xrayay", translate("xray"))
+        self.assertEqual(translate("xray"), "xrayay")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/point-mutations/point_mutations_test.py

@@ -5,31 +5,31 @@ from point_mutations import hamming_distance
 
 class DNATest(unittest.TestCase):
     def test_no_difference_between_empty_strands(self):
-        self.assertEqual(0, hamming_distance('', ''))
+        self.assertEqual(hamming_distance('', ''), 0)
 
     def test_no_difference_between_identical_strands(self):
-        self.assertEqual(0, hamming_distance('GGACTGA', 'GGACTGA'))
+        self.assertEqual(hamming_distance('GGACTGA', 'GGACTGA'), 0)
 
     def test_complete_hamming_distance_in_small_strand(self):
-        self.assertEqual(3, hamming_distance('ACT', 'GGA'))
+        self.assertEqual(hamming_distance('ACT', 'GGA'), 3)
 
     def test_hamming_distance_in_off_by_one_strand(self):
-        self.assertEqual(19,
-                         hamming_distance('GGACGGATTCTGACCTGGACTAATTTTGGGG',
-                                          'AGGACGGATTCTGACCTGGACTAATTTTGGGG'))
+        self.assertEqual(
+            hamming_distance('GGACGGATTCTGACCTGGACTAATTTTGGGG',
+                             'AGGACGGATTCTGACCTGGACTAATTTTGGGG'), 19)
 
     def test_small_hamming_distance_in_middle_somewhere(self):
-        self.assertEqual(1, hamming_distance('GGACG', 'GGTCG'))
+        self.assertEqual(hamming_distance('GGACG', 'GGTCG'), 1)
 
     def test_larger_distance(self):
-        self.assertEqual(2, hamming_distance('ACCAGGG', 'ACTATGG'))
+        self.assertEqual(hamming_distance('ACCAGGG', 'ACTATGG'), 2)
 
     def test_ignores_extra_length_on_other_strand_when_longer(self):
-        self.assertEqual(3, hamming_distance('AAACTAGGGG', 'AGGCTAGCGGTAGGAC'))
+        self.assertEqual(hamming_distance('AAACTAGGGG', 'AGGCTAGCGGTAGGAC'), 3)
 
     def test_ignores_extra_length_on_original_strand_when_longer(self):
-        self.assertEqual(5, hamming_distance('GACTACGGACAGGGTAGGGAAT',
-                                             'GACATCGCACACC'))
+        self.assertEqual(
+            hamming_distance('GACTACGGACAGGGTAGGGAAT', 'GACATCGCACACC'), 5)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/poker/poker_test.py

@@ -6,112 +6,114 @@ from poker import poker
 class PokerTest(unittest.TestCase):
     def test_one_hand(self):
         hand = '4S 5S 7H 8D JC'.split()
-        self.assertEqual([hand], poker([hand]))
+        self.assertEqual(poker([hand]), [hand])
 
     def test_nothing_vs_one_pair(self):
         nothing = '4S 5H 6S 8D JH'.split()
         pairOf4 = '2S 4H 6S 4D JH'.split()
-        self.assertEqual([pairOf4], poker([nothing, pairOf4]))
+        self.assertEqual(poker([nothing, pairOf4]), [pairOf4])
 
     def test_two_pair(self):
         pairOf2 = '4S 2H 6S 2D JH'.split()
         pairOf4 = '2S 4H 6S 4D JH'.split()
-        self.assertEqual([pairOf4], poker([pairOf2, pairOf4]))
+        self.assertEqual(poker([pairOf2, pairOf4]), [pairOf4])
 
     def test_one_pair_vs_double_pair(self):
         pairOf8 = '2S 8H 6S 8D JH'.split()
         doublePair = '4S 5H 4S 8D 5H'.split()
-        self.assertEqual([doublePair], poker([pairOf8, doublePair]))
+        self.assertEqual(poker([pairOf8, doublePair]), [doublePair])
 
     def test_two_double_pair(self):
         doublePair2and8 = '2S 8H 2S 8D JH'.split()
         doublePair4and5 = '4S 5H 4S 8D 5H'.split()
-        self.assertEqual([doublePair2and8],
-                         poker([doublePair2and8, doublePair4and5]))
+        self.assertEqual(
+            poker([doublePair2and8, doublePair4and5]), [doublePair2and8])
 
     def test_two_double_pair_lower(self):
         doublePair2and8 = '2S 8H 2S 8C JH'.split()
         doublePair3and8 = '4S 3H 8S 8D 3H'.split()
-        self.assertEqual([doublePair3and8],
-                         poker([doublePair2and8, doublePair3and8]))
+        self.assertEqual(
+            poker([doublePair2and8, doublePair3and8]), [doublePair3and8])
 
     def test_two_double_pair_and_high(self):
         doublePair2and8 = '2S 8H 2C 8C 3H'.split()
         doublePair2and8high = '2D 2H 8S 8D AH'.split()
-        self.assertEqual([doublePair2and8high],
-                         poker([doublePair2and8high, doublePair2and8]))
+        self.assertEqual(
+            poker([doublePair2and8high, doublePair2and8]),
+            [doublePair2and8high])
 
     def test_double_pair_vs_three(self):
         doublePair2and8 = '2S 8H 2S 8D JH'.split()
         threeOf4 = '4S 5H 4S 8D 4H'.split()
-        self.assertEqual([threeOf4], poker([doublePair2and8, threeOf4]))
+        self.assertEqual(poker([doublePair2and8, threeOf4]), [threeOf4])
 
     def test_two_three(self):
         threeOf2 = '2S 2H 2S 8D JH'.split()
         threeOf1 = '4S AH AS 8D AH'.split()
-        self.assertEqual([threeOf1], poker([threeOf2, threeOf1]))
+        self.assertEqual(poker([threeOf2, threeOf1]), [threeOf1])
 
     def test_three_vs_straight(self):
         threeOf4 = '4S 5H 4S 8D 4H'.split()
         straight = '3S 4H 2S 6D 5H'.split()
-        self.assertEqual([straight], poker([threeOf4, straight]))
+        self.assertEqual(poker([threeOf4, straight]), [straight])
 
     def test_two_straights(self):
         straightTo8 = '4S 6H 7S 8D 5H'.split()
         straightTo9 = '5S 7H 8S 9D 6H'.split()
-        self.assertEqual([straightTo9], poker([straightTo8, straightTo9]))
+        self.assertEqual(poker([straightTo8, straightTo9]), [straightTo9])
         straightTo1 = 'AS QH KS TD JH'.split()
         straightTo5 = '4S AH 3S 2D 5H'.split()
-        self.assertEqual([straightTo1], poker([straightTo1, straightTo5]))
+        self.assertEqual(poker([straightTo1, straightTo5]), [straightTo1])
 
     def test_straight_vs_flush(self):
         straightTo8 = '4S 6H 7S 8D 5H'.split()
         flushTo7 = '2S 4S 5S 6S 7S'.split()
-        self.assertEqual([flushTo7], poker([straightTo8, flushTo7]))
+        self.assertEqual(poker([straightTo8, flushTo7]), [flushTo7])
 
     def test_two_flushes(self):
         flushTo8 = '3H 6H 7H 8H 5H'.split()
         flushTo7 = '2S 4S 5S 6S 7S'.split()
-        self.assertEqual([flushTo8], poker([flushTo8, flushTo7]))
+        self.assertEqual(poker([flushTo8, flushTo7]), [flushTo8])
 
     def test_flush_vs_full(self):
         flushTo8 = '3H 6H 7H 8H 5H'.split()
         full = '4S 5H 4S 5D 4H'.split()
-        self.assertEqual([full], poker([full, flushTo8]))
+        self.assertEqual(poker([full, flushTo8]), [full])
 
     def test_two_fulls(self):
         fullOf4by9 = '4H 4S 4D 9S 9D'.split()
         fullOf5by8 = '5H 5S 5D 8S 8D'.split()
-        self.assertEqual([fullOf5by8], poker([fullOf4by9, fullOf5by8]))
+        self.assertEqual(poker([fullOf4by9, fullOf5by8]), [fullOf5by8])
 
     def test_full_vs_square(self):
         full = '4S 5H 4S 5D 4H'.split()
         squareOf3 = '3S 3H 2S 3D 3H'.split()
-        self.assertEqual([squareOf3], poker([full, squareOf3]))
+        self.assertEqual(poker([full, squareOf3]), [squareOf3])
 
     def test_two_square(self):
         squareOf2 = '2S 2H 2S 8D 2H'.split()
         squareOf5 = '4S 5H 5S 5D 5H'.split()
-        self.assertEqual([squareOf5], poker([squareOf2, squareOf5]))
+        self.assertEqual(poker([squareOf2, squareOf5]), [squareOf5])
 
     def test_square_vs_straight_flush(self):
         squareOf5 = '4S 5H 5S 5D 5H'.split()
         straightFlushTo9 = '5S 7S 8S 9S 6S'.split()
-        self.assertEqual([straightFlushTo9],
-                         poker([squareOf5, straightFlushTo9]))
+        self.assertEqual(
+            poker([squareOf5, straightFlushTo9]), [straightFlushTo9])
 
     def test_two_straight_flushes(self):
         straightFlushTo8 = '4H 6H 7H 8H 5H'.split()
         straightFlushTo9 = '5S 7S 8S 9S 6S'.split()
-        self.assertEqual([straightFlushTo9],
-                         poker([straightFlushTo8, straightFlushTo9]))
+        self.assertEqual(
+            poker([straightFlushTo8, straightFlushTo9]), [straightFlushTo9])
 
     def test_three_hand_with_tie(self):
-        spadeStraightTo9 = "9S 8S 7S 6S 5S".split()
-        diamondStraightTo9 = "9D 8D 7D 6D 5D".split()
-        threeOf4 = "4D 4S 4H QS KS".split()
-        self.assertEqual([spadeStraightTo9, diamondStraightTo9],
-                         poker([spadeStraightTo9, diamondStraightTo9, threeOf4]))
+        spadeStraightTo9 = '9S 8S 7S 6S 5S'.split()
+        diamondStraightTo9 = '9D 8D 7D 6D 5D'.split()
+        threeOf4 = '4D 4S 4H QS KS'.split()
+        self.assertEqual(
+            poker([spadeStraightTo9, diamondStraightTo9, threeOf4]),
+            [spadeStraightTo9, diamondStraightTo9])
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/prime-factors/prime_factors_test.py

@@ -5,37 +5,37 @@ from prime_factors import prime_factors
 
 class PrimeFactorsTest(unittest.TestCase):
     def test_1(self):
-        self.assertEqual([], prime_factors(1))
+        self.assertEqual(prime_factors(1), [])
 
     def test_2(self):
-        self.assertEqual([2], prime_factors(2))
+        self.assertEqual(prime_factors(2), [2])
 
     def test_3(self):
-        self.assertEqual([3], prime_factors(3))
+        self.assertEqual(prime_factors(3), [3])
 
     def test_4(self):
-        self.assertEqual([2, 2], prime_factors(4))
+        self.assertEqual(prime_factors(4), [2, 2])
 
     def test_6(self):
-        self.assertEqual([2, 3], prime_factors(6))
+        self.assertEqual(prime_factors(6), [2, 3])
 
     def test_8(self):
-        self.assertEqual([2, 2, 2], prime_factors(8))
+        self.assertEqual(prime_factors(8), [2, 2, 2])
 
     def test_9(self):
-        self.assertEqual([3, 3], prime_factors(9))
+        self.assertEqual(prime_factors(9), [3, 3])
 
     def test_27(self):
-        self.assertEqual([3, 3, 3], prime_factors(27))
+        self.assertEqual(prime_factors(27), [3, 3, 3])
 
     def test_625(self):
-        self.assertEqual([5, 5, 5, 5], prime_factors(625))
+        self.assertEqual(prime_factors(625), [5, 5, 5, 5])
 
     def test_901255(self):
-        self.assertEqual([5, 17, 23, 461], prime_factors(901255))
+        self.assertEqual(prime_factors(901255), [5, 17, 23, 461])
 
     def test_93819012551(self):
-        self.assertEqual([11, 9539, 894119], prime_factors(93819012551))
+        self.assertEqual(prime_factors(93819012551), [11, 9539, 894119])
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/proverb/proverb_test.py

@@ -7,25 +7,25 @@ class ProverbTest(unittest.TestCase):
     def test_a_single_consequence(self):
         expected = 'For want of a nail the shoe was lost.\n'\
                    'And all for the want of a nail.'
-        self.assertEqual(expected, proverb(['nail', 'shoe']))
+        self.assertEqual(proverb(['nail', 'shoe']), expected)
 
     def test_short_list(self):
         expected = 'For want of a nail the shoe was lost.\n'\
                    'For want of a shoe the horse was lost.\n'\
                    'And all for the want of a nail.'
-        self.assertEqual(expected, proverb(['nail', 'shoe', 'horse']))
+        self.assertEqual(proverb(['nail', 'shoe', 'horse']), expected)
 
     def test_long_list(self):
         expected = 'For want of a nail the shoe was lost.\n'\
                    'For want of a shoe the horse was lost.\n'\
                    'For want of a horse the rider was lost.\n'\
                    'And all for the want of a nail.'
-        self.assertEqual(expected, proverb(['nail', 'shoe', 'horse', 'rider']))
+        self.assertEqual(proverb(['nail', 'shoe', 'horse', 'rider']), expected)
 
     def test_new_itens(self):
         expected = 'For want of a key the value was lost.\n'\
                    'And all for the want of a key.'
-        self.assertEqual(expected, proverb(['key', 'value']))
+        self.assertEqual(proverb(['key', 'value']), expected)
 
     def test_whole_proverb(self):
         expected = 'For want of a nail the shoe was lost.\n'\
@@ -35,8 +35,11 @@ class ProverbTest(unittest.TestCase):
                    'For want of a message the battle was lost.\n'\
                    'For want of a battle the kingdom was lost.\n'\
                    'And all for the want of a nail.'
-        self.assertEqual(expected, proverb(['nail', 'shoe', 'horse', 'rider',
-                                            'message', 'battle', 'kingdom']))
+        self.assertEqual(
+            proverb([
+                'nail', 'shoe', 'horse', 'rider', 'message', 'battle',
+                'kingdom'
+            ]), expected)
 
     def test_qualifier(self):
         expected = 'For want of a nail the shoe was lost.\n'\
@@ -46,9 +49,13 @@ class ProverbTest(unittest.TestCase):
                    'For want of a message the battle was lost.\n'\
                    'For want of a battle the kingdom was lost.\n'\
                    'And all for the want of a horseshoe nail.'
-        self.assertEqual(expected, proverb(['nail', 'shoe', 'horse', 'rider',
-                                            'message', 'battle', 'kingdom'],
-                                           qualifier='horseshoe'))
+        self.assertEqual(
+            proverb(
+                [
+                    'nail', 'shoe', 'horse', 'rider', 'message', 'battle',
+                    'kingdom'
+                ],
+                qualifier='horseshoe'), expected)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/pythagorean-triplet/pythagorean_triplet_test.py

@@ -35,47 +35,49 @@
 
 import unittest
 
-from pythagorean_triplet import (primitive_triplets, triplets_in_range,
-                                 is_triplet)
+from pythagorean_triplet import (
+    primitive_triplets,
+    triplets_in_range,
+    is_triplet
+)
 
 
 class PythagoreanTripletTest(unittest.TestCase):
-
     def test_triplet1(self):
         ans = set([(3, 4, 5)])
-        self.assertEqual(ans, primitive_triplets(4))
+        self.assertEqual(primitive_triplets(4), ans)
 
     def test_triplet2(self):
         ans = set([(13, 84, 85), (84, 187, 205), (84, 437, 445),
                    (84, 1763, 1765)])
-        self.assertEqual(ans, primitive_triplets(84))
+        self.assertEqual(primitive_triplets(84), ans)
 
     def test_triplet3(self):
         ans = set([(29, 420, 421), (341, 420, 541), (420, 851, 949),
                    (420, 1189, 1261), (420, 1739, 1789), (420, 4891, 4909),
                    (420, 11021, 11029), (420, 44099, 44101)])
-        self.assertEqual(ans, primitive_triplets(420))
+        self.assertEqual(primitive_triplets(420), ans)
 
     def test_triplet4(self):
         ans = set([(175, 288, 337), (288, 20735, 20737)])
-        self.assertEqual(ans, primitive_triplets(288))
+        self.assertEqual(primitive_triplets(288), ans)
 
     def test_range1(self):
         ans = set([(3, 4, 5), (6, 8, 10)])
-        self.assertEqual(ans, triplets_in_range(1, 10))
+        self.assertEqual(triplets_in_range(1, 10), ans)
 
     def test_range2(self):
         ans = set([(57, 76, 95), (60, 63, 87)])
-        self.assertEqual(ans, triplets_in_range(56, 95))
+        self.assertEqual(triplets_in_range(56, 95), ans)
 
     def test_is_triplet1(self):
-        self.assertEqual(True, is_triplet((29, 20, 21)))
+        self.assertTrue(is_triplet((29, 20, 21)))
 
     def test_is_triplet2(self):
-        self.assertEqual(False, is_triplet((25, 25, 1225)))
+        self.assertFalse(is_triplet((25, 25, 1225)))
 
     def test_is_triplet3(self):
-        self.assertEqual(True, is_triplet((924, 43, 925)))
+        self.assertTrue(is_triplet((924, 43, 925)))
 
     def test_odd_number(self):
         self.assertRaises(ValueError, primitive_triplets, 5)