trackler 2.1.0.9 → 2.1.0.10

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

@@ -1,4 +1,5 @@
 import unittest
+
 from datetime import date
 
 from meetup import meetup_day
@@ -9,35 +10,373 @@ except ImportError:
     MeetupDayException = Exception
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class MeetupTest(unittest.TestCase):
     def test_monteenth_of_may_2013(self):
         self.assertEqual(
             meetup_day(2013, 5, 'Monday', 'teenth'), date(2013, 5, 13))
 
+    def test_monteenth_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Monday', 'teenth'), date(2013, 8, 19))
+
+    def test_monteenth_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Monday', 'teenth'), date(2013, 9, 16))
+
+    def test_tuesteenth_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Tuesday', 'teenth'), date(2013, 3, 19))
+
+    def test_tuesteenth_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Tuesday', 'teenth'), date(2013, 4, 16))
+
+    def test_tuesteenth_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Tuesday', 'teenth'), date(2013, 8, 13))
+
+    def test_wednesteenth_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Wednesday', 'teenth'), date(2013, 1, 16))
+
+    def test_wednesteenth_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Wednesday', 'teenth'), date(2013, 2, 13))
+
+    def test_wednesteenth_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Wednesday', 'teenth'), date(2013, 6, 19))
+
+    def test_thursteenth_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Thursday', 'teenth'), date(2013, 5, 16))
+
+    def test_thursteenth_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Thursday', 'teenth'), date(2013, 6, 13))
+
+    def test_thursteenth_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', 'teenth'), date(2013, 9, 19))
+
+    def test_friteenth_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Friday', 'teenth'), date(2013, 4, 19))
+
+    def test_friteenth_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Friday', 'teenth'), date(2013, 8, 16))
+
+    def test_friteenth_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Friday', 'teenth'), date(2013, 9, 13))
+
     def test_saturteenth_of_february_2013(self):
         self.assertEqual(
             meetup_day(2013, 2, 'Saturday', 'teenth'), date(2013, 2, 16))
 
+    def test_saturteenth_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Saturday', 'teenth'), date(2013, 4, 13))
+
+    def test_saturteenth_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Saturday', 'teenth'), date(2013, 10, 19))
+
+    def test_sunteenth_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Sunday', 'teenth'), date(2013, 5, 19))
+
+    def test_sunteenth_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Sunday', 'teenth'), date(2013, 6, 16))
+
+    def test_sunteenth_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Sunday', 'teenth'), date(2013, 10, 13))
+
+    def test_first_monday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Monday', '1st'), date(2013, 3, 4))
+
+    def test_first_monday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Monday', '1st'), date(2013, 4, 1))
+
     def test_first_tuesday_of_may_2013(self):
         self.assertEqual(
             meetup_day(2013, 5, 'Tuesday', '1st'), date(2013, 5, 7))
 
+    def test_first_tuesday_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Tuesday', '1st'), date(2013, 6, 4))
+
+    def test_first_wednesday_of_july_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 7, 'Wednesday', '1st'), date(2013, 7, 3))
+
+    def test_first_wednesday_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Wednesday', '1st'), date(2013, 8, 7))
+
+    def test_first_thursday_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', '1st'), date(2013, 9, 5))
+
+    def test_first_thursday_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Thursday', '1st'), date(2013, 10, 3))
+
+    def test_first_friday_of_november_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 11, 'Friday', '1st'), date(2013, 11, 1))
+
+    def test_first_friday_of_december_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 12, 'Friday', '1st'), date(2013, 12, 6))
+
+    def test_first_saturday_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Saturday', '1st'), date(2013, 1, 5))
+
+    def test_first_saturday_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', '1st'), date(2013, 2, 2))
+
+    def test_first_sunday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Sunday', '1st'), date(2013, 3, 3))
+
+    def test_first_sunday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Sunday', '1st'), date(2013, 4, 7))
+
+    def test_second_monday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Monday', '2nd'), date(2013, 3, 11))
+
     def test_second_monday_of_april_2013(self):
         self.assertEqual(
             meetup_day(2013, 4, 'Monday', '2nd'), date(2013, 4, 8))
 
