Beispiel #1
0
    def test_my_player_is_not_moving(self):
        my_team = SimpleTeam("test", MyPlayer(), MyPlayer())
        test_layout = """
            ############
            # 0 #  # 1 #
            #   #  #   #
            # 2 .  . 3 #
            ############
        """
        teams = [
            # register my_team for bots 0, 2
            my_team,
            # register a pre-defined team as an enemy
            SimpleTeam(RandomPlayer(), RandomPlayer())
        ]

        gm = GameMaster(test_layout,
                        teams,
                        number_bots=4,
                        game_time=5,
                        seed=20)

        # play `game_time` rounds
        gm.play()

        # check the position of my bots
        self.assertEqual(gm.universe.bots[0].current_pos, (2, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (2, 3))
Beispiel #2
0
    def test_round_based_players(self):
        test_layout = (""" ############
            #0  .  .  1#
            #2        3#
            ############ """)
        movements_0 = [east, east]
        movements_1_0 = {0: west, 2: west}
        movements_1_1 = {2: west}
        teams = [
            SimpleTeam(RoundBasedPlayer(movements_0),
                       RoundBasedPlayer(movements_0)),
            SimpleTeam(RoundBasedPlayer(movements_1_0),
                       RoundBasedPlayer(movements_1_1))
        ]
        gm = GameMaster(test_layout, teams, 4, 3)

        self.assertEqual(gm.universe.bots[0].current_pos, (1, 1))
        self.assertEqual(gm.universe.bots[1].current_pos, (10, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (1, 2))
        self.assertEqual(gm.universe.bots[3].current_pos, (10, 2))

        gm.play()
        self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
        self.assertEqual(gm.universe.bots[1].current_pos, (8, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (3, 2))
        self.assertEqual(gm.universe.bots[3].current_pos, (9, 2))
Beispiel #3
0
    def test_my_player_is_not_moving(self):
        my_team = SimpleTeam("test", DrunkPlayer(), DrunkPlayer())
        test_layout = """
            ############
            # 0 #  # 1 #
            #   #  #   #
            # 2 .  . 3 #
            ############
        """
        gm = GameMaster(test_layout, number_bots=4, game_time=5, seed=20)

        # register my_team for bots 0, 2
        gm.register_team(my_team)

        # register a pre-defined team as an enemy
        # First one moves left-down-down-left-left, second one left
        gm.register_team(SimpleTeam(TestPlayer("<vv<<"), TestPlayer("<<<<<")))

        # play `game_time` rounds
        gm.play()

        # check the position of my bots
        # Tests fail, because our player is random
        #        self.assertEqual(gm.universe.bots[0].current_pos, (2, 1))
        #        self.assertEqual(gm.universe.bots[2].current_pos, (2, 3))

        # For reference, testing the test player
        self.assertEqual(gm.universe.bots[1].current_pos, (6, 3))
        self.assertEqual(gm.universe.bots[3].current_pos, (4, 3))
Beispiel #4
0
    def test_win_on_timeout_team_0(self):
        test_start = """ ######
                #0 ..#
                #.. 1#
                ###### """
        # the game lasts two rounds, enough time for bot 1 to eat food
        NUM_ROUNDS = 2
        gm = GameMaster(test_start, 2, game_time=NUM_ROUNDS)
        # bot 1 moves east twice to eat the single food
        gm.register_team(SimpleTeam(TestPlayer(">>")))
        gm.register_team(SimpleTeam(StoppingPlayer()))

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()

            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertTrue(tv.cache[-1]["team_wins"] is not None)
        self.assertEqual(tv.cache[-1]["team_wins"], 0)
        self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
Beispiel #5
0
def test_my_player_is_not_moving():
    my_team = SimpleTeam("test", KangarooPlayer(), KangarooPlayer())
    test_layout = """
        ############
        # 0 #  # 1 #
        #   #  #   #
        # 2 .  . 3 #
        ############
    """
    teams = [
        # register my_team for bots 0, 2
        my_team,
        # register a pre-defined team as an enemy
        # First one moves left-down-down-left-left, second one left
        SimpleTeam(SteppingPlayer("<vv<<"), SteppingPlayer("<<<<<"))
    ]

    gm = GameMaster(test_layout, teams, number_bots=4, game_time=5, seed=20)

    # play `game_time` rounds
    gm.play()

    # check the position of my bots
    # Tests fail, because our player is random
    # assert gm.universe.bots[0].current_pos == (2, 1)
    # assert gm.universe.bots[2].current_pos == (2, 3)

    # For reference, testing the test player
    assert gm.universe.bots[1].current_pos == (6, 3)
    assert gm.universe.bots[3].current_pos == (4, 3)
Beispiel #6
0
    def test_time_spent(self):
        outer = self

        class TimeSpendingPlayer(AbstractPlayer):
            def get_move(self):
                time_spent_begin = self.time_spent()

                sleep_time = 0.1
                time.sleep(sleep_time)

                time_spent_end = self.time_spent()

                outer.assertTrue(0 <= time_spent_begin < time_spent_end)

                time_diff = abs(time_spent_begin + sleep_time - time_spent_end)
                delta = 0.05
                outer.assertTrue(time_diff < delta)
                return stop

        test_layout = (
        """ ############
            #0 #.  .# 1#
            ############ """)
        gm = GameMaster(test_layout, 2, 1)
        gm.register_team(SimpleTeam(TimeSpendingPlayer()))
        gm.register_team(SimpleTeam(RandomPlayer()))
        gm.play()
Beispiel #7
0
    def test_time_spent(self):
        outer = self

        class TimeSpendingPlayer(AbstractPlayer):
            def get_move(self):
                time_spent_begin = self.time_spent()

                sleep_time = 0.1
                time.sleep(sleep_time)

                time_spent_end = self.time_spent()

                outer.assertTrue(0 <= time_spent_begin < time_spent_end)

                time_diff = abs(time_spent_begin + sleep_time - time_spent_end)
                delta = 0.05
                outer.assertTrue(time_diff < delta)
                return stop

        test_layout = (""" ############
            #0 #.  .# 1#
            ############ """)
        team = [SimpleTeam(TimeSpendingPlayer()), SimpleTeam(RandomPlayer())]
        gm = GameMaster(test_layout, team, 2, 1)
        gm.play()
    def test_lose_on_eating_all(self):
        test_start = (
            """ ######
                #0 . #
                # . 1#
                ###### """
        )
        # the game lasts one round, and then draws
        gm = GameMaster(test_start, 2, 100)
        # players do nothing
        gm.register_team(SimpleTeam(StoppingPlayer()))
        gm.register_team(SimpleTeam(TestPlayer([west, west, west])))
        gm.universe.teams[0].score = 2

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
                self.round_ = list()
            def observe(self, round_, turn, universe, events):
                self.cache.append(events)
                self.round_.append(round_)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertEqual(tv.round_[-1], 1)
        self.assertEqual(gm.universe.teams[0].score, 2)
        self.assertEqual(gm.universe.teams[1].score, 1)
        self.assertTrue(TeamWins in tv.cache[-1])
        self.assertEqual(tv.cache[-1].filter_type(TeamWins)[0], TeamWins(0))
    def test_common_target(self):
        my_team = SimpleTeam("test", HunterPlayer(), HunterPlayer())
        test_layout = '''
        ####################
        #    1    0       .#
        #### ###           #
        # .   2            #
        #    3            ##
        ####################
        '''
        teams = [
            # register my_team for bots 0, 2
            my_team,
            # for now enemies don't move
            SimpleTeam(TestPlayer('<<<'), TestPlayer('<<<'))
        ]

        gm = GameMaster(test_layout, teams, number_bots=4, game_time=3, seed=20)

        # play `game_time` rounds
        gm.play()
        #pdb.set_trace()
        # test if both players seeked the food
        self.assertEqual(gm.universe.bots[0].current_pos, (7, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (4, 2))
Beispiel #10
0
    def test_draw_on_timeout(self):
        test_start = (
            """ ######
                #0 . #
                # . 1#
                ###### """)
        # the game lasts one round, and then draws
        NUM_ROUNDS = 1
        # players do nothing
        teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(StoppingPlayer())]
        gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        assert tv.cache[-1]["game_draw"]
        assert gm.game_state["round_index"] == NUM_ROUNDS
Beispiel #11
0
    def test_win_on_timeout_team_1(self):
        test_start = (
            """ ######
                #0 ..#
                #.. 1#
                ###### """)
        # the game lasts two rounds, enough time for bot 1 to eat food
        NUM_ROUNDS = 2

        teams = [
            SimpleTeam(StoppingPlayer()),
            SimpleTeam(SteppingPlayer('<<')) # bot 1 moves west twice to eat the single food
        ]
        gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        assert tv.cache[-1]["team_wins"] is not None
        assert tv.cache[-1]["team_wins"] == 1
        assert gm.game_state["round_index"] == NUM_ROUNDS
Beispiel #12
0
    def test_round_based_players(self):
        test_layout = (
        """ ############
            #0  .  .  1#
            #2        3#
            ############ """)
        movements_0 = [east, east]
        movements_1_0 = {0: west, 2: west}
        movements_1_1 = {2: west}
        teams = [
            SimpleTeam(RoundBasedPlayer(movements_0), RoundBasedPlayer(movements_0)),
            SimpleTeam(RoundBasedPlayer(movements_1_0), RoundBasedPlayer(movements_1_1))
        ]
        gm = GameMaster(test_layout, teams, 4, 3)

        assert gm.universe.bots[0].current_pos == (1, 1)
        assert gm.universe.bots[1].current_pos == (10, 1)
        assert gm.universe.bots[2].current_pos == (1, 2)
        assert gm.universe.bots[3].current_pos == (10, 2)

        gm.play()
        assert gm.universe.bots[0].current_pos == (3, 1)
        assert gm.universe.bots[1].current_pos == (8, 1)
        assert gm.universe.bots[2].current_pos == (3, 2)
        assert gm.universe.bots[3].current_pos == (9, 2)
Beispiel #13
0
    def test_lose_on_eating_all(self):
        test_start = (
            """ ######
                #0 . #
                # . 1#
                ###### """
        )
        teams = [
            SimpleTeam(StoppingPlayer()),
            SimpleTeam(SteppingPlayer('<<<'))
        ]
        # bot 1 eats all the food and the game stops
        gm = GameMaster(test_start, teams, 2, 100)
        gm.universe.teams[0].score = 2

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        assert tv.cache[-1]["round_index"] == 1
        assert gm.universe.teams[0].score == 2
        assert gm.universe.teams[1].score == 1
        assert tv.cache[-1]["team_wins"] is not None
        assert tv.cache[-1]["team_wins"] == 0
        assert gm.game_state["round_index"] == 1
Beispiel #14
0
    def test_time_spent(self):
        class TimeSpendingPlayer(AbstractPlayer):
            def get_move(self):
                time_spent_begin = self.time_spent()

                sleep_time = 0.1
                time.sleep(sleep_time)

                time_spent_end = self.time_spent()

                assert 0 <= time_spent_begin < time_spent_end

                time_diff = abs(time_spent_begin + sleep_time - time_spent_end)
                delta = 0.05
                assert time_diff < delta
                return stop

        test_layout = (
        """ ############
            #0 #.  .# 1#
            ############ """)
        team = [
            SimpleTeam(TimeSpendingPlayer()),
            SimpleTeam(RandomPlayer())
        ]
        gm = GameMaster(test_layout, team, 2, 1)
        gm.play()
    def test_win_on_timeout_team_1(self):
        test_start = (""" ######
                #0 ..#
                #.. 1#
                ###### """)
        # the game lasts two rounds, enough time for bot 1 to eat food
        NUM_ROUNDS = 2

        teams = [
            SimpleTeam(StoppingPlayer()),
            SimpleTeam(TestPlayer(
                '<<'))  # bot 1 moves west twice to eat the single food
        ]
        gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()

            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertTrue(tv.cache[-1]["team_wins"] is not None)
        self.assertEqual(tv.cache[-1]["team_wins"], 1)
        self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
Beispiel #16
0
    def test_stopping(self):
        test_layout = (
        """ ############
            #0#.23 .# 1#
            ############ """)

        round_counting = self.round_counting()
        team = [
            Team(stopping),
            Team(round_counting)
        ]
        gm = GameMaster(test_layout, team, 4, 1)
        gm.play()
        assert gm.universe.bots[0].current_pos == (1, 1)
        assert gm.universe.bots[1].current_pos == (10, 1)
        assert round_counting._storage['rounds'] == 1


        round_counting = self.round_counting()
        team = [
            Team(stopping),
            Team(round_counting)
        ]
        gm = GameMaster(test_layout, team, 4, 3)
        gm.play()
        print(gm.universe.pretty)
        assert gm.universe.bots[0].current_pos == (1, 1)
        assert gm.universe.bots[1].current_pos == (10, 1)
        assert round_counting._storage['rounds'] == 3
Beispiel #17
0
    def test_track(self):
        def trackingBot(turn, game):
            bot = game.team[turn]
            other = game.team[1 - turn]
            if bot.round == 0 and turn == 0:
                assert bot.track[0] == bot.position
                game.state = {}
                game.state[turn] = {}
                game.state[1 - turn] = {}
                game.state[turn]['track'] = []
                game.state[1 - turn]['track'] = []

            if bot.eaten or not game.state[turn]['track']:
                game.state[turn]['track'] = [bot.position]
            if other.eaten or not game.state[1 - turn]['track']:
                game.state[1 - turn]['track'] = [other.position]
            else:
                game.state[1 - turn]['track'].append(other.position)

            assert bot.track[0] == bot._initial_position
            assert bot.track == game.state[turn][
                'track']  # bot.round * 2 + 1 + turn
            assert bot.track[-1] == bot.position
            return randomBot(turn, game)

        layout = """
        ############
        ##02   .3 1#
        ############
        #.#      #.#
        ############
        """
        team = [Team(trackingBot), Team(trackingBot)]
        gm = GameMaster(layout, team, 4, 300)
        gm.play()
Beispiel #18
0
    def test_lose_on_eating_all(self):
        test_start = (
            """ ######
                #0 . #
                # . 1#
                ###### """
        )
        # bot 1 eats all the food and the game stops
        gm = GameMaster(test_start, 2, 100)
        # players do nothing
        gm.register_team(SimpleTeam(StoppingPlayer()))
        gm.register_team(SimpleTeam(TestPlayer('<<<')))
        gm.universe.teams[0].score = 2

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertEqual(tv.cache[-1]["round_index"], 1)
        self.assertEqual(gm.universe.teams[0].score, 2)
        self.assertEqual(gm.universe.teams[1].score, 1)
        self.assertTrue(tv.cache[-1]["team_wins"] is not None)
        self.assertEqual(tv.cache[-1]["team_wins"], 0)
        self.assertEqual(gm.game_state["round_index"], 1)
    def test_lose_on_eating_all(self):
        test_start = (""" ######
                #0 . #
                # . 1#
                ###### """)
        teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(TestPlayer('<<<'))]
        # bot 1 eats all the food and the game stops
        gm = GameMaster(test_start, teams, 2, 100)
        gm.universe.teams[0].score = 2

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()

            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertEqual(tv.cache[-1]["round_index"], 1)
        self.assertEqual(gm.universe.teams[0].score, 2)
        self.assertEqual(gm.universe.teams[1].score, 1)
        self.assertTrue(tv.cache[-1]["team_wins"] is not None)
        self.assertEqual(tv.cache[-1]["team_wins"], 0)
        self.assertEqual(gm.game_state["round_index"], 1)
    def test_my_player_is_not_moving(self):
        my_team = SimpleTeam("test", DrunkPlayer(), DrunkPlayer())
        test_layout = """
            ############
            # 0 #  # 1 #
            #   #  #   #
            # 2 .  . 3 #
            ############
        """
        gm = GameMaster(test_layout, number_bots=4, game_time=5, seed=20)

        # register my_team for bots 0, 2
        gm.register_team(my_team)

        # register a pre-defined team as an enemy
        # First one moves left-down-down-left-left, second one left
        gm.register_team(SimpleTeam(TestPlayer("<vv<<"), TestPlayer("<<<<<")))

        # play `game_time` rounds
        gm.play()

        # check the position of my bots
        # Tests fail, because our player is random
#        self.assertEqual(gm.universe.bots[0].current_pos, (2, 1))
#        self.assertEqual(gm.universe.bots[2].current_pos, (2, 3))

        # For reference, testing the test player
        self.assertEqual(gm.universe.bots[1].current_pos, (6, 3))
        self.assertEqual(gm.universe.bots[3].current_pos, (4, 3))
    def test_draw_on_timeout(self):
        test_start = (
            """ ######
                #0 . #
                # . 1#
                ###### """)
        # the game lasts one round, and then draws
        gm = GameMaster(test_start, 2, 1)
        # players do nothing
        gm.register_team(SimpleTeam(StoppingPlayer()))
        gm.register_team(SimpleTeam(StoppingPlayer()))

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, round_, turn, universe, events):
                self.cache.append(events)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertTrue(GameDraw in tv.cache[-1])
        self.assertEqual(tv.cache[-1][0], GameDraw())
    def test_win_on_timeout_team_1(self):
        test_start = (
            """ ######
                #0 ..#
                #.. 1#
                ###### """)
        # the game lasts two rounds, enough time for bot 1 to eat food
        gm = GameMaster(test_start, 2, 2)
        gm.register_team(SimpleTeam(StoppingPlayer()))
        # bot 1 moves west twice to eat the single food
        gm.register_team(SimpleTeam(TestPlayer([west, west])))

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, round_, turn, universe, events):
                self.cache.append(events)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertTrue(TeamWins in tv.cache[-1])
        self.assertEqual(tv.cache[-1][0], TeamWins(1))
    def test_kill_before_seek_food(self):
        my_team = SimpleTeam("test", EaterPlayer(), EaterPlayer())
        test_layout = """
        ##############
        #.23      .  #
        #### ##   .  #
        #  0.       .#
        #  1    ##.. #
        ##############
        """
        teams = [
            # register my_team for bots 0, 2
            my_team,
            # for now enemies don't move
            SimpleTeam(TestPlayer(3*'>'), TestPlayer(3*'<'))
        ]

        gm = GameMaster(test_layout, teams, number_bots=4, game_time=1, seed=20)

        # play `game_time` rounds
        gm.play()

        # test if both players killed enemy instead of seeking food
        self.assertEqual(gm.universe.bots[0].current_pos, (3, 4))
        self.assertEqual(gm.universe.bots[2].current_pos, (3, 1))
        self.assertEqual(gm.universe.teams[0].score, 10)
    def test_draw_on_timeout(self):
        test_start = (""" ######
                #0 . #
                # . 1#
                ###### """)
        # the game lasts one round, and then draws
        NUM_ROUNDS = 1
        # players do nothing
        teams = [SimpleTeam(StoppingPlayer()), SimpleTeam(StoppingPlayer())]
        gm = GameMaster(test_start, teams, 2, game_time=NUM_ROUNDS)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()

            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()
        gm.play()

        # check
        self.assertTrue(tv.cache[-1]["game_draw"])
        self.assertEqual(gm.game_state["round_index"], NUM_ROUNDS)
