第九章.迭代与测试

伟大软件三步骤：

1.确认你的软件做客户要它做的事

2.运用基本的OO原则来增加软件的灵活性

3.努力实现可维护、可重用的设计。

伟大软件的编写是迭代进行的，先针对整体轮廓操作，接着迭代应用程序的每个片段，直到完成。

有两种方法去迭代深入应用程序的特定部件（part）。必须处理较小的功能片段（piece of functionality）。

可以选择聚焦在应用程序的特定功能（feature）上。此方式完全关系到取出客户想要的一个功能片段，并且实现该功能，直到它完成。

功能驱动开发（Feature Driven Development）挑出应用程序的特定功能，并且规划、分析及开发该功能，直到完成。

也可以选择聚焦在通过应用程序的特定流程（flow）上。此方式取出通过应用程序的完整路径（具有清楚的开始与结束），并且在你的程序代码中实现该路径（path）

用例驱动开发（Use Case Driven Development）挑出通过用例的场景（scenario），并且编写程序代码支持通过该用例的完整场景。

两种迭代（iterating）方式皆由良好的需求（requirement）所驱动。因为需求源自客户，两种方式都是聚焦在交付客户要的东西上。

在使用功能开发时，一次做单一功能（feature）；接着迭代，一次解决一个功能，直到你完成应用程序的整个功能性（functionality）。

在用例驱动开发中，你操作通过用例的的单一场景，接着再取出另一个场景并且完成它，直到所有场景被完成。然后再迭代下一个用例，直到所有用力都能运作。

编写测试场景：

测试案例（test case）不必复杂，它们知识提供一个方式，向客户展示类里的功能正常运作。

应该为所有你能想到的可能的使用状况测试你的软件。要有想象力！

也别忘了测试软件不正确使用的状况。你将在早期捕捉住错误，让你的客户高兴。

测试驱动开发聚焦于让类的行为正确。

良好的软件是通过迭代造就而成。分析、设计、再一次迭代，一次一次完成应用程序更小更小的部分。

每当你迭代时，重新评估你的设计决策，假如它对你的设计合理，就别害怕改变。

游戏框架我们增加了Unit  UnitTester  UnitGroup，项目架构：

Board.java:

package headfirst.gsf.board;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import headfirst.gsf.unit.Unit;

public class Board {
    
    private int width, height;
    private List tiles;
    
    public Board(int width, int height){
        this.width = width;
        this.height = height;
        initialize();
    }
    
    private void initialize(){//定义成二维数组的矩形棋盘
        tiles = new ArrayList(width);
        for(int i = 0; i < width; i++){
            tiles.add(i, new ArrayList(height));
            for(int j = 0; j < height; j++){
                ((ArrayList) tiles.get(i)).add(j, new Tile());
            }
        }
    }
    
    public Tile getTile(int x, int y){
        return (Tile) ((ArrayList) tiles.get(x - 1)).get(y - 1);
    }
    
    public void addUnit(Unit unit, int x, int y){
        Tile tile = getTile(x, y);
        tile.addUnit(unit);
    }
    
    public void removeUnits(int x, int y){
        Tile tile = getTile(x, y);
        tile.removeUnits();
    }
    
    public List getUnits(int x, int y){
        return getTile(x, y).getUnits();
    }
}

Tile.java:

package headfirst.gsf.board;

import java.util.List;
import java.util.LinkedList;

import headfirst.gsf.unit.Unit;

public class Tile {
        
    private List units;

    public Tile(){
        units = new LinkedList();
    }
        
    protected void addUnit(Unit unit){
        units.add(unit);
    }
        
    protected void removeUnit(Unit unit){
        units.remove(unit);
    }
    
    protected void removeUnits(){
    }
    
    protected List getUnits(){
        return units;
    }
}

Unit.java:

package headfirst.gsf.unit;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class Unit {
    private String type;
    private int id;
    private String name;
    private List weapons;
    private Map properties;
    
    public Unit(int id){
        this.id = id;
    }
    
    public int getId(){
        return id;
    }
    
    //getName() and setName() methods
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    //getType() and setType() methods
    public void setType(String type){
        this.type = type;
    }
    
    public String getType(){
        return type;
    }
    
    public void addWeapon(List weapon){
        if(weapon == null){
            weapon = new LinkedList();
        }
        weapons.add(weapon);
    }
    
    public List getWeapons(){
        return weapons;
    }
    
    public void setProperty(String property, Object value){
        if(properties == null){
            properties = new HashMap();
        }
        properties.put(property, value);
    }
    
    public Object getProperty(String property){
        if(properties == null){
            return null;
        }
        
        return properties.get(property);
    }
}

