class TestPowerPairedWithAllocatedSidesDrawGeneratorPartOddBrackets(unittest.TestCase):
"""Basic unit test for core functionality of power-paired draws with allocated
sides. Not comprehensive."""
brackets = dict()
brackets[1] = OrderedDict([
(5, {"aff": [1], "neg": [14]}),
(4, {"aff": [2, 3], "neg": [15]}),
(3, {"aff": [4, 5, 6, 7, 8], "neg": [16, 17, 18]}),
(2, {"aff": [9, 10], "neg": [19, 20, 21]}),
(1, {"aff": [11, 12], "neg": [22, 23, 24, 25]}),
(0, {"aff": [13], "neg": [26]}),
])
brackets[2] = OrderedDict([
(5, {"aff": [], "neg": [16, 17]}),
(4, {"aff": [1, 2, 3, 4], "neg": [18, 19, 20, 21]}),
(3, {"aff": [5, 6, 7], "neg": [22, 23]}),
(2, {"aff": [8, 9, 10], "neg": []}),
(1, {"aff": [11, 12, 13, 14], "neg": [24, 25, 26, 27]}),
(0, {"aff": [15], "neg": [28, 29, 30]}),
])
brackets[3] = OrderedDict([
(5, {"aff": [1, 2], "neg": []}),
(4, {"aff": [3, 4], "neg": [13]}),
(3, {"aff": [5, 6, 7, 8, 9], "neg": [14, 15, 16]}),
(2, {"aff": [], "neg": [17, 18, 19]}),
(1, {"aff": [10, 11], "neg": [20, 21, 22, 23, 24]}),
(0, {"aff": [12], "neg": []}),
])
brackets[4] = OrderedDict([
(3, {"aff": ["Yale 2", "Stanford 2", "Yale 1"], "neg": []}),
(2, {"aff": ["John Hopkins 1", "Stanford 1", "MIT 1", "Stanford 3", "Berkeley 1"], "neg": ["MIT 2", "Columbia 1", "Caltech 1", "Caltech 3"]}),
(1, {"aff": ["Caltech 2", "Cornell 1", "Yale 3", "Princeton 1"], "neg": ["Chicago 2", "Chicago 1", "Pennsylvania 1", "Chicago 3", "Princeton 2"]}),
(0, {"aff": [], "neg": ["Pennsylvania 2", "Harvard 1", "Harvard 2"]}),
])
brackets[99] = OrderedDict([ # Uneven aff/neg, should raise exception
(5, {"aff": [1, 2], "neg": []}),
(4, {"aff": [3, 4], "neg": [14]}),
(3, {"aff": [5, 6, 7, 8, 9], "neg": [15, 16]}),
(2, {"aff": [], "neg": [17, 18, 19, 20]}),
(1, {"aff": [10, 11], "neg": [21, 22, 23, 24]}),
(0, {"aff": [12, 13], "neg": []}),
])
def setUp(self):
self.ppd = DrawGenerator("power_paired", DUMMY_TEAMS, side_allocations="preallocated")
def tearDown(self):
del self.ppd
def bracket_resolve_odd(self, name, expecteds):
self.ppd.options["odd_bracket"] = name
for index, expected in expecteds.iteritems():
self.b2 = copy.deepcopy(self.brackets[index])
self.ppd.resolve_odd_brackets(self.b2)
self.assertDictEqual(self.b2, expected)
del self.b2
def test_pullup_invalid(self):
for name in ["pullup_top", "pullup_bottom", "pullup_random", "intermediate1", "intermediate2"]:
self.ppd.options["odd_bracket"] = name
self.b2 = copy.deepcopy(self.brackets[99])
self.assertRaises(DrawError, self.ppd.resolve_odd_brackets, self.b2)
def test_pullup_top(self):
expecteds = dict()
expecteds[1] = OrderedDict([
(5, {"aff": [1], "neg": [14]}),
(4, {"aff": [2, 3], "neg": [15, 16]}),
(3, {"aff": [4, 5, 6, 7, 8], "neg": [17, 18, 19, 20, 21]}),
(2, {"aff": [9, 10], "neg": [22, 23]}),
(1, {"aff": [11, 12], "neg": [24, 25]}),
(0, {"aff": [13], "neg": [26]}),
])
expecteds[2] = OrderedDict([
(5, {"aff": [1, 2], "neg": [16, 17]}),
(4, {"aff": [3, 4, 5, 6], "neg": [18, 19, 20, 21]}),
(3, {"aff": [7, 8], "neg": [22, 23]}),
(2, {"aff": [9, 10], "neg": [24, 25]}),
(1, {"aff": [11, 12, 13, 14], "neg": [26, 27, 28, 29]}),
(0, {"aff": [15], "neg": [30]}),
])
expecteds[3] = OrderedDict([
(5, {"aff": [1, 2], "neg": [13, 14]}),
(4, {"aff": [3, 4], "neg": [15, 16]}),
(3, {"aff": [5, 6, 7, 8, 9], "neg": [17, 18, 19, 20, 21]}),
(2, {"aff": [], "neg": []}),
(1, {"aff": [10, 11, 12], "neg": [22, 23, 24]}),
(0, {"aff": [], "neg": []}),
])
expecteds[4] = OrderedDict([
(3, {"aff": ["Yale 2", "Stanford 2", "Yale 1"], "neg": ["MIT 2", "Columbia 1", "Caltech 1"]}),
(2, {"aff": ["John Hopkins 1", "Stanford 1", "MIT 1", "Stanford 3", "Berkeley 1"], "neg": ["Caltech 3", "Chicago 2", "Chicago 1", "Pennsylvania 1", "Chicago 3"]}),
(1, {"aff": ["Caltech 2", "Cornell 1", "Yale 3", "Princeton 1"], "neg": ["Princeton 2", "Pennsylvania 2", "Harvard 1", "Harvard 2"]}),
(0, {"aff": [], "neg": []}),
])
self.bracket_resolve_odd("pullup_top", expecteds)
def test_pullup_bottom(self):
expecteds = dict()
expecteds[1] = OrderedDict([
(5, {"aff": [1], "neg": [14]}),
(4, {"aff": [2, 3], "neg": [15, 18]}),
(3, {"aff": [4, 5, 6, 7, 8], "neg": [16, 17, 19, 20, 21]}),
(2, {"aff": [9, 10], "neg": [24, 25]}),
(1, {"aff": [11, 12], "neg": [22, 23]}),
(0, {"aff": [13], "neg": [26]}),
])
expecteds[2] = OrderedDict([
(5, {"aff": [3, 4], "neg": [16, 17]}),
(4, {"aff": [1, 2, 6, 7], "neg": [18, 19, 20, 21]}),
(3, {"aff": [5, 10], "neg": [22, 23]}),
(2, {"aff": [8, 9], "neg": [26, 27]}),
(1, {"aff": [11, 12, 13, 14], "neg": [24, 25, 29, 30]}),
(0, {"aff": [15], "neg": [28]}),
])
expecteds[3] = OrderedDict([
(5, {"aff": [1, 2], "neg": [13, 16]}),
(4, {"aff": [3, 4], "neg": [14, 15]}),
(3, {"aff": [5, 6, 7, 8, 9], "neg": [17, 18, 19, 23, 24]}),
(2, {"aff": [], "neg": []}),
(1, {"aff": [10, 11, 12], "neg": [20, 21, 22]}),
(0, {"aff": [], "neg": []}),
])
expecteds[4] = OrderedDict([
(3, {"aff": ["Yale 2", "Stanford 2", "Yale 1"], "neg": ["Columbia 1", "Caltech 1", "Caltech 3"]}),
(2, {"aff": ["John Hopkins 1", "Stanford 1", "MIT 1", "Stanford 3", "Berkeley 1"], "neg": ["MIT 2", "Chicago 1", "Pennsylvania 1", "Chicago 3", "Princeton 2"]}),
(1, {"aff": ["Caltech 2", "Cornell 1", "Yale 3", "Princeton 1"], "neg": ["Chicago 2", "Pennsylvania 2", "Harvard 1", "Harvard 2"]}),
(0, {"aff": [], "neg": []}),
])
self.bracket_resolve_odd("pullup_bottom", expecteds)
def test_intermediate_brackets_1(self):
expecteds = dict()
expecteds[1] = OrderedDict([
(5, {"aff": [1], "neg": [14]}),
(4, {"aff": [2], "neg": [15]}),
(3.5, {"aff": [3], "neg": [16]}),
(3, {"aff": [4, 5], "neg": [17, 18]}),
(2.5, {"aff": [6, 7, 8], "neg": [19, 20, 21]}),
(2, {"aff": [], "neg": []}),
(1.5, {"aff": [9, 10], "neg": [22, 23]}),
(1, {"aff": [11, 12], "neg": [24, 25]}),
(0, {"aff": [13], "neg": [26]}),
])
expecteds[2] = OrderedDict([
(5, {"aff": [], "neg": []}),
(4.5, {"aff": [1, 2], "neg": [16, 17]}),
(4, {"aff": [3, 4], "neg": [18, 19]}),
(3.5, {"aff": [5, 6], "neg": [20, 21]}),
(3, {"aff": [7], "neg": [22]}),
(2.5, {"aff": [8], "neg": [23]}),
(2, {"aff": [], "neg": []}),
(1.5, {"aff": [9, 10], "neg": [24, 25]}),
(1, {"aff": [11, 12], "neg": [26, 27]}),
(0.5, {"aff": [13, 14], "neg": [28, 29]}),
(0, {"aff": [15], "neg": [30]}),
])
expecteds[3] = OrderedDict([
(5, {"aff": [], "neg": []}),
(4.5, {"aff": [1, 2], "neg": [13, 14]}),
(4, {"aff": [], "neg": []}),
(3.5, {"aff": [3, 4], "neg": [15, 16]}),
(3, {"aff": [], "neg": []}),
(2.5, {"aff": [5, 6, 7, 8, 9], "neg":[17, 18, 19, 20, 21]}),
(2, {"aff": [], "neg": []}),
(1, {"aff": [10, 11], "neg": [22, 23]}),
(0.5, {"aff": [12], "neg": [24]}),
(0, {"aff": [], "neg": []}),
])
expecteds[4] = OrderedDict([
(3, {"aff": [], "neg": []}),
(2.5, {"aff": ["Yale 2", "Stanford 2", "Yale 1"], "neg": ["MIT 2", "Columbia 1", "Caltech 1"]}),
(2, {"aff": ["John Hopkins 1"], "neg": ["Caltech 3"]}),
(1.5, {"aff": ["Stanford 1", "MIT 1", "Stanford 3", "Berkeley 1"], "neg": ["Chicago 2", "Chicago 1", "Pennsylvania 1", "Chicago 3"]}),
(1, {"aff": ["Caltech 2"], "neg": ["Princeton 2"]}),
(0.5, {"aff": ["Cornell 1", "Yale 3", "Princeton 1"], "neg": ["Pennsylvania 2", "Harvard 1", "Harvard 2"]}),
(0, {"aff": [], "neg": []}),
])
self.bracket_resolve_odd("intermediate1", expecteds)
def test_intermediate_brackets_2(self):
expecteds = dict()
expecteds[1] = OrderedDict([
(5, {"aff": [1], "neg": [14]}),
(4, {"aff": [2], "neg": [15]}),
(3.5, {"aff": [3], "neg": [16]}),
(3, {"aff": [4, 5], "neg": [17, 18]}),
(2.5, {"aff": [6, 7, 8], "neg": [19, 20, 21]}),
(2, {"aff": [], "neg": []}),
(1.5, {"aff": [9, 10], "neg": [22, 23]}),
(1, {"aff": [11, 12], "neg": [24, 25]}),
(0, {"aff": [13], "neg": [26]}),
])
expecteds[2] = OrderedDict([
(5, {"aff": [], "neg": []}),
(4.5, {"aff": [1, 2], "neg": [16, 17]}),
(4, {"aff": [3, 4], "neg": [18, 19]}),
(3.5, {"aff": [5, 6], "neg": [20, 21]}),
(3, {"aff": [7], "neg": [22]}),
(2.5, {"aff": [8], "neg": [23]}),
(2, {"aff": [], "neg": []}),
(1.5, {"aff": [9, 10], "neg": [24, 25]}),
(1, {"aff": [11, 12], "neg": [26, 27]}),
(0.5, {"aff": [13, 14], "neg": [28, 29]}),
(0, {"aff": [15], "neg": [30]}),
])
expecteds[3] = OrderedDict([
(5, {"aff": [], "neg": []}),
(4+2./3, {"aff": [1], "neg": [13]}),
(4+1./3, {"aff": [2], "neg": [14]}),
(4, {"aff": [], "neg": []}),
(3.5, {"aff": [3, 4], "neg": [15, 16]}),
(3, {"aff": [], "neg": []}),
(2+2./3, {"aff": [5, 6, 7], "neg":[17, 18, 19]}),
(2+1./3, {"aff": [8, 9], "neg": [20, 21]}),
(2, {"aff": [], "neg": []}),
(1, {"aff": [10, 11], "neg": [22, 23]}),
(0.5, {"aff": [12], "neg": [24]}),
(0, {"aff": [], "neg": []}),
])
expecteds[4] = OrderedDict([
(3, {"aff": [], "neg": []}),
(2.5, {"aff": ["Yale 2", "Stanford 2", "Yale 1"], "neg": ["MIT 2", "Columbia 1", "Caltech 1"]}),
(2, {"aff": ["John Hopkins 1"], "neg": ["Caltech 3"]}),
(1.5, {"aff": ["Stanford 1", "MIT 1", "Stanford 3", "Berkeley 1"], "neg": ["Chicago 2", "Chicago 1", "Pennsylvania 1", "Chicago 3"]}),
(1, {"aff": ["Caltech 2"], "neg": ["Princeton 2"]}),
(0.5, {"aff": ["Cornell 1", "Yale 3", "Princeton 1"], "neg": ["Pennsylvania 2", "Harvard 1", "Harvard 2"]}),
(0, {"aff": [], "neg": []}),
])
self.maxDiff = None
self.bracket_resolve_odd("intermediate2", expecteds)
def test_pullup_random(self):
for j in range(10):
# Just doing the third one because it's hardest, too lazy to write
# random tests for the others.
b2 = copy.deepcopy(self.brackets[3])
self.ppd.options["odd_bracket"] = "pullup_random"
self.ppd.resolve_odd_brackets(b2)
self.assertEqual(b2[5]["aff"], [1, 2])
self.assertIn(13, b2[5]["neg"])
self.assertEqual([i in b2[5]["neg"] for i in [14, 15, 16]].count(True), 1)
self.assertEqual(b2[4]["aff"], [3, 4])
self.assertEqual([i in b2[4]["neg"] for i in [14, 15, 16]].count(True), 2)
self.assertItemsEqual(b2[5]["neg"] + b2[4]["neg"], [13, 14, 15, 16])
self.assertEqual(b2[3]["aff"], [5, 6, 7, 8, 9])
self.assertTrue(all(i in b2[3]["neg"] for i in [17, 18, 19]))
self.assertEqual([i in b2[3]["neg"] for i in [20, 21, 22, 23, 24]].count(True), 2)
self.assertEqual(b2[2], {"aff": [], "neg": []})
self.assertEqual(b2[1]["aff"], [10, 11, 12])
self.assertEqual([i in b2[1]["neg"] for i in [20, 21, 22, 23, 24]].count(True), 3)
self.assertEqual(b2[0], {"aff": [], "neg": []})
class TestPowerPairedDrawGeneratorParts(unittest.TestCase):
"""Basic unit test for core functionality of power-paired draws.
Nowhere near comprehensive."""
brackets = OrderedDict([
(4, [1, 2, 3, 4, 5]),
(3, [6, 7, 8, 9]),
(2, [10, 11, 12, 13, 14]),
(1, [15, 16])
])
def setUp(self):
self.b2 = copy.deepcopy(self.brackets)
self.ppd = DrawGenerator("power_paired", DUMMY_TEAMS)
def tearDown(self):
del self.b2
del self.ppd
def bracket_resolve_odd(self, name, expected):
self.ppd.options["odd_bracket"] = name
self.ppd.resolve_odd_brackets(self.b2)
self.assertDictEqual(self.b2, expected)
def test_pullup_invalid(self):
brackets = OrderedDict([
(4, [1, 2, 3, 4, 5]),
(3, [6, 7, 8]),
(2, [9, 10, 11, 12, 13]),
(1, [14, 15])
])
for name in ["pullup_top", "pullup_bottom", "pullup_random", "intermediate"]:
b2 = copy.deepcopy(brackets)
self.ppd.options["odd_bracket"] = name
self.assertRaises(DrawError, self.ppd.resolve_odd_brackets, b2)
def test_pullup_top(self):
self.bracket_resolve_odd("pullup_top", OrderedDict([
(4, [1, 2, 3, 4, 5, 6]),
(3, [7, 8, 9, 10]),
(2, [11, 12, 13, 14]),
(1, [15, 16])
]))
def test_pullup_bottom(self):
self.bracket_resolve_odd("pullup_bottom", OrderedDict([
(4, [1, 2, 3, 4, 5, 9]),
(3, [6, 7, 8, 14]),
(2, [10, 11, 12, 13]),
(1, [15, 16])
]))
def test_intermediate_brackets(self):
self.bracket_resolve_odd("intermediate", OrderedDict([
(4, [1, 2, 3, 4]),
(3.5, [5, 6]),
(3, [7, 8]),
(2.5, [9, 10]),
(2, [11, 12, 13, 14]),
(1, [15, 16])
]))
def test_pullup_random(self):
for j in range(5):
b2 = self.b2
self.ppd.options["odd_bracket"] = "pullup_random"
self.ppd.resolve_odd_brackets(b2)
self.assertTrue(all(i in b2[4] for i in [1, 2, 3, 4, 5]))
self.assertEqual([i in b2[4] for i in [6, 7, 8, 9]].count(True), 1)
self.assertEqual([i in b2[3] for i in [6, 7, 8, 9]].count(True), 3)
self.assertEqual([i in b2[3] for i in [10, 11, 12, 13, 14]].count(True), 1)
self.assertEqual([i in b2[2] for i in [10, 11, 12, 13, 14]].count(True), 4)
self.assertEqual([15, 16], b2[1])
def brackets_intermediate_bubble_up_down(self, brackets, expected):
b2 = copy.deepcopy(brackets)
expected_team_flags = dict()
# Set up the brackets
for p, b in b2.iteritems():
for i, x in enumerate(b):
if isinstance(x[-1], str) and len(x) > 2:
flags = [x[-1]]
x = x[:-1]
else:
flags = None
if len(x) == 2:
t = TestTeam(x[0], x[1], p)
else:
t = TestTeam(x[0], x[1], p, x[2:])
b[i] = t
expected_team_flags[t] = flags
# Run the odd bracket resolution
self.ppd.options["odd_bracket"] = "intermediate_bubble_up_down"
self.ppd.resolve_odd_brackets(b2)
# Check that the brackets are correct
b3 = dict()
for p, b in b2.iteritems():
b3[p] = map(lambda x: x.id, b)
self.assertDictEqual(b3, expected)
# Check that the team flags worked
for team, flags in expected_team_flags.iteritems():
if team in self.ppd.team_flags:
self.assertEqual(self.ppd.team_flags[team], flags)
else:
self.assertIsNone(flags)
def test_intermediate_brackets_avoid_conflicts_1(self):
brackets = OrderedDict([
(4, [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'A', 'bub_up_accom'), (5, 'C', 12, 'bub_up_inst')]),
(3, [(6, 'C'), (7, 'D'), (8, 'A', 10), (9, 'B', 10)]),
(2, [(10, 'D', 8, 9, 'bub_dn_hist'), (11, 'A', 'bub_dn_accom'), (12, 'C', 5), (13, 'B'), (14, 'C', 15)]),
(1, [(15, 'C', 14), (16, 'C')])
])
expected = OrderedDict([
(4, [1, 2, 3, 5]),
(3.5, [4, 6]), # bubble-up (institution)
(3, [7, 8]),
(2.5, [9, 11]), # bubble-down (history, history)
(2, [10, 12, 13, 14]),
(1, [15, 16])
])
self.brackets_intermediate_bubble_up_down(brackets, expected)
def test_intermediate_brackets_avoid_conflicts_2(self):
brackets = OrderedDict([
(4, [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'A', 'bub_up_accom'), (5, 'C', 12, 'bub_up_inst')]),
(3, [(6, 'C'), (7, 'D'), (8, 'A', 'bub_up_accom'), (9, 'B', 10, 'bub_up_hist')]),
(2, [(10, 'D', 9), (11, 'A'), (12, 'C', 5), (13, 'B'), (14, 'C', 15)]),
(1, [(15, 'C', 14), (16, 'C')])
])
expected = OrderedDict([
(4, [1, 2, 3, 5]),
(3.5, [4, 6]), # bubble-up (institution)
(3, [7, 9]),
(2.5, [8, 10]), # bubble-up (history)
(2, [11, 12, 13, 14]),
(1, [15, 16])
])
self.brackets_intermediate_bubble_up_down(brackets, expected)
def test_intermediate_brackets_avoid_conflicts_3(self):
brackets = OrderedDict([
(4, [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'A', 'bub_up_accom'), (5, 'C', 12, 'bub_up_inst')]),
(3, [(6, 'C'), (7, 'D'), (8, 'D'), (9, 'B', 10)]),
(2, [(10, 'D', 9, 'bub_dn_hist'), (11, 'A', 'bub_dn_accom'), (12, 'C', 5), (13, 'B'), (14, 'C', 15)]),
(1, [(15, 'C', 14), (16, 'C')])
])
expected = OrderedDict([
(4, [1, 2, 3, 5]),
(3.5, [4, 6]), # bubble-up (institution)
(3, [7, 8]),
(2.5, [9, 11]), # bubble-down (history, institution)
(2, [10, 12, 13, 14]),
(1, [15, 16])
])
self.brackets_intermediate_bubble_up_down(brackets, expected)
def test_intermediate_brackets_avoid_conflicts_none(self):
brackets = OrderedDict([
(4, [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'A'), (5, 'C', 12)]),
(3, [(6, 'B'), (7, 'D'), (8, 'D'), (9, 'B')]),
(2, [(10, 'D'), (11, 'A'), (12, 'C', 5), (13, 'B'), (14, 'C', 15)]),
(1, [(15, 'C', 14), (16, 'C')])
])
expected = OrderedDict([
(4, [1, 2, 3, 4]),
(3.5, [5, 6]),
(3, [7, 8]),
(2.5, [9, 10]),
(2, [11, 12, 13, 14]),
(1, [15, 16])
])
self.brackets_intermediate_bubble_up_down(brackets, expected)
def test_intermediate_brackets_avoid_conflicts_exhaust(self):
brackets = OrderedDict([
(4, [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'A', 'bub_up_accom'), (5, 'C', 12, 'bub_up_inst')]),
(3, [(6, 'C'), (7, 'D'), (8, 'D'), (9, 'B', 10, 'no_bub_updn')]),
(2, [(10, 'D', 9), (11, 'B'), (12, 'C', 5), (13, 'B'), (14, 'C', 15)]),
(1, [(15, 'C', 14), (16, 'C')])
])
expected = OrderedDict([
(4, [1, 2, 3, 5]),
(3.5, [4, 6]), # bubble-up (institution)
(3, [7, 8]),
(2.5, [9, 10]), # no bubble (exhausted)
(2, [11, 12, 13, 14]),
(1, [15, 16])
])
self.brackets_intermediate_bubble_up_down(brackets, expected)
def pairings(self, name, expected):
ppd = self.ppd
ppd.options["odd_bracket"] = "pullup_top"
ppd.options["pairing_method"] = name
ppd.resolve_odd_brackets(self.b2)
pairings = ppd.generate_pairings(self.b2)
pairings_list = list()
for bracket in pairings.itervalues():
pairings_list.extend(bracket)
result = tuple(tuple(p.teams) for p in pairings_list)
self.assertEqual(result, expected)
def test_pairings_fold(self):
self.pairings("fold", (
(1, 6), (2, 5), (3, 4), (7, 10), (8, 9), (11, 14), (12, 13), (15, 16)
))
def test_pairings_slide(self):
self.pairings("slide", (
(1, 4), (2, 5), (3, 6), (7, 9), (8, 10), (11, 13), (12, 14), (15, 16)
))
def one_up_one_down(self, data, expected, **options):
for option, value in options.iteritems():
self.ppd.options[option] = value
pairings = []
for data1, data2 in data:
team1 = TestTeam(*data1)
team2 = TestTeam(*data2)
pairing = Pairing([team1, team2], None, None)
pairings.append(pairing)
pairings_dict = {0: pairings}
self.ppd.avoid_conflicts(pairings_dict)
self.assertEqual(len(expected), len(pairings))
for (exp_teams, exp_flags), pair in zip(expected, pairings):
self.assertEqual(tuple(t.id for t in pair.teams), exp_teams)
self.assertEqual(pair.flags, exp_flags)
@staticmethod
def _1u1d_no_change(data):
return [((t1[0], t2[0]), []) for t1, t2 in data]
def test_no_swap(self):
data = (((1, 'A'), (5, 'B')),
((2, 'C'), (6, 'A')),
((3, 'B'), (7, 'D')),
((4, 'C'), (8, 'A')))
expected = self._1u1d_no_change(data)
self.one_up_one_down(data, expected)
def test_swap_institution(self):
data = (((1, 'A'), (5, 'A')),
((2, 'C'), (6, 'B')),
((3, 'B'), (7, 'D')),
((4, 'C'), (8, 'A')))
expected = [((1, 6), ["1u1d_inst"]),
((2, 5), ["1u1d_other"]),
((3, 7), []),
((4, 8), [])]
self.one_up_one_down(data, expected)
def test_no_swap_institution(self):
data = (((1, 'A'), (5, 'A')),
((2, 'C'), (6, 'B')),
((3, 'B'), (7, 'D')),
((4, 'C'), (8, 'A')))
expected = self._1u1d_no_change(data)
self.one_up_one_down(data, expected, avoid_institution=False)
def test_swap_history(self):
data = (((1, 'A', None, 5), (5, 'B')),
((2, 'C'), (6, 'A')),
((3, 'B'), (7, 'D')),
((4, 'C'), (8, 'A')))
expected = [((1, 6), ["1u1d_hist"]),
((2, 5), ["1u1d_other"]),
((3, 7), []),
((4, 8), [])]
self.one_up_one_down(data, expected)
def test_no_swap_history(self):
data = (((1, 'A', None, 5), (5, 'B')),
((2, 'C'), (6, 'A')),
((3, 'B'), (7, 'D')),
((4, 'C'), (8, 'A')))
expected = self._1u1d_no_change(data)
self.one_up_one_down(data, expected, avoid_history=False)
def test_last_swap(self):
data = (((1, 'A'), (5, 'B')),
((2, 'C'), (6, 'A')),
((3, 'B'), (7, 'D')),
((4, 'C', None, 8), (8, 'A')))
expected = [((1, 5), []),
((2, 6), []),
((3, 8), ["1u1d_other"]),
((4, 7), ["1u1d_hist"])]
self.one_up_one_down(data, expected)