+    def test_second_tuesday_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Tuesday', '2nd'), date(2013, 5, 14))
+
+    def test_second_tuesday_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Tuesday', '2nd'), date(2013, 6, 11))
+
+    def test_second_wednesday_of_july_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 7, 'Wednesday', '2nd'), date(2013, 7, 10))
+
+    def test_second_wednesday_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Wednesday', '2nd'), date(2013, 8, 14))
+
+    def test_second_thursday_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', '2nd'), date(2013, 9, 12))
+
+    def test_second_thursday_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Thursday', '2nd'), date(2013, 10, 10))
+
+    def test_second_friday_of_november_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 11, 'Friday', '2nd'), date(2013, 11, 8))
+
+    def test_second_friday_of_december_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 12, 'Friday', '2nd'), date(2013, 12, 13))
+
+    def test_second_saturday_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Saturday', '2nd'), date(2013, 1, 12))
+
+    def test_second_saturday_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', '2nd'), date(2013, 2, 9))
+
+    def test_second_sunday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Sunday', '2nd'), date(2013, 3, 10))
+
+    def test_second_sunday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Sunday', '2nd'), date(2013, 4, 14))
+
+    def test_third_monday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Monday', '3rd'), date(2013, 3, 18))
+
+    def test_third_monday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Monday', '3rd'), date(2013, 4, 15))
+
+    def test_third_tuesday_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Tuesday', '3rd'), date(2013, 5, 21))
+
+    def test_third_tuesday_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Tuesday', '3rd'), date(2013, 6, 18))
+
+    def test_third_wednesday_of_july_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 7, 'Wednesday', '3rd'), date(2013, 7, 17))
+
+    def test_third_wednesday_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Wednesday', '3rd'), date(2013, 8, 21))
+
     def test_third_thursday_of_september_2013(self):
         self.assertEqual(
             meetup_day(2013, 9, 'Thursday', '3rd'), date(2013, 9, 19))
 
+    def test_third_thursday_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Thursday', '3rd'), date(2013, 10, 17))
+
+    def test_third_friday_of_november_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 11, 'Friday', '3rd'), date(2013, 11, 15))
+
+    def test_third_friday_of_december_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 12, 'Friday', '3rd'), date(2013, 12, 20))
+
+    def test_third_saturday_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Saturday', '3rd'), date(2013, 1, 19))
+
+    def test_third_saturday_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', '3rd'), date(2013, 2, 16))
+
+    def test_third_sunday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Sunday', '3rd'), date(2013, 3, 17))
+
+    def test_third_sunday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Sunday', '3rd'), date(2013, 4, 21))
+
+    def test_fourth_monday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Monday', '4th'), date(2013, 3, 25))
+
+    def test_fourth_monday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Monday', '4th'), date(2013, 4, 22))
+
+    def test_fourth_tuesday_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Tuesday', '4th'), date(2013, 5, 28))
+
+    def test_fourth_tuesday_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Tuesday', '4th'), date(2013, 6, 25))
+
+    def test_fourth_wednesday_of_july_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 7, 'Wednesday', '4th'), date(2013, 7, 24))
+
+    def test_fourth_wednesday_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Wednesday', '4th'), date(2013, 8, 28))
+
+    def test_fourth_thursday_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', '4th'), date(2013, 9, 26))
+
+    def test_fourth_thursday_of_october_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 10, 'Thursday', '4th'), date(2013, 10, 24))
+
+    def test_fourth_friday_of_november_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 11, 'Friday', '4th'), date(2013, 11, 22))
+
+    def test_fourth_friday_of_december_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 12, 'Friday', '4th'), date(2013, 12, 27))
+
+    def test_fourth_saturday_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Saturday', '4th'), date(2013, 1, 26))
+
+    def test_fourth_saturday_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', '4th'), date(2013, 2, 23))
+
     def test_fourth_sunday_of_march_2013(self):
         self.assertEqual(
             meetup_day(2013, 3, 'Sunday', '4th'), date(2013, 3, 24))
 