UnitGroup.java:

package headfirst.gsf.unit;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class UnitGroup {
    private Map units;
    
    public UnitGroup(List unitList){
        units = new HashMap();
        for(Iterator i = unitList.iterator(); i.hasNext();){
            Unit unit = (Unit) i.next();
            units.put(unit.getId(), unit);
        }
    }
    
    public UnitGroup(){
        this(new LinkedList());
    }
    
    public void addUnit(Unit unit){
        units.put(unit.getId(), unit);
    }
    
    public void removeUnit(int id){
        units.remove(id);
    }
    
    public void removeUnit(Unit unit){
        removeUnit(unit.getId());
    }
    
    public Unit getUnit(int id){
        return (Unit) units.get(id);
    }
    
    public List getUnits(){
        List unitList = new LinkedList();
        for(Iterator i = units.entrySet().iterator(); i.hasNext();){
            Unit unit = (Unit) i.next();
            unitList.add(unit);
        }
        
        return unitList;
    }
}

UnitTester.java:

package headfirst.gsf.unit;

public class UnitTester {
    public void testType(Unit unit, String type, String expectedOutputType){
        System.out.println("
Testing setting/getting the type property.");
        unit.setType(type);
        String outputType = unit.getType();
        if(expectedOutputType.equals(outputType)){
            System.out.println("Test passed");
        }else{
            System.out.println("Test failed: " + outputType + " didn't match " + expectedOutputType);
        }
    }
    
    public void testUnitSpecificProperty(Unit unit, String propertyName, Object inputValue, Object expectedOutputValue){
        System.out.println("
Testing setting/getting a unit-specific property.");
        unit.setProperty(propertyName, inputValue);
        Object outputValue = unit.getProperty(propertyName);
        if(expectedOutputValue.equals(outputValue)){
            System.out.println("Test passed");
        }else{
            System.out.println(" Test failed: " + outputValue + " didn't match " + expectedOutputValue);
        }
    }
    
    public void testChangeProperty(Unit unit, String propertyName, Object inputValue, Object expectedOutputValue){
        System.out.println("
Testing changing an existing property's value.");
        unit.setProperty(propertyName,  inputValue);
        Object outputValue = unit.getProperty(propertyName);
        if(expectedOutputValue.equals(outputValue)){
            System.out.println("Test passed");
        }else{
            System.out.println("Test failed: " + outputValue + " didn't match " + expectedOutputValue);
        }
    }
    
    public void testNonExistentProperty(Unit unit, String propertyName){
        System.out.println("
Testing getting a non-existent property's value.");
        Object outputValue = unit.getProperty(propertyName);
        if(outputValue == null){
            System.out.println("Test passed");
        }else{
            System.out.println("Test failed with value of " + outputValue);
        }
    }
    
    public static void main(String args[]){
        UnitTester tester = new UnitTester();
        Unit unit = new Unit(1000);
        tester.testType(unit, "infantry", "infantry");
        tester.testUnitSpecificProperty(unit, "hitPoints", new Integer(25), new Integer(25));
        tester.testChangeProperty(unit, "hitPoints", new Integer(15), new Integer(15));
        tester.testNonExistentProperty(unit, "strength");
    }
}

编程契约（programming contract）：当你按契约编程（programming by contract）时，你与软件的用户正同意该软件以特定方式行动。

Unit的契约，假使使用它的人是能干的程序设计师，他们能处理返回值为null的情况，因此我们的契约是，当你请求不存在的特性或武器，你能处理null值。

若你不信任客户：

你可能将Unit类中getProperty()方法重写：

public Object getProperty(String property) throws IllegalAccessException{
        if(properties == null){
            throw new IllegalAccessException("What are you doing? No properties");
        }
        Object value = properties.get(property);
        if(value == null){
            throw new IllegalAccessException("You're screwing up! No property value.");
        }else{
            return value;
        }
    }

如果他们不信任你：

他们会保护他们的程序代码，并且使用防御性编程：

//Some method goes out and gets a unit
    Unit unit = getUnit();
    //Now let's use the unit...
    String name = unit.getName();
    if((name != null) && (name.length() > 0)){
        System.out.println("Unit name: " + name);
    }
    Object value = unit.getProperty("hitPoints");
    if(value != null){
        try{
            Integer hitPoints = (Integer) value;
        }catch(ClassCastException e){
            //Handle the potential error
        }
    }