Beispiel #25
0
def run_game():
    layout = LAYOUT
    teams = [
        SimpleTeam(StoppingPlayer(), StoppingPlayer()),
        SimpleTeam(StoppingPlayer(), StoppingPlayer())
    ]
    gm = GameMaster(layout, teams, 4, 10)
    #gm.register_viewer(AsciiViewer())
    gm.play()
Beispiel #26
0
    def test_too_few_bots(self):
        test_layout = (""" ############
            #0#.   .# 1#
            ############ """)

        team = [Team(stopping), Team(stopping)]
        gm = GameMaster(test_layout, team, 2, 1)
        with pytest.raises(IndexError):
            gm.play()
Beispiel #27
0
def run_game():
    layout = LAYOUT
    teams = [
        SimpleTeam(StoppingPlayer(), StoppingPlayer()),
        SimpleTeam(StoppingPlayer(), StoppingPlayer())
    ]
    gm = GameMaster(layout, teams, 4, 10)
    #gm.register_viewer(AsciiViewer())
    gm.play()
Beispiel #28
0
 def test_demo_players(self):
     test_layout = (""" ############
         #0 #.  .# 1#
         ############ """)
     team = [SimpleTeam(SpeakingPlayer()), SimpleTeam(RandomPlayer())]
     gm = GameMaster(test_layout, team, 2, 1)
     gm.play()
     self.assertTrue(gm.game_state["bot_talk"][0].startswith("Going"))
     self.assertEqual(gm.game_state["bot_talk"][1], "")