+    def test_fourth_sunday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Sunday', '4th'), date(2013, 4, 28))
+
+    def test_last_monday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Monday', 'last'), date(2013, 3, 25))
+
+    def test_last_monday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Monday', 'last'), date(2013, 4, 29))
+
+    def test_last_tuesday_of_may_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 5, 'Tuesday', 'last'), date(2013, 5, 28))
+
+    def test_last_tuesday_of_june_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 6, 'Tuesday', 'last'), date(2013, 6, 25))
+
+    def test_last_wednesday_of_july_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 7, 'Wednesday', 'last'), date(2013, 7, 31))
+
+    def test_last_wednesday_of_august_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 8, 'Wednesday', 'last'), date(2013, 8, 28))
+
+    def test_last_thursday_of_september_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 9, 'Thursday', 'last'), date(2013, 9, 26))
+
     def test_last_thursday_of_october_2013(self):
         self.assertEqual(
             meetup_day(2013, 10, 'Thursday', 'last'), date(2013, 10, 31))
 
+    def test_last_friday_of_november_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 11, 'Friday', 'last'), date(2013, 11, 29))
+
+    def test_last_friday_of_december_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 12, 'Friday', 'last'), date(2013, 12, 27))
+
+    def test_last_saturday_of_january_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 1, 'Saturday', 'last'), date(2013, 1, 26))
+
+    def test_last_saturday_of_february_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 2, 'Saturday', 'last'), date(2013, 2, 23))
+
+    def test_last_sunday_of_march_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 3, 'Sunday', 'last'), date(2013, 3, 31))
+
+    def test_last_sunday_of_april_2013(self):
+        self.assertEqual(
+            meetup_day(2013, 4, 'Sunday', 'last'), date(2013, 4, 28))
+
     def test_last_wednesday_of_february_2012(self):
         self.assertEqual(
             meetup_day(2012, 2, 'Wednesday', 'last'), date(2012, 2, 29))
@@ -46,7 +385,7 @@ class MeetupTest(unittest.TestCase):
         self.assertEqual(
             meetup_day(2014, 12, 'Wednesday', 'last'), date(2014, 12, 31))
 
-    def test_last_sunday_of_only_four_week_february_2015(self):
+    def test_last_sunday_of_february_2015(self):
         self.assertEqual(
             meetup_day(2015, 2, 'Sunday', 'last'), date(2015, 2, 22))
 
@@ -54,6 +393,7 @@ class MeetupTest(unittest.TestCase):
         self.assertEqual(
             meetup_day(2012, 12, 'Friday', '1st'), date(2012, 12, 7))
 
+    # additional track specific tests
     def test_fifth_monday_of_march_2015(self):
         self.assertEqual(
             meetup_day(2015, 3, 'Monday', '5th'), date(2015, 3, 30))

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

@@ -0,0 +1,45 @@
+from collections import defaultdict
+
+RESULTS = dict(win=0, draw=1, loss=2)
+
+
+def invert_result(result):
+    if result == 0:
+        return 2
+    elif result == 2:
+        return 0
+    return result
+
+
+def parse_game(game_line):
+    game = game_line.split(';')
+    if len(game) == 3 and game[2] in RESULTS:
+        result = RESULTS[game[2]]
+        return (game[0], result), (game[1], invert_result(result))
+    return []
+
+
+def calculate_points(stats):
+    return stats[0] * 3 + stats[1]
+
+
+def format_table(results):
+    table = ['Team                           | MP |  W |  D |  L |  P']
+
+    for team, games in sorted(
+            results.items(), key=lambda g: (-calculate_points(g[1]), g[0])):
+        team_fmt = '{0:30} | {1:2} | {3:2} | {4:2} | {5:2} | {2:2}'
+        table.append(
+            team_fmt.format(team, sum(games), calculate_points(games), *games))
+
+    return '\n'.join(table)
+
+
+def tally(data):
+    table = defaultdict(lambda: [0, 0, 0])
+
+    for line in data.split('\n'):
+        for team, result in parse_game(line):
+            table[team][result] += 1
+
+    return format_table(table)

data/tracks/python/exercises/tournament/tournament.py

@@ -0,0 +1,2 @@
+def tally(data):
+    pass

data/tracks/python/exercises/tournament/tournament_test.py

@@ -0,0 +1,70 @@
+import unittest
+
+from tournament import tally
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.1.0
+
+class TestTournament(unittest.TestCase):
+    def test_typical_input(self):
+        results = ('Allegoric Alaskans;Blithering Badgers;win\n'
+                   'Devastating Donkeys;Courageous Californians;draw\n'
+                   'Devastating Donkeys;Allegoric Alaskans;win\n'
+                   'Courageous Californians;Blithering Badgers;loss\n'
+                   'Blithering Badgers;Devastating Donkeys;loss\n'
+                   'Allegoric Alaskans;Courageous Californians;win')
+
+        table = ('Team                           | MP |  W |  D |  L |  P\n'
+                 'Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n'
+                 'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n'
+                 'Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n'
+                 'Courageous Californians        |  3 |  0 |  1 |  2 |  1')
+
+        self.assertEqual(tally(results), table)
+
+    def test_incomplete_competitionnot_all_pairs_have_played(self):
+        results = ('Allegoric Alaskans;Blithering Badgers;loss\n'
+                   'Devastating Donkeys;Allegoric Alaskans;loss\n'
+                   'Courageous Californians;Blithering Badgers;draw\n'
+                   'Allegoric Alaskans;Courageous Californians;win')
+
+        table = ('Team                           | MP |  W |  D |  L |  P\n'
+                 'Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n'
+                 'Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n'
+                 'Courageous Californians        |  2 |  0 |  1 |  1 |  1\n'
+                 'Devastating Donkeys            |  1 |  0 |  0 |  1 |  0')
+
+        self.assertEqual(tally(results), table)
+
+    def test_ties_broken_alphabetically(self):
+        results = ('Courageous Californians;Devastating Donkeys;win\n'
+                   'Allegoric Alaskans;Blithering Badgers;win\n'
+                   'Devastating Donkeys;Allegoric Alaskans;loss\n'
+                   'Courageous Californians;Blithering Badgers;win\n'
+                   'Blithering Badgers;Devastating Donkeys;draw\n'
+                   'Allegoric Alaskans;Courageous Californians;draw')
+
+        table = ('Team                           | MP |  W |  D |  L |  P\n'
+                 'Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n'
+                 'Courageous Californians        |  3 |  2 |  1 |  0 |  7\n'
+                 'Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n'
+                 'Devastating Donkeys            |  3 |  0 |  1 |  2 |  1')
+
+        self.assertEqual(tally(results), table)
+
+    def test_mostly_invalid_lines(self):
+        results = ('\n'
+                   'Allegoric Alaskans@Blithering Badgers;draw\n'
+                   'Blithering Badgers;Devastating Donkeys;loss\n'
+                   'Devastating Donkeys;Courageous Californians;win;5\n'
+                   'Courageous Californians;Allegoric Alaskans;los')
+
+        table = ('Team                           | MP |  W |  D |  L |  P\n'
+                 'Devastating Donkeys            |  1 |  1 |  0 |  0 |  3\n'
+                 'Blithering Badgers             |  1 |  0 |  0 |  1 |  0')
+
+        self.assertEqual(tally(results), table)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/variable-length-quantity/example.py

@@ -0,0 +1,34 @@
+EIGHTBITMASK = 0x80
+SEVENBITSMASK = 0x7f
+
+
+def encode_single(n):
+    bytes = [n & SEVENBITSMASK]
+    n >>= 7
+
+    while n > 0:
+        bytes.append(n & SEVENBITSMASK | EIGHTBITMASK)
+        n >>= 7
+
+    return bytes[::-1]
+
+
+def encode(numbers):
+    return sum((encode_single(n) for n in numbers), [])
+
+
+def decode(bytes):
+    values = []
+    n = 0
+
+    for i, byte in enumerate(bytes):
+        n <<= 7
+        n += (byte & SEVENBITSMASK)
+
+        if byte & EIGHTBITMASK == 0:
+            values.append(n)
+            n = 0
+        elif i == len(bytes) - 1:
+            raise ValueError('incomplete byte sequence')
+
+    return values

data/tracks/python/exercises/variable-length-quantity/variable_length_quantity.py

@@ -0,0 +1,6 @@
+def encode():
+    pass
+
+
+def decode():
+    pass

