trackler 2.0.8.27 → 2.0.8.28

data/tracks/python/exercises/binary-search/binary_search_test.py

@@ -4,26 +4,27 @@ from binary_search import binary_search
 
 
 class BinarySearchTests(unittest.TestCase):
-
     def test_finds_value_in_array_with_one_element(self):
-        self.assertEqual(0, binary_search([6], 6))
+        self.assertEqual(binary_search([6], 6), 0)
 
     def test_finds_value_in_middle_of_array(self):
-        self.assertEqual(3, binary_search([1, 3, 4, 6, 8, 9, 11], 6))
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 6), 3)
 
     def test_finds_value_at_beginning_of_array(self):
-        self.assertEqual(0, binary_search([1, 3, 4, 6, 8, 9, 11], 1))
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 1), 0)
 
     def test_finds_value_at_end_of_array(self):
-        self.assertEqual(6, binary_search([1, 3, 4, 6, 8, 9, 11], 11))
+        self.assertEqual(binary_search([1, 3, 4, 6, 8, 9, 11], 11), 6)
 
     def test_finds_value_in_array_of_odd_length(self):
-        self.assertEqual(9, binary_search(
-            [1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634], 144))
+        self.assertEqual(
+            binary_search([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634],
+                          144), 9)
 
     def test_finds_value_in_array_of_even_length(self):
-        self.assertEqual(5, binary_search(
-            [1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377], 21))
+        self.assertEqual(
+            binary_search([1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377], 21),
+            5)
 
     def test_identifies_value_missing(self):
         self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11], 7)
@@ -32,7 +33,8 @@ class BinarySearchTests(unittest.TestCase):
         self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11], 0)
 
     def test_value_larger_than_arrays_maximum(self):
-        self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11], 13)
+        self.assertRaises(ValueError, binary_search, [1, 3, 4, 6, 8, 9, 11],
+                          13)
 
     def test_empty_array(self):
         self.assertRaises(ValueError, binary_search, [], 1)

data/tracks/python/exercises/binary/binary_test.py

@@ -10,27 +10,26 @@ from binary import parse_binary
 
 
 class BinaryTests(unittest.TestCase):
-
     def test_binary_1_is_decimal_1(self):
-        self.assertEqual(1, parse_binary("1"))
+        self.assertEqual(parse_binary("1"), 1)
 
     def test_binary_10_is_decimal_2(self):
-        self.assertEqual(2, parse_binary("10"))
+        self.assertEqual(parse_binary("10"), 2)
 
     def test_binary_11_is_decimal_3(self):
-        self.assertEqual(3, parse_binary("11"))
+        self.assertEqual(parse_binary("11"), 3)
 
     def test_binary_100_is_decimal_4(self):
-        self.assertEqual(4, parse_binary("100"))
+        self.assertEqual(parse_binary("100"), 4)
 
     def test_binary_1001_is_decimal_9(self):
-        self.assertEqual(9, parse_binary("1001"))
+        self.assertEqual(parse_binary("1001"), 9)
 
     def test_binary_11010_is_decimal_26(self):
-        self.assertEqual(26, parse_binary("11010"))
+        self.assertEqual(parse_binary("11010"), 26)
 
     def test_binary_10001101000_is_decimal_1128(self):
-        self.assertEqual(1128, parse_binary("10001101000"))
+        self.assertEqual(parse_binary("10001101000"), 1128)
 
     def test_invalid_binary_text_only(self):
         self.assertRaises(ValueError, parse_binary, "carrot")

data/tracks/python/exercises/circular-buffer/circular_buffer_test.py

@@ -8,7 +8,6 @@ from circular_buffer import (
 
 
 class CircularBufferTest(unittest.TestCase):
-
     def test_read_empty_buffer(self):
         buf = CircularBuffer(1)
         with self.assertRaises(BufferEmptyException):
@@ -25,8 +24,8 @@ class CircularBufferTest(unittest.TestCase):
         buf = CircularBuffer(2)
         buf.write('1')
         buf.write('2')
-        self.assertEqual('1', buf.read())
-        self.assertEqual('2', buf.read())
+        self.assertEqual(buf.read(), '1')
+        self.assertEqual(buf.read(), '2')
         with self.assertRaises(BufferEmptyException):
             buf.read()
 
@@ -39,16 +38,16 @@ class CircularBufferTest(unittest.TestCase):
             buf.read()
         buf.write('1')
         buf.write('2')
-        self.assertEqual('1', buf.read())
+        self.assertEqual(buf.read(), '1')
         buf.write('3')
-        self.assertEqual('2', buf.read())
+        self.assertEqual(buf.read(), '2')
 
     def test_alternate_write_and_read(self):
         buf = CircularBuffer(2)
         buf.write('1')
-        self.assertEqual('1', buf.read())
+        self.assertEqual(buf.read(), '1')
         buf.write('2')
-        self.assertEqual('2', buf.read())
+        self.assertEqual(buf.read(), '2')
 
     def test_read_back_oldest_item(self):
         buf = CircularBuffer(3)
@@ -57,7 +56,7 @@ class CircularBufferTest(unittest.TestCase):
         buf.read()
         buf.write('3')
         buf.read()
-        self.assertEqual('3', buf.read())
+        self.assertEqual(buf.read(), '3')
 
     def test_write_full_buffer(self):
         buf = CircularBuffer(2)
@@ -71,8 +70,8 @@ class CircularBufferTest(unittest.TestCase):
         buf.write('1')
         buf.write('2')
         buf.overwrite('A')
-        self.assertEqual('2', buf.read())
-        self.assertEqual('A', buf.read())
+        self.assertEqual(buf.read(), '2')
+        self.assertEqual(buf.read(), 'A')
         with self.assertRaises(BufferEmptyException):
             buf.read()
 
@@ -80,8 +79,8 @@ class CircularBufferTest(unittest.TestCase):
         buf = CircularBuffer(2)
         buf.overwrite('1')
         buf.overwrite('2')
-        self.assertEqual('1', buf.read())
-        self.assertEqual('2', buf.read())
+        self.assertEqual(buf.read(), '1')
+        self.assertEqual(buf.read(), '2')
         with self.assertRaises(BufferEmptyException):
             buf.read()
 
@@ -97,11 +96,11 @@ class CircularBufferTest(unittest.TestCase):
             buf.write(c)
         buf.overwrite('A')
         buf.overwrite('B')
-        self.assertEqual('6', buf.read())
-        self.assertEqual('7', buf.read())
-        self.assertEqual('8', buf.read())
-        self.assertEqual('A', buf.read())
-        self.assertEqual('B', buf.read())
+        self.assertEqual(buf.read(), '6')
+        self.assertEqual(buf.read(), '7')
+        self.assertEqual(buf.read(), '8')
+        self.assertEqual(buf.read(), 'A')
+        self.assertEqual(buf.read(), 'B')
         with self.assertRaises(BufferEmptyException):
             buf.read()
 

data/tracks/python/exercises/clock/clock_test.py

@@ -6,110 +6,110 @@ from clock import Clock
 class ClockTest(unittest.TestCase):
     # Test creating a new clock with an initial time.
     def test_on_the_hour(self):
-        self.assertEqual('08:00', str(Clock(8, 0)))
+        self.assertEqual(str(Clock(8, 0)), '08:00')
 
     def test_past_the_hour(self):
-        self.assertEqual('11:09', str(Clock(11, 9)))
+        self.assertEqual(str(Clock(11, 9)), '11:09')
 
     def test_midnight_is_zero_hours(self):
-        self.assertEqual('00:00', str(Clock(24, 0)))
+        self.assertEqual(str(Clock(24, 0)), '00:00')
 
     def test_hour_rolls_over(self):
-        self.assertEqual('01:00', str(Clock(25, 0)))
+        self.assertEqual(str(Clock(25, 0)), '01:00')
 
     def test_hour_rolls_over_continuously(self):
-        self.assertEqual('04:00', str(Clock(100, 0)))
+        self.assertEqual(str(Clock(100, 0)), '04:00')
 
     def test_sixty_minutes_is_next_hour(self):
-        self.assertEqual('02:00', str(Clock(1, 60)))
+        self.assertEqual(str(Clock(1, 60)), '02:00')
 
     def test_minutes_roll_over(self):
-        self.assertEqual('02:40', str(Clock(0, 160)))
+        self.assertEqual(str(Clock(0, 160)), '02:40')
 
     def test_minutes_roll_over_continuously(self):
-        self.assertEqual('04:43', str(Clock(0, 1723)))
+        self.assertEqual(str(Clock(0, 1723)), '04:43')
 
     def test_hour_and_minutes_roll_over(self):
-        self.assertEqual('03:40', str(Clock(25, 160)))
+        self.assertEqual(str(Clock(25, 160)), '03:40')
 
     def test_hour_and_minutes_roll_over_continuously(self):
-        self.assertEqual('11:01', str(Clock(201, 3001)))
+        self.assertEqual(str(Clock(201, 3001)), '11:01')
 
     def test_hour_and_minutes_roll_over_to_exactly_midnight(self):
-        self.assertEqual('00:00', str(Clock(72, 8640)))
+        self.assertEqual(str(Clock(72, 8640)), '00:00')
 
     def test_negative_hour(self):
-        self.assertEqual('23:15', str(Clock(-1, 15)))
+        self.assertEqual(str(Clock(-1, 15)), '23:15')
 
     def test_negative_hour_rolls_over(self):
-        self.assertEqual('23:00', str(Clock(-25, 0)))
+        self.assertEqual(str(Clock(-25, 0)), '23:00')
 
     def test_negative_hour_rolls_over_continuously(self):
-        self.assertEqual('05:00', str(Clock(-91, 0)))
+        self.assertEqual(str(Clock(-91, 0)), '05:00')
 
     def test_negative_minutes(self):
-        self.assertEqual('00:20', str(Clock(1, -40)))
+        self.assertEqual(str(Clock(1, -40)), '00:20')
 
     def test_negative_minutes_roll_over(self):
-        self.assertEqual('22:20', str(Clock(1, -160)))
+        self.assertEqual(str(Clock(1, -160)), '22:20')
 
     def test_negative_minutes_roll_over_continuously(self):
-        self.assertEqual('16:40', str(Clock(1, -4820)))
+        self.assertEqual(str(Clock(1, -4820)), '16:40')
 
     def test_negative_hour_and_minutes_both_roll_over(self):
-        self.assertEqual('20:20', str(Clock(-25, -160)))
+        self.assertEqual(str(Clock(-25, -160)), '20:20')
 
     def test_negative_hour_and_minutes_both_roll_over_continuously(self):
-        self.assertEqual('22:10', str(Clock(-121, -5810)))
+        self.assertEqual(str(Clock(-121, -5810)), '22:10')
 
     # Test adding and subtracting minutes.
     def test_add_minutes(self):
-        self.assertEqual('10:03', str(Clock(10, 0).add(3)))
+        self.assertEqual(str(Clock(10, 0).add(3)), '10:03')
 
     def test_add_no_minutes(self):
-        self.assertEqual('06:41', str(Clock(6, 41).add(0)))
+        self.assertEqual(str(Clock(6, 41).add(0)), '06:41')
 
     def test_add_to_next_hour(self):
-        self.assertEqual('01:25', str(Clock(0, 45).add(40)))
+        self.assertEqual(str(Clock(0, 45).add(40)), '01:25')
 
     def test_add_more_than_one_hour(self):
-        self.assertEqual('11:01', str(Clock(10, 0).add(61)))
+        self.assertEqual(str(Clock(10, 0).add(61)), '11:01')
 
     def test_add_more_than_two_hours_with_carry(self):
-        self.assertEqual('03:25', str(Clock(0, 45).add(160)))
+        self.assertEqual(str(Clock(0, 45).add(160)), '03:25')
 
     def test_add_across_midnight(self):
-        self.assertEqual('00:01', str(Clock(23, 59).add(2)))
+        self.assertEqual(str(Clock(23, 59).add(2)), '00:01')
 
     def test_add_more_than_one_day(self):
-        self.assertEqual('06:32', str(Clock(5, 32).add(1500)))
+        self.assertEqual(str(Clock(5, 32).add(1500)), '06:32')
 
     def test_add_more_than_two_days(self):
-        self.assertEqual('11:21', str(Clock(1, 1).add(3500)))
+        self.assertEqual(str(Clock(1, 1).add(3500)), '11:21')
 
     def test_subtract_minutes(self):
-        self.assertEqual('10:00', str(Clock(10, 3).add(-3)))
+        self.assertEqual(str(Clock(10, 3).add(-3)), '10:00')
 
     def test_subtract_to_previous_hour(self):
-        self.assertEqual('10:00', str(Clock(10, 3).add(-3)))
+        self.assertEqual(str(Clock(10, 3).add(-3)), '10:00')
 
     def test_subtract_more_than_an_hour(self):
-        self.assertEqual('09:33', str(Clock(10, 3).add(-30)))
+        self.assertEqual(str(Clock(10, 3).add(-30)), '09:33')
 
     def test_subtract_across_midnight(self):
-        self.assertEqual('08:53', str(Clock(10, 3).add(-70)))
+        self.assertEqual(str(Clock(10, 3).add(-70)), '08:53')
 
     def test_subtract_more_than_two_hours(self):
-        self.assertEqual('21:20', str(Clock(0, 0).add(-160)))
+        self.assertEqual(str(Clock(0, 0).add(-160)), '21:20')
 
     def test_subtract_more_than_two_hours_with_borrow(self):
-        self.assertEqual('03:35', str(Clock(6, 15).add(-160)))
+        self.assertEqual(str(Clock(6, 15).add(-160)), '03:35')
 
     def test_subtract_more_than_one_day(self):
-        self.assertEqual('04:32', str(Clock(5, 32).add(-1500)))
+        self.assertEqual(str(Clock(5, 32).add(-1500)), '04:32')
 
     def test_subtract_more_than_two_days(self):
-        self.assertEqual('00:20', str(Clock(2, 20).add(-3000)))
+        self.assertEqual(str(Clock(2, 20).add(-3000)), '00:20')
 
     # Construct two separate clocks, set times, test if they are equal.
     def test_clocks_with_same_time(self):

data/tracks/python/exercises/crypto-square/crypto_square_test.py

@@ -4,26 +4,25 @@ from crypto_square import encode
 
 
 class CryptoSquareTest(unittest.TestCase):
-
     def test_empty_string(self):
-        self.assertEqual('', encode(''))
+        self.assertEqual(encode(''), '')
 
     def test_perfect_square(self):
-        self.assertEqual('ac bd', encode('ABCD'))
+        self.assertEqual(encode('ABCD'), 'ac bd')
 
     def test_small_imperfect_square(self):
-        self.assertEqual('tis hsy ie sa', encode('This is easy!'))
+        self.assertEqual(encode('This is easy!'), 'tis hsy ie sa')
 
     def test_punctuation_and_numbers(self):
         msg = "1, 2, 3, Go! Go, for God's sake!"
         ciph = '1gga 2ook 3fde gos ors'
-        self.assertEqual(ciph, encode(msg))
+        self.assertEqual(encode(msg), ciph)
 
     def test_long_string(self):
         msg = ("If man was meant to stay on the ground, god would have given "
                "us roots.")
         ciph = "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau"
-        self.assertEqual(ciph, encode(msg))
+        self.assertEqual(encode(msg), ciph)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/diamond/diamond_test.py

@@ -4,9 +4,8 @@ from diamond import make_diamond
 
 
 class DiamondTests(unittest.TestCase):
-
     def test_letter_A(self):
-        self.assertMultiLineEqual('A\n', make_diamond('A'))
+        self.assertMultiLineEqual(make_diamond('A'), 'A\n')
 
     def test_letter_C(self):
         result = ['  A  ',
@@ -14,7 +13,7 @@ class DiamondTests(unittest.TestCase):
                   'C   C',
                   ' B B ',
                   '  A  ']
-        self.assertMultiLineEqual('\n'.join(result) + '\n', make_diamond('C'))
+        self.assertMultiLineEqual(make_diamond('C'), '\n'.join(result) + '\n')
 
     def test_letter_E(self):
         result = ['    A    ',
@@ -26,7 +25,7 @@ class DiamondTests(unittest.TestCase):
                   '  C   C  ',
                   '   B B   ',
                   '    A    ']
-        self.assertMultiLineEqual('\n'.join(result) + '\n', make_diamond('E'))
+        self.assertMultiLineEqual(make_diamond('E'), '\n'.join(result) + '\n')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/etl/etl_test.py

@@ -8,13 +8,13 @@ class TransformTest(unittest.TestCase):
         old = {1: ['WORLD']}
         expected = {'world': 1}
 
-        self.assertEqual(expected, etl.transform(old))
+        self.assertEqual(etl.transform(old), expected)
 
     def test_transform_more_values(self):
         old = {1: ['WORLD', 'GSCHOOLERS']}
         expected = {'world': 1, 'gschoolers': 1}
 
-        self.assertEqual(expected, etl.transform(old))
+        self.assertEqual(etl.transform(old), expected)
 
     def test_more_keys(self):
         old = {1: ['APPLE', 'ARTICHOKE'], 2: ['BOAT', 'BALLERINA']}
@@ -25,7 +25,7 @@ class TransformTest(unittest.TestCase):
             'ballerina': 2
         }
 