Beispiel #29
0
 def test_demo_players(self):
     test_layout = (""" ############
         #0#.   .# 1#
         ############ """)
     team = [SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer())]
     gm = GameMaster(test_layout, team, 2, 1)
     gm.play()
     self.assertEqual(gm.universe.bots[0].current_pos, (1, 1))
     self.assertEqual(gm.universe.bots[1].current_pos, (9, 1))
Beispiel #30
0
 def test_demo_players(self):
     test_layout = """ ############
         #0#.   .# 1#
         ############ """
     gm = GameMaster(test_layout, 2, 1)
     gm.register_team(SimpleTeam(NQRandomPlayer()))
     gm.register_team(SimpleTeam(NQRandomPlayer()))
     gm.play()
     self.assertEqual(gm.universe.bots[0].current_pos, (1, 1))
     self.assertEqual(gm.universe.bots[1].current_pos, (9, 1))
Beispiel #31
0
 def test_demo_players(self):
     test_layout = """ ##################
         #0#.  .  # .     #
         #2#####    #####3#
         #     . #  .  .#1#
         ################## """
     gm = GameMaster(test_layout, 4, 200)
     gm.register_team(SimpleTeam(StoppingPlayer(), NQRandomPlayer()))
     gm.register_team(SimpleTeam(RandomPlayer(), BFSPlayer()))
     gm.play()
