Last active
August 29, 2015 14:06
-
-
Save JamesJinPark/39586b3f0e8218db6786 to your computer and use it in GitHub Desktop.
Three_Musketeers_Test
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import unittest | |
| from three_musketeers import * | |
| left = 'left' | |
| right = 'right' | |
| up = 'up' | |
| down = 'down' | |
| M = 'M' | |
| R = 'R' | |
| _ = '-' | |
| class TestThreeMusketeers(unittest.TestCase): | |
| def setUp(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, _, R, M, _], | |
| [_, R, M, R, _], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ]) | |
| def test_create_board(self): | |
| create_board() | |
| self.assertEqual(at((0, 0)), 'R') | |
| self.assertEqual(at((0, 4)), 'M') | |
| def test_set_board(self): | |
| self.assertEqual(at((0, 0)), '-') | |
| self.assertEqual(at((1, 2)), 'R') | |
| self.assertEqual(at((1, 3)), 'M') | |
| def test_get_board(self): | |
| self.assertEqual([ [_, _, _, M, _], | |
| [_, _, R, M, _], | |
| [_, R, M, R, _], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ], | |
| get_board()) | |
| def test_string_to_location(self): | |
| self.assertEqual ((0, 4), string_to_location('A5')) | |
| self.assertEqual ((2, 2), string_to_location('C3')) | |
| self.assertEqual ((0, 0), string_to_location('A1')) | |
| self.assertNotEqual ((1, 1), string_to_location('E3')) | |
| def test_location_to_string(self): | |
| self.assertEqual ('A5', location_to_string((0, 4))) | |
| self.assertEqual ('C3', location_to_string((2, 2))) | |
| self.assertEqual ('A1', location_to_string((0, 0))) | |
| def test_at(self): | |
| self.assertEqual ('M', at((0, 3))) | |
| def test_all_locations(self): | |
| self.assertEqual([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)], all_locations()) | |
| self.assertNotEqual([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3)], all_locations()) | |
| def test_adjacent_location(self): | |
| self.assertEqual((1, 4), adjacent_location((1, 3),'right')) | |
| self.assertEqual((1, 2), adjacent_location((1, 3),'left')) | |
| self.assertEqual((0, 3), adjacent_location((1, 3),'up')) | |
| self.assertEqual((2, 3), adjacent_location((1, 3),'down')) | |
| self.assertNotEqual((1, 4), adjacent_location((1, 4),'right')) | |
| self.assertEqual((3, 3), adjacent_location((2, 3),'down')) | |
| def test_is_legal_move_by_musketeer(self): | |
| set_board([ [_, _, R, M, _], | |
| [_, R, _, M, _], | |
| [_, _, M, R, R], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ] ) | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'right')) | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'up')) | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'down')) | |
| self.assertTrue(is_legal_move_by_musketeer((0 ,3), 'left')) | |
| def test_is_legal_move_by_enemy(self): | |
| set_board([ [_, _, R, M, _], | |
| [_, R, _, M, _], | |
| [_, _, M, R, R], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ] ) | |
| self.assertFalse(is_legal_move_by_enemy((0, 2), 'right')) | |
| self.assertFalse(is_legal_move_by_enemy((0, 2), 'up')) | |
| self.assertTrue(is_legal_move_by_enemy((0, 2), 'down')) | |
| self.assertTrue(is_legal_move_by_enemy((0 ,2), 'left')) | |
| self.assertTrue(is_legal_move_by_enemy((1 ,1), 'left')) | |
| self.assertFalse(is_legal_move_by_enemy((2 ,3), 'right')) | |
| self.assertFalse(is_legal_move_by_enemy((2 ,3), 'left')) | |
| self.assertTrue(is_legal_move_by_enemy((2 ,3), 'down')) | |
| def test_is_legal_move(self): | |
| set_board([ [_, _, R, M, _], | |
| [_, R, _, M, _], | |
| [_, _, M, R, R], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ] ) | |
| #test_is_legal_move_by_musketeer(self) | |
| #test_is_legal_move_by_enemy(self) why don't these work? | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'right')) | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'up')) | |
| self.assertFalse(is_legal_move_by_musketeer((0, 3), 'down')) | |
| self.assertTrue(is_legal_move_by_musketeer((0 ,3), 'left')) | |
| self.assertFalse(is_legal_move_by_enemy((0, 2), 'right')) | |
| self.assertFalse(is_legal_move_by_enemy((0, 2), 'up')) | |
| self.assertTrue(is_legal_move_by_enemy((0, 2), 'down')) | |
| self.assertTrue(is_legal_move_by_enemy((0 ,2), 'left')) | |
| self.assertTrue(is_legal_move_by_enemy((1 ,1), 'left')) | |
| self.assertFalse(is_legal_move_by_enemy((2 ,3), 'right')) | |
| self.assertFalse(is_legal_move_by_enemy((2 ,3), 'left')) | |
| self.assertTrue(is_legal_move_by_enemy((2 ,3), 'down')) | |
| def test_has_some_legal_move_somewhere(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, R, _, M, _], | |
| [_, _, M, _, R], | |
| [_, R, _, _, _], | |
| [_, _, _, R, _] ] ) | |
| self.assertFalse(has_some_legal_move_somewhere('M')) | |
| self.assertTrue(has_some_legal_move_somewhere('R')) | |
| def test_possible_moves_from(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, R, _, M, _], | |
| [_, R, M, _, R], | |
| [_, R, _, R, _], | |
| [_, _, R, R, R] ] ) | |
| self.assertEqual(['left'], possible_moves_from((2, 2))) | |
| self.assertEqual(['left', 'right', 'down'], possible_moves_from((3, 1))) | |
| def test_can_move_piece_at(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, R, _, M, _], | |
| [_, _, M, _, R], | |
| [_, R, _, R, _], | |
| [_, _, R, R, R] ] ) | |
| self.assertFalse(can_move_piece_at((2, 2))) | |
| self.assertFalse(can_move_piece_at((0, 3))) | |
| self.assertFalse(can_move_piece_at((1, 3))) | |
| self.assertFalse(can_move_piece_at((4, 3))) | |
| self.assertTrue(can_move_piece_at((1, 1))) | |
| def test_is_legal_location(self): | |
| self.assertFalse(is_legal_location((-1, 2))) | |
| self.assertFalse(is_legal_location((0, -2))) | |
| self.assertFalse(is_legal_location((0, 5))) | |
| self.assertFalse(is_legal_location((5, 4))) | |
| def test_is_within_board(self): | |
| self.assertFalse(is_within_board((0, 0), 'left')) | |
| self.assertFalse(is_within_board((4, 0), 'left')) | |
| self.assertFalse(is_within_board((0, 4), 'right')) | |
| self.assertFalse(is_within_board((4, 4), 'right')) | |
| self.assertFalse(is_within_board((0, 2), 'up')) | |
| self.assertFalse(is_within_board((4, 3), 'down')) | |
| self.assertTrue(is_within_board((1, 3), 'down') ) | |
| def test_all_possible_moves_for(self): | |
| set_board([ [_, _, R, M, R], | |
| [_, _, _, M, M], | |
| [_, _, _, _, _], | |
| [_, _, _, _, _], | |
| [_, _, _, _, _] ] ) | |
| self.assertEqual((((0, 3), 'left'), ((0, 3), 'right')), ((1, 4), 'up')), all_possible_moves_for('M') | |
| self.assertEqual((((0, 2), 'left'), ((0, 2), 'down')), all_possible_moves_for('R')) | |
| def test_make_move(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, R, R, M, _], | |
| [_, _, M, _, R], | |
| [_, R, _, R, _], | |
| [_, _, R, R, R] ] ) | |
| self.assertEqual('M', make_move((1, 3), 'left')) | |
| self.assertEqual('R', make_move((3, 1), 'down')) | |
| def test_choose_computer_move(self): | |
| self.assertEqual( , choose_computer_move('M')) | |
| self.assertEqual( , choose_computer_move('R')) | |
| def test_is_enemy_win(self): | |
| set_board([ [_, _, _, M, _], | |
| [_, R, R, M, _], | |
| [_, _, M, _, R], | |
| [_, R, _, R, _], | |
| [_, _, R, R, R] ] ) | |
| self.assertFalse( , is_enemy_win()) | |
| self.assertFalse( , is_enemy_win()) | |
| self.assertFalse( , is_enemy_win()) | |
| self.assertFalse( , is_enemy_win()) | |
| self.assertTrue( , is_enemy_win()) | |
| unittest.main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment