Example #1
0
    def test06(self):
        """ an object knows its location when put on the grid """

        grid = Grid(5, 5)
        bug = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        grid.put(2, 2, bug)
        self.assertEquals((2, 2), (bug.x, bug.y))
        grid.remove(2, 2, bug)
        self.assertEquals((None, None), (bug.x, bug.y))
Example #2
0
    def test07(self):
        """ the movement can be caught (e.g. by a PySGE behaviour for smooth transition) """

        moves = []
        def mover(*arg):
            moves.append(arg)
        grid = Grid(5, 5, mover=mover)
        bug = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        grid.put(2, 2, bug)
        grid.move(3, 4, bug)
        self.assertEquals(1, len(moves))
        self.assertEquals((3, 4, bug), moves[0])
        self.assertEquals(2,  bug.x)
        self.assertEquals(2, bug.y)
        self.assertTrue(grid.has(2, 2, bug))
Example #3
0
    def test02(self):
        """ two bugs with the same scent """

        grid = Grid(5, 5)
        bug1 = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        bug2 = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=2)
        grid.put(2, 2, bug1)
        grid.put(1, 1, bug2)

        grid.diffuse()
        self.assertEquals(2, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4, grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(2.5 , grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4.25, grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(2.875 , grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4.8125, grid.scent(2, 2, PHEROMONE))
Example #4
0
    def test01(self):
        """ one bug """

        grid = Grid(5, 5)
        bug = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        grid.put(2, 2, bug)

        grid.diffuse()
        self.assertEquals(4, grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0.5, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4  , grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0.0625, grid.scent(0, 0, PHEROMONE))
        self.assertEquals(0.125 , grid.scent(0, 1, PHEROMONE))
        self.assertEquals(0.1875, grid.scent(0, 2, PHEROMONE))
        self.assertEquals(0.625 , grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4.5   , grid.scent(2, 2, PHEROMONE))
Example #5
0
    def test05(self):
        """ one bug, one pond """

        grid = Grid(5, 5)
        bug = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        pond1 = Pond(grid, pheromoneKind=PHEROMONE)
        pond2 = Pond(grid, pheromoneKind=PHEROMONE)
        pond3 = Pond(grid, pheromoneKind=PHEROMONE)
        pond4 = Pond(grid, pheromoneKind=PHEROMONE)
        pond5 = Pond(grid, pheromoneKind=PHEROMONE)

        grid.put(2, 2, bug)
        grid.put(1, 0, pond1)
        grid.put(1, 1, pond2)
        grid.put(1, 2, pond3)
        grid.put(1, 3, pond4)
        grid.put(1, 4, pond5)

        grid.diffuse()
        self.assertEquals(0, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4, grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0    , grid.scent(0, 0, PHEROMONE))
        self.assertEquals(0    , grid.scent(0, 1, PHEROMONE))
        self.assertEquals(0    , grid.scent(0, 2, PHEROMONE))
        self.assertEquals(0.125, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(0.5  , grid.scent(2, 1, PHEROMONE))
        self.assertEquals(0    , grid.scent(2, 0, PHEROMONE))
        self.assertEquals(4    , grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0.015625  , grid.scent(0, 0, PHEROMONE))
        self.assertEquals(0.03125   , grid.scent(0, 1, PHEROMONE))
        self.assertEquals(0.046875  , grid.scent(0, 2, PHEROMONE))
        self.assertEquals(0.14453125, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(0.65625   , grid.scent(2, 1, PHEROMONE))
        self.assertEquals(0.140625  , grid.scent(2, 0, PHEROMONE))
        self.assertEquals(4.359375  , grid.scent(2, 2, PHEROMONE))
Example #6
0
 def setUp(self):
     self.grid = Grid(5, 5)
     def louseFactory(life):
         return Louse(self.grid, NO_SPRITE, louseFactory, life=life)
     self.louse = louseFactory(life=10)
Example #7
0
    def test04(self):
        """ one bug, one wall """

        grid = Grid(5, 5)
        bug = Bug(grid, pheromoneKind=PHEROMONE, pheromoneValue=4)
        wall1 = Wall(grid, pheromoneKind=PHEROMONE)
        wall2 = Wall(grid, pheromoneKind=PHEROMONE)
        wall3 = Wall(grid, pheromoneKind=PHEROMONE)
        wall4 = Wall(grid, pheromoneKind=PHEROMONE)
        wall5 = Wall(grid, pheromoneKind=PHEROMONE)

        grid.put(2, 2, bug)
        grid.put(1, 0, wall1)
        grid.put(1, 1, wall2)
        grid.put(1, 2, wall3)
        grid.put(1, 3, wall4)
        grid.put(1, 4, wall5)

        grid.diffuse()
        self.assertEquals(0, grid.scent(1, 1, PHEROMONE))
        self.assertEquals(4, grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0   , grid.scent(0, 0, PHEROMONE))
        self.assertEquals(0   , grid.scent(0, 1, PHEROMONE))
        self.assertEquals(0   , grid.scent(0, 2, PHEROMONE))
        self.assertEquals(0   , grid.scent(1, 1, PHEROMONE))
        self.assertEquals(0.5 , grid.scent(2, 1, PHEROMONE))
        self.assertEquals(0   , grid.scent(2, 0, PHEROMONE))
        self.assertEquals(4   , grid.scent(2, 2, PHEROMONE))

        grid.diffuse()
        self.assertEquals(0     , grid.scent(0, 0, PHEROMONE))
        self.assertEquals(0     , grid.scent(0, 1, PHEROMONE))
        self.assertEquals(0     , grid.scent(0, 2, PHEROMONE))
        self.assertEquals(0     , grid.scent(1, 1, PHEROMONE))
        self.assertEquals(0.625 , grid.scent(2, 1, PHEROMONE))
        self.assertEquals(0.125 , grid.scent(2, 0, PHEROMONE))
        self.assertEquals(4.3125, grid.scent(2, 2, PHEROMONE))
Example #8
0
 def setUp(self):
     self.grid = Grid(5, 5)
Example #9
0
class LouseTestCase(unittest.TestCase):
    def setUp(self):
        self.grid = Grid(5, 5)
        def louseFactory(life):
            return Louse(self.grid, NO_SPRITE, louseFactory, life=life)
        self.louse = louseFactory(life=10)

    def test01a(self):
        """ lice just die on sand; they don't produce milk """
        self.grid.put(2, 2, Sand(self.grid))
        self.grid.put(2, 2, self.louse)
        self.louse.prepareToMove()
        self.assertEquals(9, self.louse._life)

    def test01b(self):
        """ lice strive on soil; they reproduce but they don't produce milk """
        self.grid.put(2, 2, Soil(self.grid))
        self.grid.put(2, 2, self.louse)
        self.louse.prepareToMove()
        self.assertEquals(9, self.louse._life)
        newLouse = self.louse.move()
        self.assertTrue(self.grid.has(2, 2, self.louse))
        self.assertEquals(5, self.louse._life)
        self.assertEquals(0, self.louse._milk)
        lice = [(x,y) for x, y in self.grid.square(2, 2) if self.grid.has(x, y, newLouse)]
        self.assertEquals(1, len(lice))
        self.assertEquals(4, newLouse._life)
        self.assertEquals(0, newLouse._milk)

    def test01c(self):
        """ lice strive on grass; they reproduce and produce milk """
        self.grid.put(2, 2, Grass(self.grid))
        self.grid.put(2, 2, self.louse)
        self.louse.prepareToMove()
        self.assertEquals(9, self.louse._life)
        newLouse = self.louse.move()
        self.assertTrue(self.grid.has(2, 2, self.louse))
        self.assertEquals(5, self.louse._life)
        self.assertEquals(1, self.louse._milk)
        lice = [(x,y) for x, y in self.grid.square(2, 2) if self.grid.has(x, y, newLouse)]
        self.assertEquals(1, len(lice))
        self.assertEquals(4, newLouse._life)
        self.assertEquals(0, newLouse._milk)
Example #10
0
class AntFemaleTestCase(unittest.TestCase):
    def setUp(self):
        self.grid = Grid(5, 5)

    def test01a(self):
        """ no target => exploration """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        self.grid.put(2, 2, ant)
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("exploration", str(ant.state))

    def test01b(self):
        """ target not detected => exploration """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(0, 0, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("exploration", str(ant.state))

    def test02(self):
        """ target detected => following the scent """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(0, 0, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("following target", str(ant.state))

    def test03(self):
        """ target reached => staying there """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(2, 2, target)
        ant.goToTarget(target)
        ant.prepareToMove()
        self.assertEquals("foundTarget", str(ant.state))

    def test04(self):
        """ ant movement in exploration """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        self.grid.put(2, 2, ant)
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("exploration", str(ant.state))
        ant.move()
        self.assertNotEquals((2, 2), (ant.x, ant.y))

    def test05(self):
        """ ant movement in target follow """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(0, 0, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("following target", str(ant.state))
        ant.move()
        self.assertEquals((1, 1), (ant.x, ant.y))
        ant.prepareToMove()
        ant.move()
        self.assertEquals((0, 0), (ant.x, ant.y))

    def test06(self):
        """ ant movement when target reached """
        ant = AntFemale(self.grid, NO_SPRITE, None, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(2, 2, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("foundTarget", str(ant.state))
        ant.move()
        self.assertEquals((2, 2), (ant.x, ant.y))

    def test07(self):
        """ ants die """
        ant = AntFemale(self.grid, NO_SPRITE, None, life=3, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, ant)
        self.grid.put(2, 2, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        self.grid.diffuse()
        ant.prepareToMove()
        ant.move()
        self.assertFalse(ant.isDead())
        ant.prepareToMove()
        ant.move()
        self.assertFalse(ant.isDead())
        ant.prepareToMove()
        ant.move()
        self.assertTrue(ant.isDead())
        self.assertEquals((None, None), (ant.x, ant.y))

    def test08(self):
        """ a female that reaches its target on soil becomes a queen """
        def promote(life):
            return AntQueen(self.grid, NO_SPRITE, life=life)
        ant = AntFemale(self.grid, NO_SPRITE, promote, life=3, randomizer=DeterministRandomizer())
        target = AntFemaleTarget(self.grid, NO_SPRITE)
        self.grid.put(2, 2, Soil(self.grid))
        self.grid.put(2, 2, ant)
        self.grid.put(2, 2, target)
        ant.goToTarget(target)
        self.grid.diffuse()
        self.grid.diffuse()
        ant.prepareToMove()
        self.assertEquals("foundTarget", str(ant.state))
        queen = ant.move()
        self.assertNotEquals(ant, queen)
        self.assertTrue(self.grid.has(2, 2, queen))
        self.assertEquals((2, 2), (queen.x, queen.y))
        self.assertEquals(AntQueen, queen.__class__)
        self.assertEquals(ant._life, queen._life)
Example #11
0
 def setUp(self):
     self.grid = Grid(5, 5)
     self.queen = AntQueen(self.grid, NO_SPRITE)
     self.ant = AntWorker(self.grid, NO_SPRITE, randomizer=DeterministRandomizer())
Example #12
0
class AntWorkerTestCase(unittest.TestCase):
    from net.cadrian.microcosmos.model.bugs.antWorkers import TRAIL_HILL, TRAIL_FOOD, TRAIL_LICE

    def setUp(self):
        self.grid = Grid(5, 5)
        self.queen = AntQueen(self.grid, NO_SPRITE)
        self.ant = AntWorker(self.grid, NO_SPRITE, randomizer=DeterministRandomizer())

    def test01a(self):
        """ an ant moving from the hill leaves a trail -- note: the hill is the square around the queen """
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.ant.prepareToMove()
        self.grid.diffuse()
        self.assertEquals(32, self.grid.scent(1, 1, self.TRAIL_HILL))

    def test01b(self):
        """ an ant moving from the hill leaves a trail -- the ant far from the hill """
        self.grid.put(2, 2, self.queen)
        self.grid.put(0, 0, self.ant)
        self.ant.prepareToMove()
        self.grid.diffuse()
        self.assertEquals(0, self.grid.scent(0, 0, self.TRAIL_HILL))

    def test01c(self):
        """ an ant moving from the hill leaves a trail -- the ant is far from the hill but marked as coming from it """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(0, 0, self.ant)
        self.ant.prepareToMove()
        self.grid.diffuse()
        self.assertEquals(32, self.grid.scent(0, 0, self.TRAIL_HILL))

    def test01d(self):
        """ an ant moving from the hill leaves a trail -- the ant is getting far from the hill but moves from it """
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.ant.prepareToMove()
        self.grid.diffuse()
        self.assertEquals(32, self.grid.scent(1, 1, self.TRAIL_HILL))

        self.ant.move()
        self.assertFalse(self.grid.has(1, 1, self.ant))
        self.assertTrue(self.grid.has(self.ant.x, self.ant.y, self.ant))

        self.ant.prepareToMove()
        self.grid.diffuse()
        self.assertEquals(36, self.grid.scent(self.ant.x, self.ant.y, self.TRAIL_HILL))

    def test02a(self):
        """ when leaving hill, an ant will choose to explore by default """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.ant.prepareToMove()
        self.assertEquals("exploration", str(self.ant.state))

    def test02b(self):
        """ when leaving hill, an ant will choose to follow a trail to food if there is one """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.grid._ensurePheromone(1, 2, self.TRAIL_FOOD, 8)
        self.assertEquals(8, self.grid.scent(1, 2, self.TRAIL_FOOD))
        self.ant.prepareToMove()
        self.assertEquals("following food", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(1, 1, self.ant))
        self.assertTrue(self.grid.has(1, 2, self.ant))

    def test02c(self):
        """ when leaving hill, an ant will choose to follow a trail to lice if there is one """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.grid._ensurePheromone(1, 2, self.TRAIL_LICE, 8)
        self.assertEquals(8, self.grid.scent(1, 2, self.TRAIL_LICE))
        self.ant.prepareToMove()
        self.assertEquals("following lice", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(1, 1, self.ant))
        self.assertTrue(self.grid.has(1, 2, self.ant))

    def test02d(self):
        """ when leaving hill, an ant will choose to follow the strongest trail is there are both a food and a lice trails """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.grid._ensurePheromone(1, 2, self.TRAIL_LICE, 8)
        self.grid._ensurePheromone(1, 0, self.TRAIL_FOOD, 16)
        self.assertEquals(8, self.grid.scent(1, 2, self.TRAIL_LICE))
        self.ant.prepareToMove()
        self.assertEquals("following food", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(1, 1, self.ant))
        self.assertFalse(self.grid.has(1, 2, self.ant))
        self.assertTrue(self.grid.has(1, 0, self.ant))

    def test02e(self):
        """ when leaving hill, an ant will choose to follow the lice trail over the food trail if both trails have the same strength """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(1, 1, self.ant)
        self.grid._ensurePheromone(1, 2, self.TRAIL_LICE, 8)
        self.grid._ensurePheromone(1, 0, self.TRAIL_FOOD, 8)
        self.assertEquals(8, self.grid.scent(1, 2, self.TRAIL_LICE))
        self.ant.prepareToMove()
        self.assertEquals("following lice", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(1, 1, self.ant))
        self.assertFalse(self.grid.has(1, 0, self.ant))
        self.assertTrue(self.grid.has(1, 2, self.ant))

    def test03a(self):
        """ when finding food, the ant takes some of it """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(0, 0, self.ant)
        self.grid._ensurePheromone(1, 1, self.TRAIL_HILL, 8)
        food = Food(self.grid, store=5)
        self.grid.put(0, 0, food)
        self.ant.prepareToMove()
        self.assertEquals("storing food", str(self.ant.state))
        self.ant.move()
        self.assertTrue(self.grid.has(0, 0, self.ant))
        self.assertTrue(self.ant._hasFood())
        self.assertEquals(4, food.store)
        self.ant.prepareToMove()
        self.assertEquals("following hill", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(0, 0, self.ant))
        self.assertTrue(self.grid.has(1, 1, self.ant))

    def test03b(self):
        """ when finding lice, the ant milks them """
        self.ant._setLeavingHill()
        self.grid.put(2, 2, self.queen)
        self.grid.put(0, 0, self.ant)
        self.grid._ensurePheromone(1, 1, self.TRAIL_HILL, 8)
        louse = Louse(self.grid, milk=5)
        self.grid.put(0, 0, louse)
        self.ant.prepareToMove()
        self.assertEquals("storing milk", str(self.ant.state))
        self.ant.move()
        self.assertTrue(self.grid.has(0, 0, self.ant))
        self.assertTrue(self.ant._hasFood())
        self.assertEquals(4, louse.milk)
        self.ant.prepareToMove()
        self.assertEquals("following hill", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(0, 0, self.ant))
        self.assertTrue(self.grid.has(1, 1, self.ant))

    def test04(self):
        """ an ant tries to go home even when there is no trail to follow -- and it leaves a trail"""
        self.grid.put(2, 2, self.queen)
        self.grid.put(0, 0, self.ant)
        self.grid.diffuse()
        self.ant._setFood(SCENT_FOOD)
        self.grid.diffuse()
        self.ant.prepareToMove()
        self.assertEquals("following queen", str(self.ant.state))
        self.ant.move()
        self.assertFalse(self.grid.has(0, 0, self.ant))
        self.assertTrue(self.grid.has(1, 1, self.ant))
        self.assertEquals(16, self.grid.scent(0, 0, SCENT_FOOD.kind))
Example #13
0
 def setUp(self):
     self.grid = Grid(5, 5)
     def newAnt():
         return AntFemale(self.grid, NO_SPRITE, None)
     self.ant = AntQueen(self.grid, NO_SPRITE, life=10, nextPosition=lambda square: square[0], nextAnt=lambda: (newAnt, 4))
Example #14
0
class AntQueenTestCase(unittest.TestCase):
    def setUp(self):
        self.grid = Grid(5, 5)
        def newAnt():
            return AntFemale(self.grid, NO_SPRITE, None)
        self.ant = AntQueen(self.grid, NO_SPRITE, life=10, nextPosition=lambda square: square[0], nextAnt=lambda: (newAnt, 4))

    def test01a(self):
        """ a queen that does not produce an ant does not lose life points """
        self.ant._next = None
        self.assertTrue(self.ant._createNext() is None)
        self.assertEquals(10, self.ant._life)

    def test01b(self):
        """ a queen that produces an ant loses some life """
        self.ant._next = lambda: AntFemale(self.grid, NO_SPRITE, None)
        self.ant._cost = 1
        self.assertEquals(AntFemale, self.ant._createNext().__class__)
        self.assertEquals(9, self.ant._life)

    def test01c(self):
        """ a queen with not enough life left will not produce the ant """
        self.ant._life = 3
        self.ant._cost = 3
        self.ant._next = lambda: AntFemale(self.grid, NO_SPRITE, None)
        self.assertTrue(self.ant._createNext() is None)
        self.assertEquals(3, self.ant._life)

    def test02a(self):
        """ a queen can produce ants on soil """
        self.grid.put(2, 2, Soil(self.grid))
        self.grid.put(2, 2, self.ant)
        self.assertTrue(self.ant._next is None)
        self.ant.prepareToMove()
        self.assertTrue(self.ant._next is not None)
        newAnt = self.ant.move()
        self.assertTrue(isinstance(newAnt, AntFemale))
        self.assertTrue(self.grid.has(1, 1, newAnt))

    def test02b(self):
        """ a queen can produce ants on grass """
        self.grid.put(2, 2, Grass(self.grid))
        self.grid.put(2, 2, self.ant)
        self.assertTrue(self.ant._next is None)
        self.ant.prepareToMove()
        self.assertTrue(self.ant._next is not None)
        newAnt = self.ant.move()
        self.assertTrue(isinstance(newAnt, AntFemale))
        self.assertTrue(self.grid.has(1, 1, newAnt))

    def test02c(self):
        """ a queen cannot produce ants on sand """
        self.grid.put(2, 2, Sand(self.grid))
        self.grid.put(2, 2, self.ant)
        self.assertTrue(self.ant._next is None)
        self.ant.prepareToMove()
        self.assertTrue(self.ant._next is None)
        newAnt = self.ant.move()
        self.assertTrue(newAnt is None)

    def test03(self):
        """ a dead queen produces nothing """
        self.grid.put(2, 2, Grass(self.grid))
        self.grid.put(2, 2, self.ant)
        self.assertTrue(self.ant._next is None)
        self.ant._life = 0
        self.ant.prepareToMove()
        self.assertTrue(self.ant._next is None)
        newAnt = self.ant.move()
        self.assertTrue(newAnt is None)