Beispiel #32
0
    def test_must_not_move_after_last_timeout(self):
        # 0 must move back and forth because of random steps
        # but due to its last timeout, it should be disqualified
        # immediately
        test_start = (
            """ ######
                ##0.##
                # ## #
                ##. 1#
                ###### """
        )
        # players do nothing
        class TimeOutPlayer(AbstractPlayer):
            def get_move(self):
                raise PlayerTimeout

        class CheckTestPlayer(AbstractPlayer):
            def get_move(self):
                raise RuntimeError("This should never be called")

        teams = [
            SimpleTeam(TimeOutPlayer()),
            SimpleTeam(CheckTestPlayer())
        ]
        # the game lasts one round, and then draws
        gm = GameMaster(test_start, teams, 2, 100, max_timeouts=1)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()

        gm.play()
        print(gm.universe.pretty)
        print(gm.game_state)

        # check
        assert gm.game_state["max_timeouts"] == 1
        assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
        assert gm.universe.teams[0].score == 0
        assert gm.universe.teams[1].score == 0
        assert gm.universe.bots[0].current_pos == (2,1)
        assert tv.cache[-1]["team_wins"] is not None
        assert tv.cache[-1]["team_wins"] == 1

        # the game ends in round 0 with bot_id 0
        assert gm.game_state["round_index"] == 0
        assert gm.game_state["bot_id"] == 0
