永久更新地址:https://my.oschina.net/bysu/blog/1632393
写在前面:若有侵权,请发邮件by.su@qq.com告知。
本文主要是学习《Java测试驱动开发》过程中的记录,除了工具有点不一致之外,其他都是摘抄自书本。
转载者告知:如果本文被转载,但凡涉及到侵权相关事宜,转载者需负责。请知悉!
个人觉得这书相当不错,有兴趣的可以买来看看。
图书的相关链接:http://www.ituring.com.cn/book/1942
书中源码下载:https://download.csdn.net/download/gdzjsubaoya/10286870
工具:eclipse(书中用的是IntelliJ IDEA)+gradle+Junit,整个项目目录如下:
这个练习中,你将根据需求编写测试,再编写满足测试期望的代码。最后,如果有必要,将对代码进行重构。也就是书中所说的:“红灯-绿灯-重构”过程。
开发“开发井字游戏”
游戏规则:双方轮流在一个3X3的网格中画X和O,最先在水平、垂直或对角线上将自己的3个标记连起来的 玩家获胜。
需求1
我们应该首先定义边界,以及将棋子放在哪些地方非法。
可将棋子放在3X3棋盘上任何没有棋子的地方。
可将这个需求分成三个测试:
1.如果棋子放在超出了X轴边界的地方,就引发RuntimeException异常;
2.如果棋子放在超出了Y轴边界的地方,就引发RuntimeException异常;
3.如果棋子放在已经有棋子的地方,就引发RuntimeException异常;
编写第一个测试前,先简单说说如何使用JUNIT测试异常。JUnit4.7引入了一项名为规则(Rule)的功能,使用它可以做很多不同的事情,但在这里我们感兴趣的是规则Expected-Exception。
import org.junit.Test;
import org.junit.Rule;
import org.junit.rules.ExpectedException;
public class TicTacToeTest {
@Rule
public ExpectedException exception = ExpectedException.none();
private TicTacToe ticTacToe;
}
@Test
public void whenXOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5,2);
}
}
1.测试
首先检查棋子是否放在3X3棋盘的边界内:
棋子放在超出X轴边界的地方时,将引发RuntimenException异常。
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
public class TicTacToeTest {
@Rule
public ExpectedException exception = ExpectedException.none();
private TicTacToe ticTacToe;
@Before
public final void before(){
ticTacToe = new TicTacToe();
}
@Test public void whenXOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5,2);
}
}
这个测试中,我们指出调用方法ticTacToe.play(5,2)时,期望的结果是引发RuntimeException异常。这个测试既简短又容易,要让它通过应该也很容易:只需创建方法paly,并确保它在参数X小于1或大于3(棋盘是3X3的)时引发RuntimeException异常。你应运行这个测试3次:第一次运行时,它应该不能通过,因为此时还没有方法play;添加这个方法后,测试也应不能通过,因为它没有引发异常RuntimeException;第三次运行时应该通过,因为实现了与这个测试相关联的所有代码。
2.实现
明确什么情况下应引发异常后,实现代码编写起来应该很简单:
public class TicTacToe {
public String play(int x,int y){
if(x < 1 || x > 3){
throw new RuntimeException("X is outside board");
}
}
}
3.测试
这个测试与前一个测试几乎相同,但验证的是Y轴:
@Test public void whenYOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5,2);
}
4.实现
这个规范的实现几乎与前一个相同,只需在参数Y不在指定范围内时引发异常即可:
public class TicTacToe {
public String play(int x,int y){
if(x < 1 || x > 3){
throw new RuntimeException("X is outside board");
}else if(y < 1 || y >3){
throw new RuntimeException("Y is outside board");
}
}
}
为让最后一个测试通过,添加一条“检查参数Y是否在棋盘内”的else子句。
下面编写当前需求涉及的最后一个测试。
5.测试
确定棋子在棋盘边界内后,还需确保它放在未被别的棋子占据的地方:
棋子放在被别的棋子占据的地方时,将引发RuntimeException异常。
@Test
public void whenOccupiedThenRuntimeException() {
ticTacToe.play(2, 1);
exception.expect(RuntimeException.class);
ticTacToe.play(2, 1);
}
这就是最后一个测试。编写 实现后,即可认为第一个需求完成了。
6.实现
为实现最后一个测试,应将既有棋子的位置存储在一个数组中。每当玩家放置新棋子时,都应确认棋子放在未占用的位置,否则引发异常:
public class TicTacToe {
private Character[][] board = {{'\0','\0','\0'},{'\0','\0','\0'},{'\0','\0','\0'}};
public String play(int x,int y){
if(x < 1 || x > 3){
throw new RuntimeException("X is outside board");
}else if(y < 1 || y >3){
throw new RuntimeException("Y is outside board");
}
if(board[x -1][y - 1] != '\0'){
throw new RuntimeException("Box is occupied");
}else{
board[x - 1][y - 1] = 'X';
}
}
}
我们检查要放置棋子的位置是否被占用,如果未占用,就将相应数组元素的值从空('\0')改为被占用的(X)。注意,我们还没有记录棋子是谁(X还是O)的。
7.重构
这些代码虽然满足了测试指定的需求,但有点令人迷惑。如果有人阅读这些代码,会搞不清方法play的母的。应重构这个方法,将其中的代码放在多个方法中。重构后代码如下:
public String play(int x,int y){
checkAxis(x);
checkAxis(y);
setBox(x,y,lastPlayer);
}
private void checkAxis(int axis){
if(axis < 1 || axis > 3){
throw new RuntimeException("X is outside board!");
}
}
private void setBox(int x,int y,char lastPlayer){
if(board[x-1][y-1] != '\0'){
throw new RuntimeException("Box is occupied");
}else{
board[x-1][y-1] = 'X';
}
}
这个重构过程中,没有改变方法play的功能,其行为与以前完全相同,但代码的可读性更强了。由于我们有覆盖了所有功能的测试,因此不用害怕重构时犯错。只要确保所有测试都通过且重构时没有引入新行为,就可以放心大胆地修改代码。
需求1.完整的源码:
测试代码:
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
public class TicTacToeTest {
@Rule
public ExpectedException exception = ExpectedException.none();
private TicTacToe ticTacToe;
@Before
public final void before() {
ticTacToe = new TicTacToe();
}
@Test
public void whenXOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5, 2);
}
@Test
public void whenYOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(2, 5);
}
@Test
public void whenOccupiedThenRuntimeException() {
- ticTacToe.play(1, 1);
ticTacToe.play(2, 1);
exception.expect(RuntimeException.class);
ticTacToe.play(2, 1);
}
}
实现代码
public class TicTacToe {
private Character[][] board = {{null, null, null}, {null, null, null}, {null, null, null}};
public void play(int x, int y) {
if (x < 1 || x > 3) {
throw new RuntimeException("X is outside board");
} else if (y < 1 || y > 3) {
throw new RuntimeException("Y is outside board");
}
if (board[x - 1][y - 1] != null) {
throw new RuntimeException("Y is outside board");
throw new RuntimeException("Box is occupied");
} else {
board[x - 1][y - 1] = 'X';
}
}
}
需求2
现在处理轮到哪个玩家落子的问题。
需要提供一种途径,用于判断接下来该谁落子。
可将这个需求分成三个 测试:
1.玩家X先下;
2.如果上一次是X下的,接下来将轮到O下;
3.如果上一次是O下的,接下来将轮到X下。
到目前为止,我们还未使用过JUnit断言。要使用断言,需要导入org.junit.Assert类中的静态(static)方法:
import static org.junit.Assert.*;
Assert类中的方法都非常简单,它们大都以assert打头。例如,assertEquals对两个对象进行比较:assertNotEquals验证两个对象不同,而assertArrayEquals验证两个数组相同。这两个断言都有很多重载版本,因此几乎能够对任何类型的java对象进行比较。
在这里,我们需要比较两个字符,其中第一个是预期的字符,而第二个是方法nextPlayer返回的实际字符。
现在编写这些测试及其实现。
先编写测试,再编写实现代码
这样做的好处是:可 确保编写的代码是可测试的,且每行代码都有对应的测试。
通过先编写或修改测试,开发人员可在编写代码前专注于需求。这是与完成实现后再编写测试的主要差别所在。测试先行的另一个好处是,可避免原本应为质量保证的测试沦为质量检查。
1.测试
玩家X先下:
//X玩家先下
@Test public void givenFirstTurnWhenNextPlayerThenX(){
assertEquals('X', ticTacToe.nextPlayer());
}
应该是玩家X先下
这个测试应该是不言自明的:我们期望nextPlayer返回X。如果现在运行这个测试,将发现它都不能通过编辑,这是因为还没有方法player。我们的任务是编写方法nextPlayer,并确保它返回正确的值。
2.实现
其实根本不需要检查玩家X是否先下,因为就目前而言,只需让nextPlayer返回X就能让这个测试通过。后面的测试将要求我们修改这个方法的代码:
public char nextPlayer(){
return 'X';
}
3.测试
现在需要确保让玩家轮流下。玩家X下棋后,应轮到玩家O,然后再轮到玩家X,以此类推:
//X玩家下完,到O玩家下
@Test public void givenLastTurnWhenNextPlayerThenO(){
ticTacToe.play(1, 1);
assertEquals('O', ticTacToe.nextPlayer());
}
如果前一次是玩家X下的,接下来应轮到玩家O。
4.实现
为跟踪接下来该谁下,需要存储前一次下棋的玩家:
private char lastPlayer = '\0';
public String play(int x,int y){
checkAxis(x);
checkAxis(y);
setBox(x,y,lastPlayer);
lastPlayer = nextPlayer();
}
public char nextPlayer(){
if(lastPlayer == 'X'){
return 'O';
}
return 'X';
}
你很可能已经进入状态。测试很小且易于编写,有了足够的经验后,编写一个测试只需一分钟甚至几秒钟;而编写实现所需的时间也差不多,甚至更短。
5.测试
我们终于可以检查玩家O下后是不是轮到玩家X了。
如果前一次是玩家O下的,接下来应轮到玩家X下。
即使什么都不用做,这个测试也能通过。因此它毫无用处,应当删除。如果编写这个测试,将发现它存在报错问题:在没有修改实现的情况下就能通过。你可以自己试一试。编写测试后,如果它在没有编写任何实现代码时就能通过,应将其删除。
此时,测试的完整代码
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.junit.Assert.*;
public class TicTacToeSpec {
@Rule
public ExpectedException exception = ExpectedException.none();
private TicTacToe ticTacToe;
@Before
public final void before() {
ticTacToe = new TicTacToe();
}
@Test
public void whenXOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5, 2);
}
@Test
public void whenYOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(2, 5);
}
@Test
public void whenOccupiedThenRuntimeException() {
ticTacToe.play(1, 1);
ticTacToe.play(2, 1);
exception.expect(RuntimeException.class);
ticTacToe.play(2, 1);
}
@Test
public void givenFirstTurnWhenNextPlayerThenX() {
assertEquals('X', ticTacToe.nextPlayer());
}
@Test
public void givenLastTurnWasXWhenNextPlayerThenO() {
ticTacToe.play(1, 1);
assertEquals('O', ticTacToe.nextPlayer());
}
}
需求3
现在考虑这个游戏的获胜规则。相比于前面的代码,这部分工作更繁琐。我们必须检查所有可能获胜的情况,只要满足其中一个,就宣布相应玩家获胜。
最先在水平、垂直或对角线上将自己的3个标记连起来的玩家获胜。
要检查同一玩家的3颗棋子是否连成了线,需要检查水平方向、垂直方向和对角线。
1.测试
下面首先定义方法play的默认返回值:
@Test
public void whenPlayThenNoWinner() {
String actual = ticTacToe.play(1, 1);
assertEquals("No winner", actual);
}
如果不满足获胜条件,则无人获胜。
2.实现
默认返回值总是最容易实现的,这里也不例外:
public String play(int x, int y) {
checkAxis(x);
checkAxis(y);
setBox(x, y, lastPlayer);
lastPlayer = nextPlayer();
return "No winner";
}
3.测试
指定默认结果(没有人获胜)后,处理各种获胜条件:
@Test
public void whenPlayAndWholeHorizontalLineThenWinner() {
ticTacToe.play(1, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 1); // X
ticTacToe.play(2, 2); // O
String actual = ticTacToe.play(3, 1); // X
assertEquals("X is the winner", actual);
}
一个玩家的棋子占据整条水平线就赢了。
4.实现
为让这个测试通过,需要检查是否有水平线全被当前玩家的棋子占据。到目前为止,我们根本不关心存储到数组board中的值是什么,但现在不但要记录哪些棋盘格是空的,还需记录各个棋盘格被哪个玩家占据:
public String play(int x, int y) {
checkAxis(x);
checkAxis(y);
lastPlayer = nextPlayer();
setBox(x, y, lastPlayer);
for(int index = 0;index < 3;index++){
if(board[0][index] == lastPlayer && board[1][index] == lastPlayer && board[2][index] == lastPlayer){
return lastPlayer + " is the winner";
}
}
return "No winner";
}
private void setBox(int x, int y, char lastPlayer) {
if (board[x - 1][y - 1] != '\0') {
throw new RuntimeException("Box is occupied");
} else {
board[x - 1][y - 1] = lastPlayer;
}
}
5.重构
前面的代码能够让测试通过,完成了尽快让测试通过的使命,但并非没有改进的空间。现在我们有了确保预期行为完整性的测试,可对代码进行重构:
private static final int SIZE = 3;
public String play(int x, int y) {
checkAxis(x);
checkAxis(y);
lastPlayer = nextPlayer();
setBox(x, y, lastPlayer);
if (isWin()) {
return lastPlayer + " is the winner";
}
return "No winner";
}
private boolean isWin() {
for (int i = 0; i < SIZE; i++) {
if ((board[0][i] + board[1][i] + board[2][i]) == (lastPlayer * SIZE)) {
return true;
}
}
return false;
}
重构后的解决方案看起来更好。play依然很短,很容易理解。将实现获胜逻辑的代码移到一个独立的方法中,不仅让方法play的目的变得清晰,还能让我们独立添加检查获胜条件的代码。
6.测试
我们还需检查是否有垂直线完全被某个玩家占据:
@Test
public void whenPlayAndWholeVerticalLineThenWinner() {
ticTacToe.play(2, 1); // X
ticTacToe.play(1, 1); // O
ticTacToe.play(3, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 2); // X
String actual = ticTacToe.play(1, 3); // O
assertEquals("O is the winner", actual);
}
一个玩家的棋子占据整条垂直线就赢了。
7.实现
这个实现应该与前一个类似。前面在水平方向上做了检查,现在需要在垂直方向上做同样的检查:
private boolean isWin() {
int playerTotal = lastPlayer * SIZE;
for (int i = 0; i < SIZE; i++) {
if ((board[0][i] + board[1][i] + board[2][i]) == playerTotal) {
return true;
} else if ((board[i][0] + board[i][1] + board[i][2]) == playerTotal) {
return true;
}
}
return false;
}
8.测试
水平线和垂直线都处理后,该将注意力转向对角线了:
@Test
public void whenPlayAndTopBottomDiagonalLineThenWinner() {
ticTacToe.play(1, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 2); // X
ticTacToe.play(1, 3); // O
String actual = ticTacToe.play(3, 3); // O
assertEquals("X is the winner", actual);
}
一个玩家的棋子占据从左上角到右下角的整条对角线就赢了。
9.实现
private boolean isWin() {
int playerTotal = lastPlayer * 3;
for (int i = 0; i < SIZE; i++) {
if ((board[0][i] + board[1][i] + board[2][i]) == playerTotal) {
return true;
} else if ((board[i][0] + board[i][1] + board[i][2]) == playerTotal) {
return true;
}
}
if (board[0][0] + board[1][1] + board[2][2] == playerTotal) {
return true;
}
return false;
}
10.测试
最后,还有最后一个可能的获胜条件需要处理:
@Test
public void whenPlayAndBottomTopDiagonalLineThenWinner() {
ticTacToe.play(1, 3); // X
ticTacToe.play(1, 1); // O
ticTacToe.play(2, 2); // X
ticTacToe.play(1, 2); // O
String actual = ticTacToe.play(3, 1); // O
assertEquals("X is the winner", actual);
}
一个玩家的棋子占据从左下角到右上角的整条对角线就赢了。
11.实现
这个测试的实现应该与前一个几乎完全相同:
private boolean isWin() {
int playerTotal = lastPlayer * 3;
for (int i = 0; i < SIZE; i++) {
if ((board[0][i] + board[1][i] + board[2][i]) == playerTotal) {
return true;
} else if ((board[i][0] + board[i][1] + board[i][2]) == playerTotal) {
return true;
}
}
if (board[0][0] + board[1][1] + board[2][2] == playerTotal) {
return true;
}else if (board[0][2] + board[1][1] + board[2][0] == playerTotal) {
return true;
}
return false;
}
12.重构
处理对角线时,所做的计算看起来不太好,也许重用既有的循环更合适:
private boolean isWin(){
int playerTotal = lastPlayer * 3;
char diagonal1 = '\0';
char diagonal2 = '\0';
for(int index=0;index<SIZE;index ++){
diagonal1 += board[index][index];//从左上到右下的对角线
diagonal2 += board[index][SIZE-index-1];//从右下到左上的对角线
if(board[0][index] + board[1][index] + board[2][index] == playerTotal){//水平线,赢
return true;
}else if(board[index][0] + board[index][1] + board[index][2] == playerTotal){//垂直线,赢
return true;
}
if(diagonal1 == playerTotal || diagonal2 == playerTotal){//两条对角线
return true;
}
}
return false;
}
下面处理最后一个需求。
需求4
现在缺失的唯一一项内容是如何处理平局。
所有格子都占满则为平局。
1.测试
可以通过填满棋盘的所有格子测试平局结果:
//平局,棋盘被占满
@Test
public void whenAllBoxesAreFilledThenDraw(){
ticTacToe.play(1, 1);
ticTacToe.play(1, 2);
ticTacToe.play(1, 3);
ticTacToe.play(2, 1);
ticTacToe.play(2, 3);
ticTacToe.play(2, 2);
ticTacToe.play(3, 1);
ticTacToe.play(3, 3);
String actual = ticTacToe.play(3, 2);
assertEquals("The result is draw", actual);
}
2.实现
检查是否为平局非常简单——只需检查是否已占满整个棋盘。为此,可遍历数组board:
public String play(int x,int y){
checkAxis(x);
checkAxis(y);
lastPlayer = nextPlayer();
setBox(x,y,lastPlayer);
if(isWin()){
return lastPlayer + " is the winner";
}else if(isDraw()){
return "The result is draw";
}else{
return "No winner";
}
}
private boolean isDraw(){
for(int x=0;x<SIZE;x++){
for(int y=0;y<SIZE;y++){
if(board[x][y] == '\0'){
return false;
}
}
}
return true;
}
3.重构
private boolean isWin(int x,int y){
int playerTotal = lastPlayer * SIZE;
char horizontal='\0',vertical='\0',diagonal1='\0',diagonal2 = '\0';
for(int index=0;index<SIZE;index ++){
horizontal += board[index][y-1];
vertical += board[x-1][index];
diagonal1 += board[index][index];//从左上到右下的对角线
diagonal2 += board[index][SIZE-index-1];//从右下到左上的对角线
if(horizontal == playerTotal || vertical == playerTotal || diagonal1 == playerTotal || diagonal2 == playerTotal){//两条对角线
return true;
}
}
return false;
}
//调用时isWin函数需要传对应的参数
public String play(int x,int y){
checkAxis(x);
checkAxis(y);
lastPlayer = nextPlayer();
setBox(x,y,lastPlayer);
if(isWin(x,y)){
return lastPlayer + " is the winner";
}else if(isDraw()){
return "The result is draw";
}else{
return "No winner";
}
}
Git仓库中的源码:https://bitbucket.org/vfarcic/tdd-java-ch03-tic-tac-toe/branch/04-draw
或下面源码
测试源码
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static org.junit.Assert.*;
public class TicTacToeTest{
@Rule
public ExpectedException exception = ExpectedException.none();
private TicTacToe ticTacToe;
@Before
public final void before() {
ticTacToe = new TicTacToe();
}
@Test
public void whenXOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(5, 2);
}
@Test
public void whenYOutsideBoardThenRuntimeException() {
exception.expect(RuntimeException.class);
ticTacToe.play(2, 5);
}
@Test
public void whenOccupiedThenRuntimeException() {
ticTacToe.play(2, 1);
exception.expect(RuntimeException.class);
ticTacToe.play(2, 1);
}
@Test
public void givenFirstTurnWhenNextPlayerThenX() {
assertEquals('X', ticTacToe.nextPlayer());
}
@Test
public void givenLastTurnWasXWhenNextPlayerThenO() {
ticTacToe.play(1, 1);
assertEquals('O', ticTacToe.nextPlayer());
}
@Test
public void whenPlayThenNoWinner() {
String actual = ticTacToe.play(1, 1);
assertEquals("No winner", actual);
}
@Test
public void whenPlayAndWholeHorizontalLineThenWinner() {
ticTacToe.play(1, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 1); // X
ticTacToe.play(2, 2); // O
String actual = ticTacToe.play(3, 1); // X
assertEquals("X is the winner", actual);
}
@Test
public void whenPlayAndWholeVerticalLineThenWinner() {
ticTacToe.play(2, 1); // X
ticTacToe.play(1, 1); // O
ticTacToe.play(3, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 2); // X
String actual = ticTacToe.play(1, 3); // O
assertEquals("O is the winner", actual);
}
@Test
public void whenPlayAndTopBottomDiagonalLineThenWinner() {
ticTacToe.play(1, 1); // X
ticTacToe.play(1, 2); // O
ticTacToe.play(2, 2); // X
ticTacToe.play(1, 3); // O
String actual = ticTacToe.play(3, 3); // O
assertEquals("X is the winner", actual);
}
@Test
public void whenPlayAndBottomTopDiagonalLineThenWinner() {
ticTacToe.play(1, 3); // X
ticTacToe.play(1, 1); // O
ticTacToe.play(2, 2); // X
ticTacToe.play(1, 2); // O
String actual = ticTacToe.play(3, 1); // O
assertEquals("X is the winner", actual);
}
@Test
public void whenAllBoxesAreFilledThenDraw() {
ticTacToe.play(1, 1);
ticTacToe.play(1, 2);
ticTacToe.play(1, 3);
ticTacToe.play(2, 1);
ticTacToe.play(2, 3);
ticTacToe.play(2, 2);
ticTacToe.play(3, 1);
ticTacToe.play(3, 3);
String actual = ticTacToe.play(3, 2);
assertEquals("The result is draw", actual);
}
}
实现源码:
public class TicTacToe {
private Character[][] board = {{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}};
private char lastPlayer = '\0';
private static final int SIZE = 3;
public String play(int x, int y) {
checkAxis(x);
checkAxis(y);
lastPlayer = nextPlayer();
setBox(x, y, lastPlayer);
if (isWin(x, y)) {
return lastPlayer + " is the winner";
} else if (isDraw()) {
return "The result is draw";
} else {
return "No winner";
}
}
public char nextPlayer() {
if (lastPlayer == 'X') {
return 'O';
}
return 'X';
}
private void checkAxis(int axis) {
if (axis < 1 || axis > SIZE) {
throw new RuntimeException("X is outside board");
}
}
private void setBox(int x, int y, char lastPlayer) {
if (board[x - 1][y - 1] != '\0') {
throw new RuntimeException("Box is occupied");
} else {
board[x - 1][y - 1] = lastPlayer;
}
}
private boolean isWin(int x, int y) {
int playerTotal = lastPlayer * SIZE;
char horizontal, vertical, diagonal1, diagonal2;
horizontal = vertical = diagonal1 = diagonal2 = '\0';
for (int i = 0; i < SIZE; i++) {
horizontal += board[i][y - 1];
vertical += board[x - 1][i];
diagonal1 += board[i][i];
diagonal2 += board[i][SIZE - i - 1];
}
if (horizontal == playerTotal
|| vertical == playerTotal
|| diagonal1 == playerTotal
|| diagonal2 == playerTotal) {
return true;
}
return false;
}
private boolean isDraw() {
for (int x = 0; x < SIZE; x++) {
for (int y = 0; y < SIZE; y++) {
if (board[x][y] == '\0') {
return false;
}
}
}
return true;
}
}
代码覆盖率
如果需要结合JaCoCo,参考我另一篇博文,不过跟本博文中抄录的书籍无关。书中也说了JaCoCo的使用,感兴趣的可以找来阅读。
《在eclipse中使用jacoco插件对测试覆盖进行监控》
小结
我们使用“红灯-绿灯-重构”流程完成了“井字游戏”,这些示例本身都很简单,易于理解。
本章并非要深入探讨复杂的东西,而是要让你养成反复使用“红灯-绿灯-重构”流程的习惯。
你学习了如下内容:开发软件的最简单方式就是将其分成小块;设计方案脱胎于测试,而不是预先采用复杂的方法进行制定;先编写测试并确定未通过后,在着手编写实现代码;确定最后一个测试未通过后,就能肯定它是有效的(你一不小心就会犯错,编写总是能够通过的测试),要实现的功能还不存在;测试未通过后,编写其实现代码;编写实现时,力图使其尽可能简单,只要能让测试通过就行,而不试图提供完美的解决方案;不断重复这个过程,直到认为需要对代码进行重构为止;重构时不能引入任何新功能(即不改变应用程序的行为),而只是对代码进行改进,使其更容易理解和维护。