data/tracks/python/exercises/variable-length-quantity/variable_length_quantity_test.py

@@ -0,0 +1,100 @@
+import unittest
+
+from variable_length_quantity import encode, decode
+
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
+class TestVLQ(unittest.TestCase):
+    def test_zero(self):
+        self.assertEqual(encode([0x0]), [0x0])
+
+    def test_arbitrary_single_byte(self):
+        self.assertEqual(encode([0x40]), [0x40])
+
+    def test_largest_single_byte(self):
+        self.assertEqual(encode([0x7f]), [0x7f])
+
+    def test_smallest_double_byte(self):
+        self.assertEqual(encode([0x80]), [0x81, 0x0])
+
+    def test_arbitrary_double_byte(self):
+        self.assertEqual(encode([0x2000]), [0xc0, 0x0])
+
+    def test_largest_double_byte(self):
+        self.assertEqual(encode([0x3fff]), [0xff, 0x7f])
+
+    def test_smallest_triple_byte(self):
+        self.assertEqual(encode([0x4000]), [0x81, 0x80, 0x0])
+
+    def test_arbitrary_triple_byte(self):
+        self.assertEqual(encode([0x100000]), [0xc0, 0x80, 0x0])
+
+    def test_largest_triple_byte(self):
+        self.assertEqual(encode([0x1fffff]), [0xff, 0xff, 0x7f])
+
+    def test_smallest_quadruple_byte(self):
+        self.assertEqual(encode([0x200000]), [0x81, 0x80, 0x80, 0x0])
+
+    def test_arbitrary_quadruple_byte(self):
+        self.assertEqual(encode([0x8000000]), [0xc0, 0x80, 0x80, 0x0])
+
+    def test_largest_quadruple_byte(self):
+        self.assertEqual(encode([0xfffffff]), [0xff, 0xff, 0xff, 0x7f])
+
+    def test_smallest_quintuple_byte(self):
+        self.assertEqual(encode([0x10000000]), [0x81, 0x80, 0x80, 0x80, 0x0])
+
+    def test_arbitrary_quintuple_byte(self):
+        self.assertEqual(encode([0xff000000]), [0x8f, 0xf8, 0x80, 0x80, 0x0])
+
+    def test_maximum_32_bit_integer_input(self):
+        self.assertEqual(encode([0xffffffff]), [0x8f, 0xff, 0xff, 0xff, 0x7f])
+
+    def test_two_single_byte_values(self):
+        self.assertEqual(encode([0x40, 0x7f]), [0x40, 0x7f])
+
+    def test_two_multi_byte_values(self):
+        self.assertEqual(
+            encode([0x4000, 0x123456]), [0x81, 0x80, 0x0, 0xc8, 0xe8, 0x56])
+
+    def test_many_multi_byte_values(self):
+        self.assertEqual(
+            encode([0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000]),
+            [0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff,
+             0x7f, 0x81, 0x80, 0x0]
+        )
+
+    def test_one_byte(self):
+        self.assertEqual(decode([0x7f]), [0x7f])
+
+    def test_two_bytes(self):
+        self.assertEqual(decode([0xc0, 0x0]), [0x2000])
+
+    def test_three_bytes(self):
+        self.assertEqual(decode([0xff, 0xff, 0x7f]), [0x1fffff])
+
+    def test_four_bytes(self):
+        self.assertEqual(decode([0x81, 0x80, 0x80, 0x0]), [0x200000])
+
+    def test_maximum_32_bit_integer(self):
+        self.assertEqual(decode([0x8f, 0xff, 0xff, 0xff, 0x7f]), [0xffffffff])
+
+    def test_incomplete_sequence_causes_error(self):
+        with self.assertRaises(ValueError):
+            decode([0xff])
+
+    def test_incomplete_sequence_causes_error_even_if_value_is_zero(self):
+        with self.assertRaises(ValueError):
+            decode([0x80])
+
+    def test_multiple_values(self):
+        self.assertEqual(
+            decode([0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f,
+                    0x0, 0xff, 0x7f, 0x81, 0x80, 0x0]),
+            [0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000]
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()