Beispiel #33
0
    def test_must_not_move_after_last_timeout(self):
        # 0 must move back and forth because of random steps
        # but due to its last timeout, it should be disqualified
        # immediately
        test_start = (
            """ ######
                ##0.##
                # ## #
                ##. 1#
                ###### """
        )
        # players do nothing
        class TimeOutPlayer(AbstractPlayer):
            def get_move(self):
                raise PlayerTimeout

        class CheckTestPlayer(AbstractPlayer):
            def get_move(self):
                raise RuntimeError("This should never be called")

        teams = [
            SimpleTeam(TimeOutPlayer()),
            SimpleTeam(CheckTestPlayer())
        ]
        # the game lasts one round, and then draws
        gm = GameMaster(test_start, teams, 2, 100, max_timeouts=1)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()

        gm.play()
        print(gm.universe.pretty)
        print(gm.game_state)

        # check
        assert gm.game_state["max_timeouts"] == 1
        assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
        assert gm.universe.teams[0].score == 0
        assert gm.universe.teams[1].score == 0
        assert gm.universe.bots[0].current_pos == (2,1)
        assert tv.cache[-1]["team_wins"] is not None
        assert tv.cache[-1]["team_wins"] == 1

        # the game ends in round 0 with bot_id 0
        assert gm.game_state["round_index"] == 0
        assert gm.game_state["bot_id"] == 0
Beispiel #34
0
 def test_demo_players(self):
     test_layout = (
     """ ############
         #0 #.  .# 1#
         ############ """)
     gm = GameMaster(test_layout, 2, 1)
     gm.register_team(SimpleTeam(SpeakingPlayer()))
     gm.register_team(SimpleTeam(RandomPlayer()))
     gm.play()
     self.assertTrue(gm.game_state["bot_talk"][0].startswith("Going"))
     self.assertEqual(gm.game_state["bot_talk"][1], "")
Beispiel #35
0
 def test_path(self):
     test_layout = (""" ############
         #  . # .# ##
         # ## #  # ##
         #0#.   .##1#
         ############ """)
     team = [SimpleTeam(NQRandomPlayer()), SimpleTeam(NQRandomPlayer())]
     gm = GameMaster(test_layout, team, 2, 7)
     gm.play()
     self.assertEqual(gm.universe.bots[0].current_pos, (4, 3))
     self.assertEqual(gm.universe.bots[1].current_pos, (10, 3))
Beispiel #36
0
 def test_demo_players(self):
     test_layout = (
     """ ############
         #0#.   .# 1#
         ############ """)
     team = [
         SimpleTeam(NQRandomPlayer()),
         SimpleTeam(NQRandomPlayer())
     ]
     gm = GameMaster(test_layout, team, 2, 1)
     gm.play()
     assert gm.universe.bots[0].current_pos == (1, 1)
     assert gm.universe.bots[1].current_pos == (9, 1)
Beispiel #37
0
 def test_demo_players(self):
     test_layout = (
     """ ############
         #0 #.  .# 1#
         ############ """)
     team = [
         SimpleTeam(SpeakingPlayer()),
         SimpleTeam(RandomPlayer())
     ]
     gm = GameMaster(test_layout, team, 2, 1)
     gm.play()
     assert gm.game_state["bot_talk"][0].startswith("Going")
     assert gm.game_state["bot_talk"][1] == ""
Beispiel #38
0
    def test_unreachable_bot(self):
        test_layout = (
        """ ############
            #  .  0#. 1#
            ############ """)
        game_master = GameMaster(test_layout, 2, 1, noise=False)

        bfs2 = BasicDefensePlayer()
        game_master.register_team(SimpleTeam(StoppingPlayer()))
        game_master.register_team(SimpleTeam(bfs2))
        game_master.set_initial()
        game_master.play()
        self.assertTrue(bfs2.path is None)
Beispiel #39
0
 def test_path(self):
     test_layout = (
     """ ############
         #  . # .# ##
         # ## #  # ##
         #0#.   .##1#
         ############ """)
     gm = GameMaster(test_layout, 2, 7)
     gm.register_team(SimpleTeam(NQRandomPlayer()))
     gm.register_team(SimpleTeam(NQRandomPlayer()))
     gm.play()
     self.assertEqual(gm.universe.bots[0].current_pos, (4, 3))
     self.assertEqual(gm.universe.bots[1].current_pos, (10, 3))
Beispiel #40
0
    def test_too_few_bots(self):
        test_layout = (
        """ ############
            #0#.   .# 1#
            ############ """)


        team = [
            Team(stopping),
            Team(stopping)
        ]
        gm = GameMaster(test_layout, team, 2, 1)
        with pytest.raises(IndexError):
            gm.play()
    def test_failing_player(self):
        class FailingPlayer(AbstractPlayer):
            def get_move(self):
                return 1

        test_layout = (""" ######
                #0 . #
                #.. 1#
                ###### """)
        teams = [SimpleTeam(FailingPlayer()), SimpleTeam(TestPlayer("^"))]

        gm = GameMaster(test_layout, teams, 2, 1)

        gm.play()
        self.assertEqual(gm.game_state["timeout_teams"], [1, 0])
