下面的测试用例我们很容易想到：
1. 1m = 1m
2. 1m = 100cm
3. 1m != 2m
4. 1m = 1000mm
接着我们就需要开始写测试代码了：
import org.junit.Test;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
public class LengthTest {
@Test
public void should_1_m_equals_1_m(){
Length length1 = new Length(1,"m");
Length length2 = new Length(1,"m");
assertThat(length1.equals(length2),is(true));
}
}
这时候编译是不通过的，因为我们就没有Length类，不过IDE能够很快的帮我们完成这件事儿，创建号Length类以后呢，跑测试，失败了。看来我们需要重写equals方法，为了让测试通过，我们可以先最简单的实现equals方法，代码如下：
public class Length {
private int value;
private String unit;
public Length(int value, String unit) {
this.value = value;
this.unit = unit;
}
@Override
public boolean equals(Object obj){
Length anotherLength = (Length) obj;
return (this.unit.equals(anotherLength.unit)&&this.value == anotherLength.value);
}
}
好，接下来我们继续第二个测试用例：
@Test
public void should_1m_equals_100_cm(){
Length length1 = new Length(1,"m");
Length length2 = new Length(100,"cm");
assertThat(length1.equals(length2),is(true));
}
跑测试，失败。继续改equals方法：
@Override
public boolean equals(Object obj){
Length anotherLength = (Length) obj;
if(anotherLength.unit.equals("cm")){
return this.value * 100 == anotherLength.value;
}
return (this.unit.equals(anotherLength.unit)&&this.value == anotherLength.value);
}
运行，成功，然后依次类推，将余下的测试按照刚才的模式写完：
package com.lee.oocamp.blog;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
public class LengthTest {
@Test
public void should_1_m_equals_1_m(){
Length length1 = new Length(1,"m");
Length length2 = new Length(1,"m");
assertThat(length1.equals(length2),is(true));
}
@Test
public void should_1_m_equals_100_cm(){
Length length1 = new Length(1,"m");
Length length2 = new Length(100,"cm");
assertThat(length1.equals(length2),is(true));
}
@Test
public void should_1_m_not_equal_2_m(){
Length length1 = new Length(1,"m");
Length length2 = new Length(2,"m");
assertThat(length1.equals(length2),is(false));
}
@Test
public void should_1_m_equals_1000_mm(){
Length length1 = new Length(1,"m");
Length length2 = new Length(1000,"mm");
assertThat(length1.equals(length2),is(true));
}
}
Length类中的equals方法代码：
@Override
public boolean equals(Object obj){
Length anotherLength = (Length) obj;
if(anotherLength.unit.equals("cm")){
return this.value * 100 == anotherLength.value;
}else if(anotherLength.unit.equals("mm")){
return this.value * 1000 == anotherLength.value;
}else{
return this.value*1 == anotherLength.value;
}
}
运行单元测试，全部通过。兴奋之余，似乎少了些什么？是的！1m=100cm正确，但是验证100cm=1m了么？1000mm = 1m 似乎也没有验证？继续添加测试用例：
@Test
public void should_1000_mm_equals_1_m(){
Length length1 = new Length(1000,"mm");
Length length2 = new Length(1,"m");
assertThat(length1.equals(length2),is(true));
}
@Test
public void should_100_cm_equals_1_m(){
Length length1 = new Length(100,"cm");
Length length2 = new Length(1,"m");
assertThat(length1.equals(length2),is(true));
}
运行，测试失败。为什么呢？因为我们只对this.value 做了从m向其他单位的转换，却并没有做从mm或cm向其他单位的转换。继续修改我们的实现代码，我们要让测试全部通过！
这时，我们想，我们既要由m向mm转换，又要由mm向m转换，为什么不在生成对象的时候就全部实现统一的转换呢？顺着这个思路我们可以继续往下走，由于有单元测试做保证，所以我们可以随意修改我们的实现。但是记着，改动不要太大，时刻记着运行单元测试，小步快跑是测试驱动开发的秘笈。
修改后Length代码如下：
public class Length {
private int value;
private String unit;
public Length(int value, String unit) {
this.value = getValue(unit,value);
this.unit = unit;
}
private int getValue(String unit, int value) {
int result = 0;
if(unit.equals("m")){
result = value * 1000;
}else if(unit.equals("cm")){
result = value * 10;
}else if(unit.equals("mm")){
result = value * 1;
}
return result;
}
@Override
public boolean equals(Object obj){
Length anotherLength = (Length) obj;
return this.value == anotherLength.value;
}
}
运行测试用例，全部通过！说明我们的测试是可行的，实现也是正确的。但是不和谐的因素出现了，在getValue中有太多的if-else 了！一个有良好设计风格的程序员肯定会想方设法的去消灭这些if-else。 好，我们继续重构（别忘了，我们有充分的单元测试做保证，因为我们的代码是由测试驱动出来的，只要测试通过了，代码就没问题，所以不要担心会把功能重构丢了。）getValue中的unit其实可以用枚举变量来代替，重构后代码清单如下：
Length类：
public class Length {
private int value;
private Length() {
}
public static Length createLength(int value, UNIT unit) {
Length length = new Length();
length.value = unit.getTheValue(value);
return length;
}
@Override
public boolean equals(Object obj){
boolean result = false;
Length anotherLength = (Length) obj;
result = this.value == anotherLength.value;
return result;
}
}
枚举UNIT：
public enum UNIT {
M(1000),CM(10),MM(1);
int radio;
UNIT(int radio){
this.radio = radio;
}
public int getTheValue(int value) {
int result = value * this.radio;
return result;
}
}
当然，由于构造器设置为了私有的，Length由简单对象工程来生成，我们也需要修改我们相应的单元测试用例。修改完成后我们发现测试类中也存在大量重复性代码，是时候对测试类进行重构了，重构后代码如下：
import org.junit.Test;
import com.lee.oocamp.Length;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
public class LengthTest {
@Test
public void should_1_m_equals_1_m(){
compareTwoLengthObj(1,UNIT.M,1,UNIT.M,true);
}
@Test
public void should_1_m_not_equal_2m(){
compareTwoLengthObj(1,UNIT.M,2,UNIT.M,false);
}
@Test
public void should_1_m_not_equal_1cm(){
compareTwoLengthObj(1,UNIT.M,1,UNIT.CM,false);
}
@Test
public void should_1_m_equals_100cm(){
compareTwoLengthObj(1, UNIT.M, 100, UNIT.CM ,true);
}
@Test
public void should_1_m_equals_1000mm(){
compareTwoLengthObj(1, UNIT.M, 1000, UNIT.MM ,true);
}
@Test
public void should_100_cm_equals_1m(){
compareTwoLengthObj(100, UNIT.CM, 1, UNIT.M ,true);
}
@Test
public void should_1000_mm_equals_1m(){
compareTwoLengthObj(1000, UNIT.MM, 1, UNIT.M ,true);
}
@Test
public void should_2000_mm_not_equals_1m(){
compareTwoLengthObj(2000, UNIT.MM, 1, UNIT.M ,false);
}
private void compareTwoLengthObj(int valueOfLength1,UNIT unitOfLength1,int valueOfLength2,UNIT unitOfLength2,boolean expect) {
Length length1 = Length.createLength(valueOfLength1,unitOfLength1);
Length length2 = Length.createLength(valueOfLength2,unitOfLength2);
assertThat(length1.equals(length2),is(expect));
}
}
即使又新加了几个测试用例，是不是看着也更清爽了呢？
end。