-
Notifications
You must be signed in to change notification settings - Fork 0
/
TestBoard.py
234 lines (198 loc) · 7.55 KB
/
TestBoard.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
"""
CS5001, Spring 2023
Final Project, 2048 Game
Seunghan, Lee
This program includes TestBoard class which implement PyUnit.
"""
import unittest
from board import *
class TestBoard(unittest.TestCase):
"""
This class contains test cases for the features of the
Board class.
"""
board_one = Board(4)
def test_create_matrix(self):
'''
Test create_matrix method in the Board class.
'''
new_board = Board(4)
expected_matrix = [[None, None, None, None], [None, None, None, None],\
[None, None, None, None], [None, None, None, None]]
actual_matrix = new_board.get_matrix()
self.assertEqual(expected_matrix, actual_matrix)
def test_generate(self):
'''
TODO: how should I test randomly generated ones
Test generate method in the Board class.
'''
self.board_one.set_matrix([[1, 1, 1, 1], [1, 1, 1, None],\
[1, 1, 1, 1], [1, 1, 1, 1]])
self.board_one.generate()
expected = [2, 4]
actual = self.board_one.get_matrix()[1][3]
self.assertTrue(actual in expected)
def test_rotate_n(self):
'''
Test rotate_n method in the Board class.
'''
before_rotate = [[1, 2, 3, 4], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
self.board_one.set_matrix(before_rotate)
self.board_one.rotate_n(2)
expected_matrix = [[16, 15, 14, 13], [12, 11, 10, 9],\
[8, 7, 6, 5], [4, 3, 2, 1]]
actual_matrix = self.board_one.get_matrix()
self.assertEqual(expected_matrix, actual_matrix)
def test_swipe(self):
'''
Test swipe method in the Board class.
'''
# Expected and Actual values
matrix_before = [[4, 4, 4, 4], [None, None, 2, 2],\
[None, 2, 2, 2], [2, 4, 8, 16]]
expected_matrix = [[None, None, 8, 8], [None, None, None, 4],\
[None, None, 2, 4], [2, 4, 8, 16]]
expected_score = 24
# Set board
board = self.board_one
board.set_matrix(matrix_before)
curr_score = board.get_score()
# Call swipe function to the board
board.swipe()
# Get Actual values
actual_matrix = board.get_matrix()
actual_score = board.get_score() - curr_score
# Test whether expected and actual are equal
self.assertEqual(expected_score, actual_score)
self.assertEqual(expected_matrix, actual_matrix)
def test_update(self):
'''
Test update method in the Board class.
'''
# Test swiping up - input for the rotation is 1
matrix_before = [[4, 4, 8, None], [None, None, 4, 4],\
[4, 4, 4, 16], [8, 8, 8, 16]]
expected_matrix = [[8, 8, 8, 4], [8, 8, 8, 32],\
[None, None, 8, None], [None, None, None, None]]
expected_score = 56
# Set board
board = self.board_one
board.set_matrix(matrix_before)
curr_score = board.get_score()
# Call update function to the board
board.update(1) # for up swipe, initial rotatation is 1
# Get the actual values
actual_matrix = board.get_matrix()
actual_score = board.get_score() - curr_score
# Compare expected and actual
self.assertEqual(expected_matrix, actual_matrix)
self.assertEqual(expected_score, actual_score)
def test_can_generate(self):
'''
Test can_generate method in the Board class.
'''
# Test full matrix
matrix_one = [[1, 2, 3, 4], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
self.board_one.set_matrix(matrix_one)
self.assertFalse(self.board_one.can_generate())
# Text matrix that is not full
matrix_two = [[1, 2, 3, None], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
self.board_one.set_matrix(matrix_two)
self.assertTrue(self.board_one.can_generate())
def test_can_swipe(self):
'''
Test can_swipe method in the Board class.
'''
# Test when the player can swipe
matrix_can = [[4, 4, 8, None], [None, None, 4, 4],\
[4, 4, 4, 16], [8, 8, 8, 16]]
board = self.board_one
board.set_matrix(matrix_can)
self.assertTrue(board.can_swipe())
# Test when the player cannot swipe
matrix_cannot = [[1, 2, 3, 4], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
board.set_matrix(matrix_cannot)
self.assertFalse(board.can_swipe())
def reset(self):
'''
Test reset method in the Board class.
'''
# Resets the Board class
board = self.board_one
board.reset()
# Expected values
expected_score = 0
expected_matrix = [[None, None, None, None], [None, None, None, None],\
[None, None, None, None], [None, None, None, None]]
# Actual values
actual_score = board.get_score()
actual_matrix = board.get_matrix()
# Compare expected and the actual value
self.assertEqual(expected_matrix, actual_matrix)
self.assertEqual(expected_score, actual_score)
def test_set_matrix(self):
'''
Test set_matrix method in the Board class.
'''
new_matrix = [[1, 2, 3, 4], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
self.board_one.set_matrix(new_matrix)
actual = self.board_one.get_matrix()
self.assertEqual(new_matrix, actual)
def test_set_status(self):
'''
Test set_status method in the Board class.
'''
new_status = "Lets get an internship this summer"
self.board_one.set_status(new_status)
actual = self.board_one.get_status()
self.assertEqual(new_status, actual)
def test_add_score(self):
'''
Test add_score method in the Board class.
'''
curr_score = self.board_one.get_score()
self.board_one.add_score(4)
expected_score = curr_score + 4
actual_score = self.board_one.get_score()
self.assertEqual(expected_score, actual_score)
def test_get_size(self):
'''
Test get_size method in the Board class.
'''
expected = 4
actual = self.board_one.get_size()
self.assertEqual(expected, actual)
def test_get_matrix(self):
'''
Test get_matrix method in the Board class.
'''
new_matrix = [[1, 2, 3, 4], [5, 6, 7, 8],\
[9, 10, 11, 12], [13, 14, 15, 16]]
self.board_one.set_matrix(new_matrix)
expected = new_matrix
actual = self.board_one.get_matrix()
self.assertEqual(expected, actual)
def test_get_score(self):
'''
Test get_score method in the Board class.
'''
curr_score = self.board_one.get_score()
self.board_one.add_score(1)
new_score = self.board_one.get_score()
self.assertEqual(1, new_score - curr_score)
def test_get_status(self):
'''
Test get_status method in the Board class.
'''
expected = "Boring"
self.board_one.set_status(expected)
actual = self.board_one.get_status()
self.assertEqual(expected, actual)
if __name__ == '__main__':
# begin the unittest.main()
unittest.main()