测试驱动开发（TDD）

最新推荐文章于 2024-07-02 09:07:06 发布

weixin_30456039

最新推荐文章于 2024-07-02 09:07:06 发布

阅读量745

点赞数 2

文章标签：测试 java c/c++

原文链接：http://www.cnblogs.com/happyzm/p/7468975.html

版权

测试驱动开发的基本概念

为什么会出现测试驱动开发
- 当有一个新的任务时，往往第一个念头就是如何去实现它呢？
- 拿到任务就开始编码，一边写，变修改和设计
- 我已经调试了好几遍，应该不会有问题了，好了，先休息一下吧
- 测试是QA的事，我为什么要做啊，我做了，他们做什么？
- 奇怪了，怎么代码跟开发文档有这么大的区别啊？
- 开发部在搞什么啊，怎么代码有这么多的BUG？
- 这段代码想干嘛？
- ……
什么是测试驱动
- 测试驱动是一种开发形式：
  - 首先要编写测试代码
  - 除非存在相关测试，否则不编写任何的产品代码
  - 由测试来决定需要写什么样的代码
  - 要求维护一套详细的测试集
目标
- 代码整洁可用
  - 只有测试失败时，我们才写代码
  - 消除重复设计，优化设计结构

测试驱动开发的流程

Test-Driven Design（TDD）

是一种开发风格，它要求程序员做到：

在写产品代码之前，先写它的单元测试（Unit Tests）
没有单元测试的Class不运行作为产品代码
单元测试用例决定了如何写产品代码
不断地成功运行所有的单元测试用例
不断地完善单元测试用例

Test-Driven Design是把需求分析，设计，质量控制量化的过程！

如何做Test-Driven Design and Development

在开发一个新功能之前：

首先确定“做什么”（不是要如何做！）
- 例如，一个网站的增加用户的功能，我们需要一个方法来增加一个用户：
  - public void addUser(User user)
  - 功能包括：增加一个用户（在数据库中插入一条记录）；如果已经有相同的用户，应该返回一个用户已存在的消息
然后为这个功能写单元测试例子（Unit Test）
- 单元测试用例要覆盖这个Method的“做什么”
- 所以我们至少要有两个测试用例：
  - Test Case1：测试成功增加一个用户
  - Test Case 2：测试增加一个已存在的用户
  - 其它边缘情况测试：Test Case 3：传入的User对象为NULL
写生成（Production）代码
- 我们清楚地知道这段代码需要做什么，清晰的表明这段代码的Contracts。
- 只需要能实现在Unit Test中的Contracts和能够通过它的Unit Test
运行Unit Test
- 如果顺利通过，你已经很好的完成了你的任务
- 如果没通过，修补代码直到能通过Unit Test为止
- 如果出现在Unit Test中没预先设定的结果，在Unit Test中增加一个Test Case，修补代码直到通过所有的Test Case为止。

TDD 和 PSP

Personal Software Process的development

Test-Driven Design and Development

什么时候写Tests？

如果你要写一个新的功能，请先写它的测试用例
如果你要在没有经过测试的代码上写新的功能，请先写目前代码的测试用例
如果你要Fix一个Bug，请先为这个Bug写一个测试用例
如果你要Refactor没有测试过的代码，请先写一个测试用例
如果发现一个边缘例外值，请为它写一个测试用例

xUnit 工具

Java Class的测试Framework： JUnit
Java Swing app 的测试Framework： JFCUnit
Java Server Side（EJB，Servlet）的测试Framework：Catus
HTML Page的测试Framework： HTMLUnit、HTTPUnit
C++的测试Framework： CPPUnit
.Net APP的测试Framework： .NetUnit

实例

考虑一个质因数分解的例子：将任何一个大于1的自然数分解成质因子相乘，如4=2*2,24=2*2*2*3等。

第一天

建立Maven工程

创建如下Maven工程：

在pom.xml文件中加入JUnit信息：
根据测试驱动要求，写一个TestCase：

写第一个TestCase：
public class FactorTest { @Test public void testFactor() { assertEquals(2, Factor.factor(2)); } }
创建一个类Factor和静态方法factor：

public class Factor {
    public static int factor(int i){
        return 2;
    }
}

运行第一个TestCase：

测试通过：

于是形成质因数分解的第一个版本。

第二天

第一个测试用例可以测试2，那么3呢？
新增加一个测试用例：

public class FactorTest {
    
    @Test
    public void testFactor() {
        assertEquals(2, Factor.factor(2));
        assertEquals(3, Factor.factor(3));
    }

}

根据测试用例，修改Factor类的代码以通过测试用例：

public class Factor {
    public static int factor(int i){
        if(i==2) return 2;
        if(i==3) return 3;
        return 0;
    }
}

运行测试用例：

测试通过！

第三天

在前2个测试用例的基础上，增加4，又会怎样呢？

发现测试4，不能通过？怎么办？开始修改Factor类的代码！
首先希望测试4时，返回的是质因子的集合，修改测试用例：

assertEquals(Arrays.asList(2,2), Factor.factor(4));

对应的，其它测试用例相应发生更改：

public class FactorTest {
    
    @Test
    public void testFactor() {
        assertEquals(Arrays.asList(2), Factor.factor(2));
        assertEquals(Arrays.asList(3), Factor.factor(3));
        assertEquals(Arrays.asList(2,2), Factor.factor(4));
    }
}

由于返回的是数组集合，因此修改Factor类的factor方法：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        if(i==2) l.add(2);
        if(i==3) l.add(3);
        return l;
    }
}