-        self.assertEqual(expected, etl.transform(old))
+        self.assertEqual(etl.transform(old), expected)
 
     def test_full_dataset(self):
         old = {
@@ -47,7 +47,7 @@ class TransformTest(unittest.TestCase):
             "z": 10
         }
 
-        self.assertEqual(expected, etl.transform(old))
+        self.assertEqual(etl.transform(old), expected)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/gigasecond/gigasecond_test.py

@@ -7,43 +7,35 @@ from gigasecond import add_gigasecond
 class GigasecondTest(unittest.TestCase):
     def test_1(self):
         self.assertEqual(
-            datetime(2043, 1, 1, 1, 46, 40),
-            add_gigasecond(datetime(2011, 4, 25))
-        )
+            add_gigasecond(datetime(2011, 4, 25)),
+            datetime(2043, 1, 1, 1, 46, 40))
 
     def test_2(self):
         self.assertEqual(
-            datetime(2009, 2, 19, 1, 46, 40),
-            add_gigasecond(datetime(1977, 6, 13))
-        )
+            add_gigasecond(datetime(1977, 6, 13)),
+            datetime(2009, 2, 19, 1, 46, 40))
 
     def test_3(self):
         self.assertEqual(
-            datetime(1991, 3, 27, 1, 46, 40),
-            add_gigasecond(datetime(1959, 7, 19))
-        )
+            add_gigasecond(datetime(1959, 7, 19)),
+            datetime(1991, 3, 27, 1, 46, 40))
 
     def test_4(self):
         self.assertEqual(
-            datetime(2046, 10, 2, 23, 46, 40),
-            add_gigasecond(datetime(2015, 1, 24, 22, 0, 0))
-        )
+            add_gigasecond(datetime(2015, 1, 24, 22, 0, 0)),
+            datetime(2046, 10, 2, 23, 46, 40))
 
     def test_5(self):
         self.assertEqual(
-            datetime(2046, 10, 3, 1, 46, 39),
-            add_gigasecond(datetime(2015, 1, 24, 23, 59, 59))
-        )
+            add_gigasecond(datetime(2015, 1, 24, 23, 59, 59)),
+            datetime(2046, 10, 3, 1, 46, 39))
 
     def test_yourself(self):
         # customize this to test your birthday and find your gigasecond date:
         your_birthday = datetime(1970, 1, 1)
         your_gigasecond = datetime(2001, 9, 9, 1, 46, 40)
 
-        self.assertEqual(
-            your_gigasecond,
-            add_gigasecond(your_birthday)
-        )
+        self.assertEqual(add_gigasecond(your_birthday), your_gigasecond)
 
 
 if __name__ == '__main__':