TestMovements.test_does_end_on_own_piece() - Code Metrics - Inspection of "Catch errors found when integrating with the api" - theovoss/Chess - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 4422cd...d02956 )

by Theo

created 2016-05-29 19:30 UTC

TestMovements.test_does_end_on_own_piece() A

↳ Parent: TestMovements

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
cc	2
c	3
b	0
f	1
dl	0
loc	8
rs	9.4285

"""Chess Board unit test module."""

import unittest
from unittest.mock import Mock
from chess.movement import (distance_of_one,

                            doesnt_land_on_piece,
                            doesnt_land_on_own_piece,
                            cant_jump_pieces,
                            ends_on_enemy,
                            directional,
                            first_move,
                            get_all_potential_end_locations)
from chess.board.chess_board import ChessBoard


class TestMovements(unittest.TestCase):

    """Chess unit test class."""

    def setUp(self):
        self.chess_board = ChessBoard()

    def test_distance_of_one_filtering_given_positions(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        directions = [(1, 0), (0, 1), (0, -1)]
        start_square = (1, 1)
        already_acceptable_possitions = [(1, 2), (1, 0), (2, 1), (3, 3), (5, 5), (2, 3), (9, 1)]
        positions = distance_of_one(self.chess_board, start_square, directions, potential_end_locations=already_acceptable_possitions, player_direction=Mock())

        expected_positions = [(1, 2), (1, 0), (2, 1)]
        assert len(positions) == len(expected_positions)
        for pos in positions:
            assert pos in positions

    def test_does_end_on_own_piece(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (1, 1)
        end = (1, 0)
        self.chess_board[start] = Mock(color=1)
        self.chess_board[end] = Mock(color=1)
        potential_end_locations = [end]
        ret_val = doesnt_land_on_own_piece(self.chess_board, start, None, potential_end_locations, Mock())
        assert ret_val == []

    def test_doesnt_end_on_own_piece(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (1, 1)
        end = (1, 0)
        self.chess_board[start] = Mock(color=1)
        self.chess_board[end] = Mock(color=2)
        potential_end_locations = [end]
        ret_val = doesnt_land_on_own_piece(self.chess_board, start, None, potential_end_locations, Mock())
        assert ret_val == [(1, 0)]

    def test_cant_jump_pieces(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (2, 2)
        middle = (4, 2)

        self.chess_board[start] = Mock()
        self.chess_board[middle] = Mock()

        starting_end_locations = [(3, 2), (4, 2), (5, 2), (6, 2)]
        expected_positions = [(3, 2), (4, 2)]
        new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())

        assert new_end_locations == expected_positions

    def test_cant_jump_own_pieces(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (7, 2)
        middle = (4, 2)

        self.chess_board[start] = Mock(color=1)
        self.chess_board[middle] = Mock(color=1)
        self.chess_board[(6, 2)] = None
        self.chess_board[(5, 2)] = None

        starting_end_locations = [(3, 2), (4, 2), (6, 2)]
        expected_positions = [(4, 2), (6, 2)]
        new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())

        assert new_end_locations == expected_positions

    def test_cant_jump_own_pieces_diagonally(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 2)
        middle = (1, 1)

        self.chess_board[start] = Mock(color=1)
        self.chess_board[middle] = Mock(color=1)
        self.chess_board[(2, 0)] = None

        starting_end_locations = [(1, 1), (2, 0)]
        expected_positions = [(1, 1)]
        new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())

        assert new_end_locations == expected_positions

    def test_cant_jump_pieces_divide_by_one_error(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (2, 2)

        self.chess_board[start] = Mock()

        starting_end_locations = [(3, 2), (1, 2)]
        expected_positions = [(3, 2), (1, 2)]
        new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())

        assert new_end_locations == expected_positions

    def test_cant_jump_pieces_doesnt_limit_if_no_pieces_are_in_the_way(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (1, 1)

        self.chess_board[start] = Mock()

        starting_end_locations = [(2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1)]

        new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())

        assert new_end_locations == starting_end_locations


    def test_get_potential_end_squares_vertical(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        directions = [(0, 1)]
        ends = get_all_potential_end_locations(start, directions, self.chess_board)

        expected_ends = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7)]
        assert ends == expected_ends


    def test_get_potential_end_squares_horizontal(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        directions = [(1, 0)]
        ends = get_all_potential_end_locations(start, directions, self.chess_board)

        expected_ends = [(1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0)]
        assert ends == expected_ends

    def test_get_potential_end_squares_diagonal(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        directions = [(1, 1)]
        ends = get_all_potential_end_locations(start, directions, self.chess_board)

        expected_ends = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7)]
        assert ends == expected_ends

    def test_get_potential_end_squares_rook(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        directions = [(2, 1)]
        ends = get_all_potential_end_locations(start, directions, self.chess_board)

        expected_ends = [(2, 1), (4, 2), (6, 3)]
        assert ends == expected_ends

    def test_ends_on_enemy_no_enemy(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        potential_end_locations = [(1, 0), (2, 0), (2, 2)]
        ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
        assert ends == []

    def test_ends_on_same_players_piece(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        self.chess_board[start] = Mock(color=1)
        potential_end_locations = [(1, 0), (2, 0), (2, 2)]
        for end in potential_end_locations:
            self.chess_board[end] = Mock(color=1)
        ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
        assert ends == []

    def test_ends_on_enemy_players_piece(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (0, 0)
        self.chess_board[start] = Mock(color=1)
        potential_end_locations = [(1, 0), (2, 0), (2, 2)]
        end = None
        for end in potential_end_locations:
            self.chess_board[end] = Mock(color=1)
        self.chess_board[end] = Mock(color=2)
        ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
        assert ends == [(2, 2)]

    def test_doesnt_land_on_piece(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (1, 1)
        potential_end_locations = [(1, 2), (1, 3), (2, 4), (1, 4), (0, 2)]
        for end in potential_end_locations:
            self.chess_board[end] = Mock(color=2)
        potential_end_locations.append((2, 3))
        ends = doesnt_land_on_piece(self.chess_board, start, None, potential_end_locations, Mock())
        assert ends == [(2, 3)]

    def test_directional_white(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (3, 1)
        potential_end_locations = [(4, 1), (2, 1)]

        ends = directional(self.chess_board, start, None, potential_end_locations, (1, 0))
        assert ends == [(4, 1)]

    def test_directional_black(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (3, 1)
        potential_end_locations = [(4, 1), (2, 1)]

        ends = directional(self.chess_board, start, None, potential_end_locations, (-1, 0))
        assert ends == [(2, 1)]

    def test_directional_diagonal(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (3, 1)
        potential_end_locations = [(4, 2), (2, 2)]

        ends = directional(self.chess_board, start, None, potential_end_locations, (1, 1))
        assert ends == [(4, 2)]

    def test_first_move(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (3, 1)
        self.chess_board[start] = Mock(move_count=0)
        potential_end_locations = [(4, 2), (4, 3), (2, 2), (2, 1), (2, 2)]

        ends = first_move(self.chess_board, start, None, potential_end_locations, Mock())

        assert ends == potential_end_locations

    def test_not_first_move(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        start = (3, 1)
        self.chess_board[start] = Mock(move_count=1)
        potential_end_locations = [(4, 2), (4, 3), (2, 2), (2, 1), (2, 2)]

        ends = first_move(self.chess_board, start, None, potential_end_locations, Mock())

        assert ends == []


1		"""Chess Board unit test module."""
2
3		import unittest
4		from unittest.mock import Mock
5		from chess.movement import (distance_of_one,
		0 ignored issues – show Bug introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report The name `ends_on_enemy` does not seem to exist in module `chess.movement`. Loading history...
6		doesnt_land_on_piece,
7		doesnt_land_on_own_piece,
8		cant_jump_pieces,
9		ends_on_enemy,
10		directional,
11		first_move,
12		get_all_potential_end_locations)
13		from chess.board.chess_board import ChessBoard
14
15
16		class TestMovements(unittest.TestCase):
17
18		"""Chess unit test class."""
19
20		def setUp(self):
21		self.chess_board = ChessBoard()
22
23		def test_distance_of_one_filtering_given_positions(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
24		directions = [(1, 0), (0, 1), (0, -1)]
25		start_square = (1, 1)
26		already_acceptable_possitions = [(1, 2), (1, 0), (2, 1), (3, 3), (5, 5), (2, 3), (9, 1)]
27		positions = distance_of_one(self.chess_board, start_square, directions, potential_end_locations=already_acceptable_possitions, player_direction=Mock())
		0 ignored issues – show Coding Style introduced 2016-04-25 05:02 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (159/150). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
28		expected_positions = [(1, 2), (1, 0), (2, 1)]
29		assert len(positions) == len(expected_positions)
30		for pos in positions:
31		assert pos in positions
32
33		def test_does_end_on_own_piece(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
34		start = (1, 1)
35		end = (1, 0)
36		self.chess_board[start] = Mock(color=1)
37		self.chess_board[end] = Mock(color=1)
38		potential_end_locations = [end]
39		ret_val = doesnt_land_on_own_piece(self.chess_board, start, None, potential_end_locations, Mock())
40		assert ret_val == []
41
42		def test_doesnt_end_on_own_piece(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
43		start = (1, 1)
44		end = (1, 0)
45		self.chess_board[start] = Mock(color=1)
46		self.chess_board[end] = Mock(color=2)
47		potential_end_locations = [end]
48		ret_val = doesnt_land_on_own_piece(self.chess_board, start, None, potential_end_locations, Mock())
49		assert ret_val == [(1, 0)]
50
51		def test_cant_jump_pieces(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
52		start = (2, 2)
53		middle = (4, 2)
54
55		self.chess_board[start] = Mock()
56		self.chess_board[middle] = Mock()
57
58		starting_end_locations = [(3, 2), (4, 2), (5, 2), (6, 2)]
59		expected_positions = [(3, 2), (4, 2)]
60		new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())
61
62		assert new_end_locations == expected_positions
63
64		def test_cant_jump_own_pieces(self):
		0 ignored issues – show Coding Style introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
65		start = (7, 2)
66		middle = (4, 2)
67
68		self.chess_board[start] = Mock(color=1)
69		self.chess_board[middle] = Mock(color=1)
70		self.chess_board[(6, 2)] = None
71		self.chess_board[(5, 2)] = None
72
73		starting_end_locations = [(3, 2), (4, 2), (6, 2)]
74		expected_positions = [(4, 2), (6, 2)]
75		new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())
76
77		assert new_end_locations == expected_positions
78
79	View Code Duplication	def test_cant_jump_own_pieces_diagonally(self):
		0 ignored issues – show Duplication introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history... Coding Style introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
80		start = (0, 2)
81		middle = (1, 1)
82
83		self.chess_board[start] = Mock(color=1)
84		self.chess_board[middle] = Mock(color=1)
85		self.chess_board[(2, 0)] = None
86
87		starting_end_locations = [(1, 1), (2, 0)]
88		expected_positions = [(1, 1)]
89		new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())
90
91		assert new_end_locations == expected_positions
92
93		def test_cant_jump_pieces_divide_by_one_error(self):
		0 ignored issues – show Coding Style introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
94		start = (2, 2)
95
96		self.chess_board[start] = Mock()
97
98		starting_end_locations = [(3, 2), (1, 2)]
99		expected_positions = [(3, 2), (1, 2)]
100		new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())
101
102		assert new_end_locations == expected_positions
103
104		def test_cant_jump_pieces_doesnt_limit_if_no_pieces_are_in_the_way(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
105		start = (1, 1)
106
107		self.chess_board[start] = Mock()
108
109		starting_end_locations = [(2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1)]
110
111		new_end_locations = cant_jump_pieces(self.chess_board, start, None, starting_end_locations, Mock())
112
113	View Code Duplication	assert new_end_locations == starting_end_locations
		0 ignored issues – show Duplication introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
114
115		def test_get_potential_end_squares_vertical(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
116		start = (0, 0)
117		directions = [(0, 1)]
118		ends = get_all_potential_end_locations(start, directions, self.chess_board)
119
120		expected_ends = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7)]
121		assert ends == expected_ends
122	View Code Duplication
		0 ignored issues – show Duplication introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
123		def test_get_potential_end_squares_horizontal(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
124		start = (0, 0)
125		directions = [(1, 0)]
126		ends = get_all_potential_end_locations(start, directions, self.chess_board)
127
128		expected_ends = [(1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0)]
129		assert ends == expected_ends
130
131		def test_get_potential_end_squares_diagonal(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
132		start = (0, 0)
133		directions = [(1, 1)]
134		ends = get_all_potential_end_locations(start, directions, self.chess_board)
135
136		expected_ends = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7)]
137		assert ends == expected_ends
138
139		def test_get_potential_end_squares_rook(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
140		start = (0, 0)
141		directions = [(2, 1)]
142		ends = get_all_potential_end_locations(start, directions, self.chess_board)
143
144		expected_ends = [(2, 1), (4, 2), (6, 3)]
145		assert ends == expected_ends
146
147		def test_ends_on_enemy_no_enemy(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
148		start = (0, 0)
149		potential_end_locations = [(1, 0), (2, 0), (2, 2)]
150		ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
151		assert ends == []
152
153		def test_ends_on_same_players_piece(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
154		start = (0, 0)
155		self.chess_board[start] = Mock(color=1)
156		potential_end_locations = [(1, 0), (2, 0), (2, 2)]
157		for end in potential_end_locations:
158		self.chess_board[end] = Mock(color=1)
159		ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
160		assert ends == []
161
162	View Code Duplication	def test_ends_on_enemy_players_piece(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... Duplication introduced 2016-05-29 19:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
163		start = (0, 0)
164		self.chess_board[start] = Mock(color=1)
165		potential_end_locations = [(1, 0), (2, 0), (2, 2)]
166		end = None
167		for end in potential_end_locations:
168		self.chess_board[end] = Mock(color=1)
169		self.chess_board[end] = Mock(color=2)
170		ends = ends_on_enemy(self.chess_board, start, None, potential_end_locations, Mock())
171		assert ends == [(2, 2)]
172
173		def test_doesnt_land_on_piece(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
174		start = (1, 1)
175		potential_end_locations = [(1, 2), (1, 3), (2, 4), (1, 4), (0, 2)]
176		for end in potential_end_locations:
177		self.chess_board[end] = Mock(color=2)
178		potential_end_locations.append((2, 3))
179		ends = doesnt_land_on_piece(self.chess_board, start, None, potential_end_locations, Mock())
180		assert ends == [(2, 3)]
181
182		def test_directional_white(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
183		start = (3, 1)
184		potential_end_locations = [(4, 1), (2, 1)]
185
186		ends = directional(self.chess_board, start, None, potential_end_locations, (1, 0))
187		assert ends == [(4, 1)]
188
189		def test_directional_black(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
190		start = (3, 1)
191		potential_end_locations = [(4, 1), (2, 1)]
192
193		ends = directional(self.chess_board, start, None, potential_end_locations, (-1, 0))
194		assert ends == [(2, 1)]
195
196		def test_directional_diagonal(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
197		start = (3, 1)
198		potential_end_locations = [(4, 2), (2, 2)]
199
200		ends = directional(self.chess_board, start, None, potential_end_locations, (1, 1))
201		assert ends == [(4, 2)]
202
203		def test_first_move(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
204		start = (3, 1)
205		self.chess_board[start] = Mock(move_count=0)
206		potential_end_locations = [(4, 2), (4, 3), (2, 2), (2, 1), (2, 2)]
207
208		ends = first_move(self.chess_board, start, None, potential_end_locations, Mock())
209
210		assert ends == potential_end_locations
211
212		def test_not_first_move(self):
		0 ignored issues – show Coding Style introduced 2016-01-01 04:50 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
213		start = (3, 1)
214		self.chess_board[start] = Mock(move_count=1)
215		potential_end_locations = [(4, 2), (4, 3), (2, 2), (2, 1), (2, 2)]
216
217		ends = first_move(self.chess_board, start, None, potential_end_locations, Mock())
218
219		assert ends == []
220

theovoss / Chess

GitHub Access Token became invalid

Push — develop ( 4422cd...d02956 )

TestMovements.test_does_end_on_own_piece() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like