Beispiel #42
0
    def test_players(self):
        test_layout = (""" ############
            #  . # .  ##
            # ## #    ##
            # ## #  # ##
            # ## #  # ##
            #    #  # ##
            #0#.   .  1#
            ############ """)

        for player in SANE_PLAYERS:
            team = [SimpleTeam(player()), SimpleTeam(NQRandomPlayer())]
            gm = GameMaster(test_layout, team, 2, 20)
            gm.play()
            assert gm.finished is True
Beispiel #43
0
 def test_path(self):
     test_layout = (
     """ ############
         #  . # .# ##
         # ## #  # ##
         #0#.   .##1#
         ############ """)
     team = [
         SimpleTeam(NQRandomPlayer()),
         SimpleTeam(NQRandomPlayer())
     ]
     gm = GameMaster(test_layout, team, 2, 7)
     gm.play()
     assert gm.universe.bots[0].current_pos == (4, 3)
     assert gm.universe.bots[1].current_pos == (10, 3)
Beispiel #44
0
    def test_unreachable_border(self):
        test_layout = (
        """ ############
            #0 .   #. 1#
            ############ """)
        game_master = GameMaster(test_layout, 2, 1, noise=False)

        bfs1 = BasicDefensePlayer()
        bfs2 = BasicDefensePlayer()
        game_master.register_team(SimpleTeam(bfs1))
        game_master.register_team(SimpleTeam(bfs2))
        game_master.set_initial()
        game_master.play()
        self.assertEqual(bfs1.path, [(5, 1), (4, 1), (3, 1)])
        self.assertTrue(bfs2.path is None)
Beispiel #45
0
    def test_failing_player(self):
        class FailingPlayer(AbstractPlayer):
            def get_move(self):
                return 1

        test_layout = (
            """ ######
                #0 . #
                #.. 1#
                ###### """)
        teams = [SimpleTeam(FailingPlayer()), SimpleTeam(SteppingPlayer("^"))]

        gm = GameMaster(test_layout, teams, 2, 1)

        gm.play()
        assert gm.game_state["timeout_teams"] == [1, 0]
Beispiel #46
0
    def test_failing_player(self):
        class FailingPlayer(AbstractPlayer):
            def get_move(self):
                return 1

        test_layout = """ ######
                #0 . #
                #.. 1#
                ###### """
        gm = GameMaster(test_layout, 2, 1)

        gm.register_team(SimpleTeam(FailingPlayer()))
        gm.register_team(SimpleTeam(TestPlayer("^")))

        gm.play()
        self.assertEqual(gm.game_state["timeout_teams"], [1, 0])
Beispiel #47
0
    def test_too_many_moves(self):
        test_layout = (
        """ ############
            #0  .  .  1#
            #2        3#
            ############ """)
        movements_0 = [east, east]
        movements_1 = [west, west]
        teams = [
            SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0)),
            SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1))
        ]
        gm = GameMaster(test_layout, teams, 4, 3)

        with pytest.raises(ValueError):
            gm.play()
Beispiel #48
0
    def test_lose_5_timeouts(self):
        # 0 must move back and forth because of random steps
        test_start = (
            """ ######
                #0 #.#
                ###  #
                ##. 1#
                ###### """
        )
        # players do nothing
        class TimeOutPlayer(AbstractPlayer):
            def get_move(self):
                raise PlayerTimeout

        teams = [
            SimpleTeam(TimeOutPlayer()),
            SimpleTeam(StoppingPlayer())
        ]
        # the game lasts one round, and then draws
        gm = GameMaster(test_start, teams, 2, 100, max_timeouts=5)

        # this test viewer caches all events lists seen through observe
        class TestViewer(AbstractViewer):
            def __init__(self):
                self.cache = list()
            def observe(self, universe, game_state):
                self.cache.append(game_state)

        # run the game
        tv = TestViewer()
        gm.register_viewer(tv)
        gm.set_initial()

        assert gm.universe.bots[0].current_pos == (1,1)

        gm.play()

        # check
        assert gm.game_state["max_timeouts"] == 5
        assert tv.cache[-1]["round_index"] == gm.game_state["max_timeouts"] - 1
        assert gm.universe.teams[0].score == 0
        assert gm.universe.teams[1].score == 0
        # the bot moves four times, so after the fourth time,
        # it is back on its original position
        assert gm.universe.bots[0].current_pos == (1,1)
        assert tv.cache[-1]["team_wins"] is not None
        assert tv.cache[-1]["team_wins"] == 1
Beispiel #49
0
    def test_rnd(self):
        outer = self

        class RndPlayer(AbstractPlayer):
            def set_initial(self):
                original_seed = self.current_state["seed"]
                original_rand = self.rnd.randint(10, 100)
                outer.assertTrue(10 <= original_rand <= 100)

                # now check
                test_rnd = random.Random(original_seed + self._index)
                outer.assertEqual(test_rnd.randint(10, 100), original_rand)

            def get_move(self):
                outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100)
                return datamodel.stop

        class SeedTestingPlayer(AbstractPlayer):
            def __init__(self):
                # must be initialised before set_initial is called
                self.seed_offset = 120

            def set_initial(self):
                original_seed = self.current_state["seed"]
                original_rand = self.rnd.randint(0, 100)

                # now check
                test_rnd = random.Random(original_seed + self.seed_offset)
                outer.assertEqual(test_rnd.randint(0, 100), original_rand)

            def get_move(self):
                outer.assertTrue(10 <= self.rnd.randint(10, 100) <= 100)
                return datamodel.stop

        test_layout = (""" ############
            #02#.  .#31#
            ############ """)
        teams = [
            SimpleTeam(RndPlayer(), SeedTestingPlayer()),
            SimpleTeam(SeedTestingPlayer(), RndPlayer())
        ]
        gm = GameMaster(test_layout, teams, 4, 1)
        gm.play()
Beispiel #50
0
    def test_stopping(self):
        test_layout = (""" ############
            #0#.23 .# 1#
            ############ """)

        round_counting = self.round_counting()
        team = [Team(stopping), Team(round_counting)]
        gm = GameMaster(test_layout, team, 4, 1)
        gm.play()
        assert gm.universe.bots[0].current_pos == (1, 1)
        assert gm.universe.bots[1].current_pos == (10, 1)
        assert round_counting._storage['rounds'] == 1

        round_counting = self.round_counting()
        team = [Team(stopping), Team(round_counting)]
        gm = GameMaster(test_layout, team, 4, 3)
        gm.play()
        assert gm.universe.bots[0].current_pos == (1, 1)
        assert gm.universe.bots[1].current_pos == (10, 1)
        assert round_counting._storage['rounds'] == 3
Beispiel #51
0
    def test_demo_players(self):
        test_layout = (""" ################
            #              #
            #              #
            #              #
            #   0      1   #
            #              #
            #              #
            #              #
            #.            .#
            ################ """)
        teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
        gm = GameMaster(test_layout, teams, 2, 5, seed=20)
        self.assertEqual(gm.universe.bots[0].current_pos, (4, 4))
        self.assertEqual(gm.universe.bots[1].current_pos, (4 + 7, 4))
        gm.play()

        pos_left_bot = gm.universe.bots[0].current_pos
        pos_right_bot = gm.universe.bots[1].current_pos

        # running again to test seed:
        teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
        gm = GameMaster(test_layout, teams, 2, 5, seed=20)
        gm.play()
        self.assertEqual(gm.universe.bots[0].current_pos, pos_left_bot)
        self.assertEqual(gm.universe.bots[1].current_pos, pos_right_bot)

        # running again with other seed:
        teams = [SimpleTeam(RandomPlayer()), SimpleTeam(RandomPlayer())]
        gm = GameMaster(test_layout, teams, 2, 5, seed=200)
        gm.play()
        # most probably, either the left bot or the right bot or both are at
        # a different position
        self.assertTrue(gm.universe.bots[0].current_pos != pos_left_bot
                        or gm.universe.bots[1].current_pos != pos_right_bot)
