def test_current_rent_amount(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(bi.get_rent(1, 7), 2)
bi.upgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 10)
bi.upgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 30)
bi.upgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 90)
bi.upgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 160)
bi.upgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 250)
bi.downgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 160)
bi.downgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 90)
bi.downgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 30)
bi.downgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 10)
bi.downgrade("red", 1)
self.assertEquals(bi.get_rent(1, 7), 2)
def test_non_property_position(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
with self.assertRaises(BoardError):
bi.downgrade("red", 2)
def test_can_purchase(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertFalse(bi.can_purchase(6))
self.assertFalse(bi.can_purchase(8))
self.assertFalse(bi.can_purchase(9))
bi.mortgage("red", 6)
bi.mortgage("red", 8)
bi.mortgage("red", 9)
self.assertFalse(bi.can_purchase(6))
self.assertFalse(bi.can_purchase(8))
self.assertFalse(bi.can_purchase(9))
bi.unmortgage("red", 6)
bi.unmortgage("red", 8)
bi.unmortgage("red", 9)
self.assertFalse(bi.can_purchase(6))
self.assertFalse(bi.can_purchase(8))
self.assertFalse(bi.can_purchase(9))
def test_can_upgrade_owned(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
self.assertFalse(bi.can_upgrade("red", 1))
self.assertFalse(bi.can_upgrade("blue", 1))
def test_unknown_player(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
with self.assertRaises(BoardError):
bi.downgrade("reed", 2)
def test_wrong_player(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
with self.assertRaises(BoardError):
bi.upgrade("blue", 2)
def test_other_can_upgrade_when_unmortgaging(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertTrue(bi.can_upgrade("red", 6))
self.assertTrue(bi.can_upgrade("red", 8))
self.assertTrue(bi.can_upgrade("red", 9))
bi.mortgage("red", 6)
self.assertFalse(bi.can_upgrade("red", 6))
self.assertFalse(bi.can_upgrade("red", 8))
self.assertFalse(bi.can_upgrade("red", 9))
bi.unmortgage("red", 6)
self.assertTrue(bi.can_upgrade("red", 6))
self.assertTrue(bi.can_upgrade("red", 8))
self.assertTrue(bi.can_upgrade("red", 9))
bi.mortgage("red", 8)
self.assertFalse(bi.can_upgrade("red", 6))
self.assertFalse(bi.can_upgrade("red", 8))
self.assertFalse(bi.can_upgrade("red", 9))
bi.unmortgage("red", 8)
self.assertTrue(bi.can_upgrade("red", 6))
self.assertTrue(bi.can_upgrade("red", 8))
self.assertTrue(bi.can_upgrade("red", 9))
def test_can_downgrade_non_monopoly(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
self.assertFalse(bi.can_downgrade("blue", 1))
def test_level(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(bi.get_level(1), 1)
bi.upgrade("red", 1)
self.assertEquals(bi.get_level(1), 2)
bi.upgrade("red", 1)
self.assertEquals(bi.get_level(1), 3)
bi.upgrade("red", 1)
self.assertEquals(bi.get_level(1), 4)
bi.upgrade("red", 1)
self.assertEquals(bi.get_level(1), 5)
bi.upgrade("red", 1)
self.assertEquals(bi.get_level(1), 6)
def test_can_downgrade(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
self.assertTrue(bi.can_downgrade("red", 1))
bi.downgrade("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
bi.mortgage("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
bi.unmortgage("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
bi.upgrade("red", 1)
self.assertTrue(bi.can_downgrade("red", 1))
def test_level(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(1, bi.get_level(6))
self.assertEquals(1, bi.get_level(8))
self.assertEquals(1, bi.get_level(9))
bi.mortgage("red", 6)
bi.mortgage("red", 8)
bi.mortgage("red", 9)
self.assertEquals(0, bi.get_level(6))
self.assertEquals(0, bi.get_level(8))
self.assertEquals(0, bi.get_level(9))
bi.unmortgage("red", 6)
bi.unmortgage("red", 8)
bi.unmortgage("red", 9)
self.assertEquals(1, bi.get_level(6))
self.assertEquals(1, bi.get_level(8))
self.assertEquals(1, bi.get_level(9))
def test_rent(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(6, bi.get_rent(6, 7))
self.assertEquals(6, bi.get_rent(8, 7))
self.assertEquals(8, bi.get_rent(9, 7))
bi.mortgage("red", 6)
bi.mortgage("red", 8)
bi.mortgage("red", 9)
self.assertEquals(0, bi.get_rent(6, 7))
self.assertEquals(0, bi.get_rent(8, 7))
self.assertEquals(0, bi.get_rent(9, 7))
bi.unmortgage("red", 6)
bi.unmortgage("red", 8)
bi.unmortgage("red", 9)
self.assertEquals(6, bi.get_rent(6, 7))
self.assertEquals(6, bi.get_rent(8, 7))
self.assertEquals(8, bi.get_rent(9, 7))
def test_value(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertEquals(100, bi.get_value(6))
self.assertEquals(100, bi.get_value(8))
self.assertEquals(120, bi.get_value(9))
bi.mortgage("red", 6)
bi.mortgage("red", 8)
bi.mortgage("red", 9)
self.assertEquals(50, bi.get_value(6))
self.assertEquals(50, bi.get_value(8))
self.assertEquals(60, bi.get_value(9))
bi.unmortgage("red", 6)
bi.unmortgage("red", 8)
bi.unmortgage("red", 9)
self.assertEquals(100, bi.get_value(6))
self.assertEquals(100, bi.get_value(8))
self.assertEquals(120, bi.get_value(9))
def test_non_player(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertRaises(BoardError, lambda: bi.unmortgage("reed", 6))
def test_non_property(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 2))
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 10))
def test_unowned_property(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
with self.assertRaises(BoardError):
bi.downgrade("red", 6)
def test_houses_return_when_hotel_upgrade(self):
bi = Board(["red", "blue"],
10000,
available_houses=20,
available_hotels=4)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(20, bi.available_houses)
self.assertEquals(4, bi.available_hotels)
bi.upgrade("red", 1)
self.assertEquals(19, bi.available_houses)
self.assertEquals(4, bi.available_hotels)
bi.upgrade("red", 1)
self.assertEquals(18, bi.available_houses)
self.assertEquals(4, bi.available_hotels)
bi.upgrade("red", 1)
self.assertEquals(17, bi.available_houses)
self.assertEquals(4, bi.available_hotels)
bi.upgrade("red", 1)
self.assertEquals(16, bi.available_houses)
self.assertEquals(4, bi.available_hotels)
bi.upgrade("red", 1)
self.assertEquals(20, bi.available_houses)
self.assertEquals(3, bi.available_hotels)
def test_mortgage_without_monopoly(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
try:
bi.mortgage("red", 1)
except BoardError:
self.fail("Game rules allow this")
def test_unmortgage_without_mortgaging(self):
bi = Board(["red", "blue"])
bi.purchase("red", 6)
bi.purchase("red", 8)
bi.purchase("red", 9)
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 6))
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 8))
self.assertRaises(BoardError, lambda: bi.unmortgage("red", 9))
def test_level(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(1, bi.get_level(1))
bi.mortgage("red", 1)
self.assertEquals(0, bi.get_level(1))
def test_can_upgrade_non_max(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
self.assertTrue(bi.can_upgrade("red", 1))
def test_can_downgrade_monopoly_mortgaged(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.mortgage("red", 1)
self.assertFalse(bi.can_downgrade("red", 1))
self.assertFalse(bi.can_downgrade("blue", 1))
def test_non_player(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertRaises(BoardError, lambda: bi.mortgage("reed", 3))
with self.assertRaises(BoardError):
bi.mortgage("reed", 3)
def test_unowned_property(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertRaises(BoardError, lambda: bi.mortgage("red", 6))
with self.assertRaises(BoardError):
bi.mortgage("red", 6)
def test_value(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(60, bi.get_value(1))
bi.mortgage("red", 1)
self.assertEquals(30, bi.get_value(1))
def test_rent(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertEquals(2, bi.get_rent(1, dice_roll=7))
bi.mortgage("red", 1)
self.assertEquals(0, bi.get_rent(1, dice_roll=7))
def test_can_purchase(self):
bi = Board(["red", "blue"])
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertFalse(bi.can_purchase(1))
bi.mortgage("red", 1)
self.assertFalse(bi.can_purchase(1))
def test_can_mortgage_other_props_of_same_color(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
bi.upgrade("red", 1)
self.assertFalse(bi.can_mortgage("red", 1))
self.assertFalse(bi.can_mortgage("red", 3))
def test_can_downgrade_level_1(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertFalse(bi.can_downgrade("red", 1))
self.assertFalse(bi.can_downgrade("blue", 1))
self.assertFalse(bi.can_downgrade("red", 3))
self.assertFalse(bi.can_downgrade("blue", 3))
def test_can_upgrade_monopoly(self):
bi = Board(["red", "blue"], 10000)
bi.purchase("red", 1)
bi.purchase("red", 3)
self.assertTrue(bi.can_upgrade("red", 1))
self.assertFalse(bi.can_upgrade("blue", 1))
self.assertTrue(bi.can_upgrade("red", 3))
self.assertFalse(bi.can_upgrade("blue", 3))