跑测试，发现测试不通过，据此修改factor方法，以使得4的测试能够通过：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        if(i==2) l.add(2);
        if(i==3) l.add(3);
        if(i==4){
            l.add(2);
            l.add(2);
        }
        return l;
    }
}

运行JUnit Test：

发现测试通过，OK！

第四天

那么5呢？能测试通过吗？

不行！修改Factor类的factor方法：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        if(i==2) l.add(2);
        if(i==3) l.add(3);
        if(i==4){
            l.add(2);
            l.add(2);
        }
        if(i==5) l.add(5);
        return l;
    }
}

测试通过：

如果再继续这么写下去，你会发现你的代码臃肿不堪，不忍直视！
那么这时候，我们需要对代码进行重构优化！

当你无节操的修改代码以通过测试时，我们一定要在某个点停下来看看，我们是不是可以再优化些什么？
测试驱动容易让人进入一个局部关注点，不太关注思维的系统整体点。

停下脚步，回头看看我们的Factor类的factor方法，发现 i=2,i=3,i=5要做的事情似乎一样。
第一步，可以考虑将代码改成：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        l.add(i);       
        if(i==4){
            l.add(2);
            l.add(2);
                        return l;
        }       
        return l;
    }
}

运行测试：

发现4不能通过！发现4不能直接加。
怎么办？调整代码顺序！

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();               
        if(i==4){
            l.add(2);
            l.add(2);
            return l;
        }
        l.add(i);
        return l;
    }
}

运行JUnit Test：

测试通过！与未重构前的代码相比，看上去漂亮多了！

第五天

接下来，我们测试6：

public class FactorTest {
    
    @Test
    public void testFactor() {
        assertEquals(Arrays.asList(2), Factor.factor(2));
        assertEquals(Arrays.asList(3), Factor.factor(3));
        assertEquals(Arrays.asList(2,2), Factor.factor(4));
        assertEquals(Arrays.asList(5), Factor.factor(5));
        assertEquals(Arrays.asList(2,3), Factor.factor(6));
    }
}

显然，6不能通过！因此修改Factor类的factor方法：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();               
        if(i==4){
            l.add(2);
            l.add(2);
            return l;
        }
        if(i==6){
            l.add(2);
            l.add(3);
            return l;
        }
        l.add(i);
        return l;
    }
}

测试通过！
回头再看，i=4和i=6的代码，发现有一个拆解的过程，都有一个共同的因子：2
因此，考虑对代码进行优化：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        if(i%2==0){
            l.add(2);
            i=i/2;
        }       
        l.add(i);
        return l;
    }
}

运行测试：

发现2不能通过，继续修改代码，排除2的情况：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        if(i%2==0 && i>2){
            l.add(2);
            i=i/2;
        }       
        l.add(i);
        return l;
    }
}

测试通过

第六天

在此基础上，我们测试8：

assertEquals(Arrays.asList(2,2,2), Factor.factor(8));

发现测试不能通过！
发现8包含多个2，在Factor类的factor方法中，似乎应该将if语句改成while循环：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        while(i%2==0 && i>2){
            l.add(2);
            i=i/2;
        }       
        l.add(i);
        return l;
    }
}

测试通过！

第七天

测试9：

assertEquals(Arrays.asList(3,3), Factor.factor(9));

测试不通过！

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        while(i%2==0 && i>2){
            l.add(2);
            i=i/2;
        }
        while(i%3==0 && i>3){
            l.add(3);
            i=i/3;
        }
        l.add(i);
        return l;
    }
}

测试通过！
分别再对9,10,11,12,20进行测试：

assertEquals(Arrays.asList(3,3), Factor.factor(9));
assertEquals(Arrays.asList(2,5), Factor.factor(10));
assertEquals(Arrays.asList(11), Factor.factor(11));
assertEquals(Arrays.asList(2,2,3), Factor.factor(12));
assertEquals(Arrays.asList(2,2,5), Factor.factor(20));

测试通过：

第八天

测试25：

assertEquals(Arrays.asList(5,5), Factor.factor(25));

测试不能通过！原因很简单，代码里面没有对因子5再做处理！
最直观地：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        while(i%2==0 && i>2){
            l.add(2);
            i=i/2;
        }
        while(i%3==0 && i>3){
            l.add(3);
            i=i/3;
        }
        while(i%5==0 && i>5){
            l.add(5);
            i=i/5;
        }
        l.add(i);
        return l;
    }
}

测试通过！
这时候，我们需要停下脚步，优化代码，消除重复。
在TestCase的保护下，考虑对代码进行修改：

public class Factor {
    public static List<Integer> factor(int i){
        List<Integer> l=new ArrayList<Integer>();
        int k=2;
        while(k<i){
            while(i%k==0 && i>k){
                l.add(k);
                i=i/k;
            }
            k++;
        }       
        l.add(i);
        return l;
    }
}

测试通过！
考虑一个复杂的TestCase：

assertEquals(Arrays.asList(2,2,2,3,5,7,7,11), Factor.factor(2*2*2*3*5*7*7*11));

测试通过！

回头看看这段代码是否可接受？

小结

测试驱动开发：

能够保证编写单元测试
使程序员坚持编写测试
有助于澄清接口和行为的细节
可证明、可再现、自动的验证
增强改变事物的信心

转载于:https://www.cnblogs.com/happyzm/p/7468975.html

weixin_30456039

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