def testSeveralChoices(self):
choices = ChoiceDoer([0, 3, 0, 2])
rider = createRouleur()
p = Player(choices, [rider])
p.pickNextMoves()
p.pickNextMoves()
assert_equals(7, rider.nextMove)
def testBackOfGroupInAscent(self):
track = Track([(1, "ascent"), (9, "normal")])
grimpeur = Rider(0, 0)
rouleur = Rider(1, 0)
streamer = Rider(3, 0)
slipstreaming([grimpeur, rouleur, streamer], track)
assert_equals((0, 0), grimpeur.position())
assert_equals((2, 0), rouleur.position())
def testNextMovesSelected(self):
choices = ChoiceDoer([0, 3, 0, 2])
rouleur = createRouleur()
sprinteur = createSprinteur()
p = Player(choices, [rouleur, sprinteur])
p.pickNextMoves()
assert_equals(6, rouleur.nextMove)
assert_equals(4, sprinteur.nextMove)
def testRanking(self):
first = createRider(5, 0)
second = createRider(4, 0)
third = createRider(3, 0)
fourth = createRider(0, 0)
race = self.createRace([fourth, second, third, first])
while not race.isOver():
race.newTurn(Logger())
assert_equals([first, second, third, fourth], race.ranking())
def testSlipstreamLogs(self):
self.track = Track([(10, "normal")])
self.addRider(1)
self.addRider(3)
self.addRider(4)
self.addRider(6)
riders = [self.rider] + self.others
logger = Logger()
slipstreaming(riders, self.track, logger)
assert_equals([[2, 1], [5, 4, 3, 2]], logger.groups)
def testObstacles(self):
riders = [
RiderToken(0, 0),
RiderToken(1, 0),
RiderToken(2, 1),
RiderToken(3, 0),
RiderToken(3, 1)
]
obstacles = Obstacles(riders)
assert_equals([(0, 0), (1, 1), (2, 0), (3, 2), (4, 0)],
findPath(obstacles, (0, 0), (4, 0)))
def testGroups(self):
firstA = Rider(5)
secondA = Rider(4)
firstB = Rider(1)
secondB = Rider(0)
exhaust([firstA, secondA, firstB, secondB])
assert_equals(0, secondA.exhausts)
assert_equals(1, firstA.exhausts)
assert_equals(0, secondB.exhausts)
assert_equals(1, firstB.exhausts)
def testRaceIsOverIfAllRidersHavePassedLine(self):
race = self.createRace([createRider(5, 0)])
assert_equals(True, race.isOver())
def testRaceOver(self):
race = self.createRace([])
assert_equals(True, race.isOver())
def testThroughAscent(self):
self.race.set("ascent", 1)
self.move(9)
assert_equals((5, 0), self.rider.position())
def testSolo(self):
rider = Rider(0)
exhaust([rider])
assert_equals(1, rider.exhausts)
def testBlocked(self):
self.race.addRider(1, 0)
self.race.addRider(1, 1)
self.move(1)
assert_equals((0, 0), self.rider.position())
def tests():
assert_equals(0, countYesInGroup([]))
assert_equals(1, countYesInGroup(["d"]))
assert_equals(2, countYesInGroup(["ad"]))
assert_equals(2, countYesInGroup(["a", "ab"]))
assert_equals(3, countYesInGroup(["a", "bc"]))
assert_equals(0, countAllYesInGroup([""]))
assert_equals(1, countAllYesInGroup(["a"]))
assert_equals(1, countAllYesInGroup(["a", "a"]))
assert_equals(2, countAllYesInGroup(["ab", "ab", "abc"]))
assert_equals(0, countAllYesInGroup(["a", "ab", "c"]))
def testRiderMove(self):
self.move(1)
assert_equals((1, 0), self.rider.position())
def testTwoRiders(self):
self.race.addRider(1, 0)
self.move(1)
assert_equals((1, 1), self.rider.position())
def testRiderAtStart(self):
assert_equals((0, 0), self.rider.position())
def testShouldStayAtSamePositionIfBlocked(self):
self.race.addRider(0, 0) # Myself
self.race.addRider(1, 0)
self.race.addRider(1, 1)
self.move(1)
assert_equals((0, 0), self.rider.position())
def testStopBeforeAscent(self):
self.race.set("ascent", 7)
self.move(9)
assert_equals((6, 0), self.rider.position())
def testRiderMovesAfterATurn(self):
rider = createRider(0, 0)
race = self.createRace([rider])
race.newTurn(Logger())
assert_equals(2, rider.position()[0])
def testDescent(self):
self.race.setAll("descent")
self.move(1)
assert_equals((5, 0), self.rider.position())
def testDontPlayForArrivedRiders(self):
rider = createRider(5, 0)
rider.nextMove = 100
race = self.createRace([rider])
race.newTurn(Logger())
assert_equals(100, rider.nextMove)
def testNoTeams(self):
assert_equals([], createChampionship(SimpleGame(), []))
def tests():
assert_equals(0, howManyColors({}))
d = {"light red": ["shiny gold"]}
assert_equals(1, howManyColors(d))
d = {"light red": ["shiny blue"]}
assert_equals(0, howManyColors(d))
d = {"light red": ["shiny gold"], "shiny blue": ["shiny gold"]}
assert_equals(2, howManyColors(d))
d = {"light red": ["shiny blue"], "shiny blue": ["shiny gold"]}
assert_equals(2, howManyColors(d))
d = {"light red": ["shiny blue"], "shiny blue": ["green gold"], "green gold": ["shiny gold"]}
assert_equals(3, howManyColors(d))
key, values = parseRule("light red bags contain 1 bright white bag, 2 muted yellow bags.")
assert_equals("light red", key)
assert_equals(["bright white", "muted yellow"], values)
def testEndOfRace(self):
self.race = Race(4)
self.move(4)
assert_equals((3, 0), self.rider.position())
def testGroup(self):
rider = Rider(0)
exhaust([rider, Rider(1)])
assert_equals(0, rider.exhausts)
def testThatAllGamesDone(self):
championship = createChampionship(
FranckGame(), ["a", "b", "c", "d", "e", "f", "g", "h"])
assert_equals(7, count_different_opponents(championship, "a"))
def assertPosition(self, square):
assert_equals((square, 0), self.rider.position())
def testCreateRace(self):
riders = [createRider(0, 0)]
race = self.createRace(riders)
assert_equals(False, race.isOver())
assert_similars([], race.ranking())
def testEightTeams(self):
assert_equals(28, len(createChampionship(SimpleGame(), ["a"] * 8)))
def testStartInAscent(self):
self.race.setAll("ascent")
self.move(9)
assert_equals((5, 0), self.rider.position())