Beispiel #52
0
    def test_test_players(self):
        test_layout = (""" ############
            #0  .  .  1#
            #2        3#
            ############ """)
        movements_0 = [east, east]
        movements_1 = [west, west]
        teams = [
            SimpleTeam(TestPlayer(movements_0), TestPlayer(movements_0)),
            SimpleTeam(TestPlayer(movements_1), TestPlayer(movements_1))
        ]
        gm = GameMaster(test_layout, teams, 4, 2)

        self.assertEqual(gm.universe.bots[0].current_pos, (1, 1))
        self.assertEqual(gm.universe.bots[1].current_pos, (10, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (1, 2))
        self.assertEqual(gm.universe.bots[3].current_pos, (10, 2))

        gm.play()
        self.assertEqual(gm.universe.bots[0].current_pos, (3, 1))
        self.assertEqual(gm.universe.bots[1].current_pos, (8, 1))
        self.assertEqual(gm.universe.bots[2].current_pos, (3, 2))
        self.assertEqual(gm.universe.bots[3].current_pos, (8, 2))
Beispiel #53
0
#!/usr/bin/python
from pelita.game_master import GameMaster
from pelita.player import StoppingPlayer, SimpleTeam
from pelita.viewer import AsciiViewer
from players import RandomPlayer, NQRandomPlayer

if __name__ == '__main__':
    layout = (""" ##################
            #0#.  .  # .     #
            #2#####    #####1#
            #     . #  .  .#3#
            ################## """)
    gm = GameMaster(layout, 4, 200)
    gm.register_team(SimpleTeam(StoppingPlayer(), NQRandomPlayer()))
    gm.register_team(SimpleTeam(NQRandomPlayer(), NQRandomPlayer()))
    gm.register_viewer(AsciiViewer())
    gm.play()
    def test_game(self):

        test_start = (""" ######
                #0 . #
                #.. 1#
                ###### """)

        number_bots = 2

        # The problem here is that the layout does not allow us to specify a
        # different inital position and current position. When testing universe
        # equality by comparing its string representation, this does not matter.
        # But if we want to compare using the __eq__ method, but specify the
        # target as ascii encoded maze/layout we need to convert the layout to a
        # CTFUniverse and then modify the initial positions. For this we define
        # a closure here to quickly generate a target universe to compare to.
        # Also we adapt the score, in case food has been eaten

        def create_TestUniverse(layout, black_score=0, white_score=0):
            initial_pos = [(1, 1), (4, 2)]
            universe = CTFUniverse.create(layout, number_bots)
            universe.teams[0].score = black_score
            universe.teams[1].score = white_score
            for i, pos in enumerate(initial_pos):
                universe.bots[i].initial_pos = pos
            if not (1, 2) in universe.food_list:
                universe.teams[1].score += 1
            if not (2, 2) in universe.food_list:
                universe.teams[1].score += 1
            if not (3, 1) in universe.food_list:
                universe.teams[0].score += 1
            return universe

        teams = [
            SimpleTeam(TestPlayer('>-v>>>')),
            SimpleTeam(TestPlayer('<<-<<<'))
        ]
        gm = GameMaster(test_start, teams, number_bots, 200)

        gm.set_initial()
        gm.play_round()
        test_first_round = (""" ######
                # 0. #
                #..1 #
                ###### """)
        self.assertEqual(create_TestUniverse(test_first_round), gm.universe)

        gm.play_round()
        test_second_round = (""" ######
                # 0. #
                #.1  #
                ###### """)
        self.assertEqual(create_TestUniverse(test_second_round), gm.universe)

        gm.play_round()
        test_third_round = (""" ######
                #  . #
                #.0 1#
                ###### """)
        self.assertEqual(
            create_TestUniverse(test_third_round,
                                black_score=gm.universe.KILLPOINTS),
            gm.universe)

        gm.play_round()
        test_fourth_round = (""" ######
                #0 . #
                #. 1 #
                ###### """)
        self.assertEqual(
            create_TestUniverse(test_fourth_round,
                                black_score=gm.universe.KILLPOINTS,
                                white_score=gm.universe.KILLPOINTS),
            gm.universe)

        gm.play_round()
        test_fifth_round = (""" ######
                # 0. #
                #.1  #
                ###### """)
        self.assertEqual(
            create_TestUniverse(test_fifth_round,
                                black_score=gm.universe.KILLPOINTS,
                                white_score=gm.universe.KILLPOINTS),
            gm.universe)

        print(gm.universe.pretty)
        gm.play_round()
        test_sixth_round = (""" ######
                #  0 #
                #1   #
                ###### """)
        print(gm.universe.pretty)
        self.assertEqual(
            create_TestUniverse(test_sixth_round,
                                black_score=gm.universe.KILLPOINTS,
                                white_score=gm.universe.KILLPOINTS),
            gm.universe)

        teams = [
            SimpleTeam(TestPlayer('>-v>>>')),
            SimpleTeam(TestPlayer('<<-<<<'))
        ]
        # now play the full game
        gm = GameMaster(test_start, teams, number_bots, 200)
        gm.play()
        test_sixth_round = (""" ######
                #  0 #
                #1   #
                ###### """)
        self.assertEqual(
            create_TestUniverse(test_sixth_round,
                                black_score=gm.universe.KILLPOINTS,
                                white_score=gm.universe.KILLPOINTS),
            gm.universe)
Beispiel #55
0
    def test_remote_viewer_may_not_change_gm(self):
        free_obj = Free

        self.mean_viewer_did_run = False

        class MeanViewer(AbstractViewer):
            def set_initial(self, universe):
                universe.teams[1].score = 50

            def observe(self_, universe, game_state):
                self.mean_viewer_did_run = True

                universe.teams[0].score = 100
                universe.bots[0].current_pos = (4, 4)
                universe.maze[0, 0] = free_obj

                game_state["team_wins"] = 0

        test_start = (""" ######
                #0 . #
                #.. 1#
                ###### """)

        number_bots = 2

        gm = GameMaster(test_start, number_bots, 1)
        gm.register_team(SimpleTeam(TestPlayer([(0, 0)])))
        gm.register_team(SimpleTeam(TestPlayer([(0, 0)])))

        original_universe = gm.universe.copy()

        self.test_viewer_did_run = False
        test_self = self

        class TestViewer(AbstractViewer):
            def observe(self_, universe, game_state):
                self.test_viewer_did_run = True

                # universe should not have been altered
                test_self.assertEqual(original_universe, gm.universe)

                # there should only be a botmoves event
                test_self.assertEqual(len(game_state["bot_moved"]), 1)
                test_self.assertEqual(len(game_state["bot_moved"]), 1)

        # We need to be able to tell when our subscriber is able to receive
        # new events from the publisher.
        # Due to its completely asynchronous approach, zmq does not even
        # provide built-in methods to check whether two or more sockets
        # are connected, so we have to figure a way to find out.
        # The approach is as follows: When the publisher starts, it
        # sends only ‘sync’ messages without a pause.
        # When a subscriber is finally connected, it will receive this message and
        # set an instance variable (`has_sync`). The main thread checks whether
        # all variables of all subscribers have been set, will stop
        # sending ‘sync’ and move on.
        # No special thread synchronisation or locking is being used. The current
        # code is hopefully simple enough not to include any race conditions.

        class SyncedSubscriber(SimpleSubscriber):
            def sync(self):
                self.has_sync = True

        address = "ipc:///tmp/pelita-publisher-%s" % uuid.uuid4()
        mean_viewer = SyncedSubscriber(MeanViewer(), address)
        test_viewer = SyncedSubscriber(TestViewer(), address)

        # must be threads because we try to access shared state
        # in the mean_viewer_did_run variable
        # (and in a bad way)
        mean_viewer_thread = mean_viewer.autoplay_thread()
        test_viewer_thread = test_viewer.autoplay_thread()

        publisher_viewer = SimplePublisher(address)

        viewers = [mean_viewer, test_viewer]
        while not all(
                getattr(viewer, "has_sync", False) for viewer in viewers):
            publisher_viewer.socket.send_json({"__action__": "sync"})

        # now we can register it and game_master takes care of sending messages
        gm.register_viewer(publisher_viewer)

        gm.set_initial()
        gm.play()

        # exit our threads
        publisher_viewer.socket.send_json({
            "__action__": "exit",
            "__data__": {}
        })

        # wait until threads stop
        mean_viewer_thread.join()
        test_viewer_thread.join()
        # must close the socket and terminate the context
        # else we may get an assertion failure in zmq
        publisher_viewer.socket.close()
        publisher_viewer.context.term()

        self.assertEqual(original_universe, gm.universe)

        # check, that the code was actually executed
        self.assertTrue(self.mean_viewer_did_run)
        self.assertTrue(self.test_viewer_did_run)