Junit学习
（一）TDD简介：
许多书上都讨论了自动测试，但是只有很少的著作注意到这么一个问题，那就是怎样把这些测试组织起来。随着测试的增加，放置和调用这些测试却变得更加麻烦。这将成为一个重要问题，以至于出现了TDD，极限编程（XP）使TDD得以普及。另外，你可以这样理解TDD：通过测试来开发。
TDD（Test-Driven Development：测试驱动开发）本质和优势
测试驱动开发不是一种测试技术，它是一种分析技术、设计技术，更是一种组织所有开发活动的技术。相对于传统的结构化开发过程方法，它具有以下优势：
1) TDD根据客户需求编写测试用例，对功能的过程和接口都进行了设计，而且这种从使用者角度对代码进行的设计通常更符合后期开发的需求。因为关注用户反馈，可以及时响应需求变更，同时因为从使用者角度出发的简单设计，也可以更快地适应变化。
2) 出于易测试和测试独立性的要求，将促使我们实现松耦合的设计，并更多地依赖于接口而非具体的类，提高系统的可扩展性和抗变性。而且TDD明显地缩短了设计决策的反馈循环，是我们几秒或几分钟之内就能获得反馈。
3) 将测试工作提到编码之前，并频繁地运行所有测试，可以尽量地避免和尽早地发现错误，极大地降低了后续测试及修复的成本，提高了代码的质量。在测试的保护下，不断重构代码，以消除重复设计，优化设计结构，提高了代码的重用性，从而提高了软件产品的质量。
4) TDD提供了持续的回归测试，使我们拥有重构的勇气，因为代码的改动导致系统其他部分产生任何异常，测试都会立刻通知我们。完整的测试会帮助我们持续地跟踪整个系统的状态，因此我们就不需要担心会产生什么不可预知的副作用了。
5) TDD所产生的单元测试代码就是最完美的开发者文档，它们展示了所有的API该如何使用以及是如何运作的，而且它们与工作代码保持同步，永远是最新的。
6) TDD可以减轻压力、降低忧虑、提高我们对代码的信心、使我们拥有重构的勇气，这些都是快乐工作的重要前提。
TDD现状
由于发展时间不长，相关应用并不是很成熟。现今越来越多的公司都在尝试实践测试驱动开发，但由于测试驱动开发对开发人员要求比较高，更与开发人员的传统思维习惯相违背，因此实践起来有一定困难。
（二）Junit的简单介绍
简单的说，junit 是用来做单元测试的一个工具。用其主页上的话来说就是：“JUnit是由Erich Gamma 和Kent Beck 编写的一个回归测试框架（regression testing work）。在https://www.doczj.com/doc/8f12563109.html,上可以下载到最新版本的junit包。
单元测试是一种白箱测试。目的是验证一个或若干个类是否按所设计的那样正常工作。集成测试则是验证所有的类是否能互相配合，协同完成特定的任务。
需要强调的是：测试是一个持续的过程。也就是说测试贯穿与开发的整个过程中，单元测试尤其适合于迭代增量式（iterative and incremental）的开发过程。
因为我们是测试新手，我们也不理会那些复杂的测试原理，先说一说最简单的:测试就是比较预期的结果是否与实际执行的结果一致。如果一致则通过，否则失败。
（三）回归测试框架-JUnit
回归测试就是你不断地对所编写的代码进行测试：编写一些，测试一些，调试一些，然后循环这一过程，你会不断地重复先前的测试，哪怕你正编写其他的类，由于软件熵的存在，你可能在编写第五个类的时候发现，第五个类的某个操作会导致第二个类的测试失败。通过回归测试我们抓住了这条大Bug。
（四）junit中的几个关键点
Junit4 与junit3相比，做了比较大的改动。具体不细讲了，有兴趣可在网上查找些资料进行了解。
1．下面通过一个简单的实例对junit框架（函数结构）做个简单的介绍。
比如下面一个类：
public class AddOperation {
public int add(int x,int y){
return x+y;
}
}
我们要测试add这个方法，我们在junit4中写单元测试得这么写：
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
/**
*
* @author bean
*/
public class AddOperationTest extends TestCase{
public AddOperationTest() {
}
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void add() {
System.out.println(\"add\");
int x = 0;
int y = 0;
AddOperation instance = new AddOperation();
int expResult = 0;
int result = instance.add(x, y);
assertEquals(expResult, result);
}
}
几个元数据的介绍：
@Before：
使用了该元数据的方法在每个测试方法执行之前都要执行一次。
@After：
使用了该元数据的方法在每个测试方法执行之后要执行一次。
注意：@Before和@After标示的方法只能各有一个。这个相当于取代了JUnit以前版本中的setUp和tearDown方法，当然你还可以继续叫这个名字，不过JUnit不会霸道的要求你这么做了。
@Test(expected=*.class)
在JUnit4.0之前，对错误的测试，我们只能通过fail来产生一个错误，并在try块里面assertTrue（true）来测试。现在，通过@Test元数据中的expected属性。expected属性的值是一个异常的类型
@Test(timeout=xxx):
该元数据传入了一个时间（毫秒）给测试方法，
如果测试方法在制定的时间之内没有运行完，则测试也失败。
@ignore：
该元数据标记的测试方法在测试中会被忽略。当测试的方法还没有实现，或者测试的方法已经过时，或者在某种条件下才能测试该方法（比如需要一个数据库联接，而在本地测试的时候，数据库并没有连接），那么使用该标签来标示这个方法。同时，你可以为该标签传递一个String的参数，来表明为什么会忽略这个测试方法。比如：@lgnore(“该方法还没有实现”)，在执行的时候，仅会报告该方法没有实现，而不会运行测试方法。
另外还有一些其他的元数据，具体请自己查资料。
setUp与tearDown，这两个函数是junit framework中提供初始化和反初始化每个测试方法的。setUp在每个测试方法调用前被调用，负责初始化测试方法所需要的测试环境；tearDown 在每个测试方法被调用之后被调用，负责撤销测试环境。
它们与测试方法的关系可以描述如下：
测试开始 -> setUp -> testXXXX -> tearDown ->测试结束
2．另一个实例说明建立测试的流程（步骤）：
假设我们要写一个整数除法和乘法的类，并且给他写测试用例：
1) 建立Math类
2) 建立测试用例
选中需要建立测试用例的包，选择new->other->JUnit Test Case。
有5个方法可以选择：
setUp()方法在测试方法前调用，一般用来做测试准备工作。
tearDown()方法在测试方法后调用，一般作测试的清理工作。
setUpBeforeClass()方法在整个类初始化之后调用，一般用来做测试准备工作。tearDownAfterClass()方法在整个类结束之前调用，一般作测试的清理工作。
constructor()为是否包含构造方法。
自动生成的代码如下：
说明：
@BeforeClass标签注释的方法用于在整个类测试过程的初始化后调用一次，@AfterClass标签注释的方法则是整个测试类结束之前调用一次。这2个标签的搭配可以避免使用@Before、@After标签组合在每个测试方法前后都调用的弊端，减少系统开销，提高系统测试速度。(不过对环境独立性要求较高的测试还是应当使用@Before、@After来完成)
@Test标签用来标注待测试的方法，按照类中声明的顺序执行。
我们在testDivide方法加入测试代码，分别测试三种情况：
a. 完全正确也没有可能出错的数据，如：9除3 结果必须等于3
b. 可能有问题的边缘数据，如：10除3 结果也必须等于3
c. 错误的数据，如：10除0 必须抛出异常
忽略testMultiple方法
代码如下：
说明:
Junit4为测试方法增加了判断异常的方式，避免了以前还要通过try/catch块捕捉异常再抛出的复杂方式，简单的这样声明“@Test(expected=ArithmeticException.class)”Junit4就会检查此方法是否抛出ArithmeticException异常，如果抛出则测试通过，没抛出则测试不通过（@Test标签还有一些其他参数，例如超时测试@Test(timeout=1)这样，但是由于并不能准确反应实际时间，所以应用较少，经过我测试误差太大绝对不适合拿来做超时测试的）
@Ignore标签会告诉Junit4忽略它所标注的方法，例如数据库不可用时可以用此标注标注一些测试数据库连接的方法来避免测试失败。
3) 运行测试
系统会打开JUnit透视图，如果测试全部通过，则显示颜色条为绿色；
我们将assertEquals(3,Math.divide(9,3));改成assertEquals(2,Math.divide(9,3));则显示颜色条为红色，我们可以对错误或者故障的地方进行追踪。
4) 创建测试套件
测试套件可以将多个测试用例合在一起测试，将相关的测试用例合成一个测试套件，在做一个修改后，只需要运行测试套件就可以，不需要运行每一个测试用例。
Junit4没有采用以前的套件测试方法，同样使用annotation的方式来进行。简单在你所要构建测试套件的包里创建一个文件，一般以包名+4Suite
下面我在上面的测试包中复制一下之前的测试类并且一个改名字叫做MathTestAnother，新建一个class 类叫做Uitl4Suite，代码如下：
说明：
通过@RunWith和@SuiteClasses标签来注释一个空的包含无参数构造函数的类来作为套件类，将需要组成套件运行的类加到@SuiteClasses的属性中即可。
可以看到运行套件类的结果是2个测试类都进行了测试。
5) 参数测试
修改testMultiple
编写参数方法：
说明：
需要使用@Parameters标签注解一个静态的返回集合对象的方法增加成员变量和构造函数：
最后在给测试类增加如下注释：
完整的循环测试代码如下：
结果如下图示，程序跑了5次，并通过运行。
实验报告五 课程名称：软件测试 学生姓名：董月 班级：浦计1104班 学号：P1401110402 指导教师：韩志刚 实验日期：2014-5-8 南京工业大学电子与信息学院
实验五 一、实验内容 用java语言编写一个计算器类，求实现加、减、乘、除、求平方根、求绝对值、求倒数1/x,方法，并用junit进行对象类的单元测试。参阅帮助文档。（说明，设计求除法、求倒数的方法，可在方法中不检测x是否为0,测试用例用y/0去测试、求平方根可不检测x>0,用负数测试） 二、实验步骤 首先新建一个项目叫JUnit_Test，我们编写一个Calculator类，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。 建立一个hzg包: 建立一个Calculator类:
把代码输进类中： package hzg; public class Calculator { private static int result; // 静态变量，用于存储运行结果 public void add(int n) { result = result + n; } public void substract(int n) { result = result - 1; //Bug: 正确的应该是result =result-n } public void multiply(int n) { result=result*n; } public void divide(int n) { result = result / n; } public void square(int n) { result = n * n; } public void squareRoot(int n) { result= (int) Math.sqrt(n); } public void clear() { // 将结果清零 result = 0; } public void reciprocal(int n) { result=1/n; } public void absolute(int n) { result=Math.abs(n); } public int getResult() { return result; } }
JUnit入门及应用 1、相关概念 ?JUnit：是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。它是用于单 元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。 ?白盒测试：把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人 员是公开的。 ?回归测试：软件或环境的修复或更正后的再测试，自动测试工具对这类测试尤其有用。 ?单元测试：最小粒度的测试，以测试某个功能或代码块。一般由程序员来做，因为它需 要知道内部程序设计和编码的细节。 2、单元测试 2.1、单元测试的好处 ?提高开发速度，测试是以自动化方式执行的，提升了测试代码的执行效率。 ?提高软件代码质量，它使用小版本发布至集成，便于实现人员除错。同时引入重构概念， 让代码更干净和富有弹性。 ?提升系统的可信赖度，它是回归测试的一种。支持修复或更正后的“再测试”，可确保代码的正确性。 2.2、单元测试的针对对象 ?面向过程的软件开发针对过程。 ?面向对象的软件开发针对对象。 ?可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。 2.3、单元测试工具和框架 目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。 单元测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人）提供的开放源代码的JUnit。 3、Junit入门简介 3.1、JUnit的好处和JUnit测试编写原则 使用JUnit的好处： ?可以使测试代码与产品代码分开。 ?针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。
JUnit4概述 JUnit4是JUnit框架有史以来的最大改进，其主要目标便是利用Java5的Annotation特性简化测试用例的编写。 先简单解释一下什么是Annotation，这个单词一般是翻译成元数据。元数据是什么？元数据就是描述数据的数据。也就是说，这个东西在Java里面可以用来和public、static等关键字一样来修饰类名、方法名、变量名。修饰的作用描述这个数据是做什么用的，差不多和public 描述这个数据是公有的一样。想具体了解可以看Core Java2。废话不多说了，直接进入正题。 我们先看一下在JUnit 3中我们是怎样写一个单元测试的。比如下面一个类： public class AddOperation { public int add(int x,int y){ return x+y; } } 我们要测试add这个方法，我们写单元测试得这么写： import junit.framework.TestCase; import static org.junit.Assert.*; public class AddOperationTest extends TestCase{ public void setUp() throws Exception { } public void tearDown() throws Exception { } public void testAdd() { System.out.println(\"add\"); int x = 0; int y = 0; AddOperation instance = new AddOperation(); int expResult = 0; int result = instance.add(x, y); assertEquals(expResult, result); } } 可以看到上面的类使用了JDK5中的静态导入，这个相对来说就很简单，只要在import关键字后面加上static关键字，就可以把后面的类的static的变量和方法导入到这个类中，调用的时候和调用自己的方法没有任何区别。
Eclipse中配置junit 在要使用JUNIT的project名上，点击properties--java build path-libraries, 点击Add External JARs,把JUNIT包点上就行了. 并在需要测试的项目上新建junit test case 用法 1. 基本使用步骤，Junit的使用非常简单，它的基本使用步骤： - 创建，从junit.framework.TestCase派生unit test需要的test case - 书写测试方法，提供类似于如下函数签名的测试方法： public void testXXXXX(); - 编译，书写完test case后，编译所写的test case类 - 运行，启动junit test runner，来运行这个test case。 Junit提供了2个基本的test runner：字符界面和图形界面。启动命令分别如下： a 图形界面： 化每个测试方法的。setUp在每个测试方法调用前被调用，负责初始化测试方法所需要的测试环境；tearDown在每个测试方法被调用之后被调用，负责撤销测
试环境。它们与测试方法的关系可以描述如下： 测试开始 -> setUp -> testXXXX -> tearDown ->测试结束 - fail，期望出现的错误。产生原因：assert函数出错（如assertFalse(true)）；fail函数产生（如fail(……)）。 - exception，不期望出现的错误，属于unit test程序运行时抛出的异常。它和普通代码运行过程中抛出的runtime异常属于一种类型。 对于assert、fail等函数请参见junit的javadoc。
junit心得体会 篇一：我本人学习JUnit的心得体验 我本人学习JUnit的心得体验 其实促使我学习JUnit首先是因为它是一个标准。其实不用JUnit进行测试可 不可以呢？答案是可以的，而且我们还可以随心所欲地编写测试代码，到最后轻松完成测试。但是问题出现了，如果有人接下你的项目进行二次开发的时候，看你的测试代码将是一件苦差事。所以有必要制定一套标准实现测试的规范化。JUnit在这种环境之下诞生了。 其次，通过学习JUnit，我感受到了先写测试再编码的好处。因为在我们写 好测试的同时，我们也确认了类别所要进行的行为，即使我们一开始对该类别的职责还不明确，藉由先写下测试，我们对该类别的要求也可以确定下来，这是写测试的好处，而且在写好的同时，相当于也写好了对该类别的职责说明书。因此我们应该先将相关的测试写好，这可以帮助我们确定所要加上的功能是什么，然后我们的目标就是通过这些新的测试。事实上，我们的类别将会被设计为与其它物件耦合度低的类别，这也是先写测试所意外带来的好处。 其实JUnit简单使用并不复杂，首先要下载JUnit包并配置好，我用的idE
是netbeans里面已经集成JUnit了。 一般一个类别都会对应一个测试类。JUnit提供了一个代码框架给我们编写 我们自己的测试类： publicclassTestXXXextendsTestcase{ publicTestXXX(Stringname){ super(name); } publicvoidsetUp(){ try{ super.setUp(); /*yourinitializecodehere*/ }catch(Exceptionex){ ex.printStackTrace(); } } publicvoidteardown(){ try{ /*yourdestroycodehere*/ super.teardown(); }catch(Exceptionex){ ex.printStackTrace();
JUnit java单元测试 首先须导入JUnit包：所在项目右击->Build Path->Add Libraries ->选择JUnit->选择一个版本->Finish 一．手动生成 1.测试方法，必须符合下列条件 *方法必须声明成：public，void *JUnit3方法名必须以test开头，JUnit4则不需要 *方法无参数 如：JUnit3：Public void testAdd(){} JUnit4：@Test （org.junit.Test） Public void AddTest(){} 2. JUit3 与 JUit4的区别 源码和测试代码分开放在不同的Source Folder，测试代码所在的包名最好和源码中的包名一一对应。JUnit3测试方法中的类必须继承TestCase （junit.framwork.TestCase）；而JUnit4类则不需要继承任何类，但在方法前须加上注解@Test（org.junit.Test）此测试方法，标注该程序是以JUnit的方式来运行的。 JUit3：在方法前加上TestCase类的方法setUp()，在执行每一次测试方法之前都会被调用，可把在测试方法中都需要的程序放在这里；最后加上
tearDown()方法，在执行每一次方法后都会被调用。 JUit4：与JUit3不同的是，在JUit4中是在方法前用注解 @BeforeClass:globeInit(),无论执行多少测试方法，它只执行一次，且运行在最前 @Before：把方法注解成Before，init()与JUit3中的setUp()方法作用一样@After：把方法注解成After，destroy()与JUit3中的tearDown ()方法作用一样 @AfterClass:无论执行多少测试方法，它只执行一次，且运行在最后 下面分别以JUit3和JUit4为例子来运行测试： 例1.JUit3 源代码： package com.sinyee.unit; public class ArrayUnit { /** *传入一个数组，返回该数组的最大值 *@param array *@return */ public int getMaxValue(int[] array) throws Exception { if (array==null) { throw new NullPointerException("空指针异常"); } if (array.length == 0) { throw new ArrayIndexOutOfBoundsException("数组不能为 空!"); } int temp = array[0]; for (int i = 1; i < array.length; i++) { if (temp < array[i]) { array[i] = temp; } } // 取出该数组的最大值 return temp;
实验五JUnit测试框架的使用 一、实验目的 1、掌握Junit测试框架的使用 2、掌握测试用例的编写 二、基本知识 1、熟悉java编程语言和Eclipse集成开发环境 2、熟悉单元测试概念 3、熟悉测试设计技术 三、实验环境 ①windows操作系统+IE浏览器 ②Eclipse集成开发环境+Junit测试框架 四、实验内容 1、学习Junit框架的使用 可通过以下两个示例进行学习。 A、Junit使用方法示例1 1）把Junit引入当前项目库中 新建一个Java 工程—coolJUnit，打开项目coolJUnit的属性页->选择“Java Build Path”子选项->点选“Add Library…”按钮->在弹出的“Add Library”对话框中选择JUnit（图1），并在下一页中选择版本Junit 4 后点击“Finish”按钮。这样便把JUnit引入到当前项目库中了。
图1 为项目添加JUnit库 2）新建单元测试代码目录 单元测试代码是不会出现在最终软件产品中的，所以最好为单元测试代码与被测试代码创建单独的目录，并保证测试代码和被测试代码使用相同的包名。这样既保证了代码的分离，同时还保证了查找的方便。遵照这条原则，在项目coolJUnit根目录下添加一个新目录testsrc，并把它加入到项目源代码目录中。（见图2、3）。
图2 新建测试代码目录 图3 添加测试代码目录 3）在工程中添加类 添加类SampleCaculator，类中有两个方法，分别计算加减法。编译代码。 package https://www.doczj.com/doc/8f12563109.html,.gzhu; publicclass SampleCalculator { //计算两整数之和 publicint add(int augend, int addend){ return augend + addend; } //计算两整数之差 publicint subtration(int minuend, int subtrahend){ return minuend - subtrahend; } } 4）写单元测试代码 为类SampleCalculator添加测试用例。在资源管理器SampleCalculator.java文件处右击选new>选Junit Test Case（见图4），Source foler选择testsrc目录，点击next，选择要测试的方法，这里把add和subtration方法都选上，最后点finish完成。
Junit单元测试 版本号：0.1 制定日期：2010-12 编制冯宝鹏日期2012-04-14 审核日期 批准日期
文档修订记录 修订日期修订内容修订人
目录 Junit单元测试 (4) 一实验目的 (4) 二实验环境 (4) 三实验内容 (4) 四实验步骤 (4) 五测试用例 (4) 六测试计划 (6) 七测试计划 (6) 八覆盖率测试报告 (9) 1.测试一元二次方程有两个实根的情况 (9) 2.测试二元一次方程有两个虚根的情况 (10) 3. 测试一元一次方程有一个根的情况 (11) 4测试不为方程的情况 (12) 九实验总结 (14)
Junit单元测试 一实验目的 1.掌握白盒测试方法，并按单元测试的要求设计测试用例。 2.能熟练应用junit测试工具进行单元测试。 3.进行代码覆盖检查。 二实验环境 主流PC机一套，windows操作系统eclipse开发平台。 三实验内容 1、用java语言编写一个求一元二次方程根的函数 2、设计白盒测试用例，达到分支覆盖 3、使用弱健壮等价类分析方法设计测试用例。 4、根据以上设计的测试用例，编写junit测试代码，并进行测试。 5、利用EclEmma完成测试代码覆盖分析，并生成html格式代码覆盖测试报告。 四实验步骤 （1）根据白盒法设计测试用例，并撰写单元测试计划书。 （2）根据每个测试用例，编写基本Junit的单元测试脚本。 （3）生成html格式的代码覆盖测试报告。 五测试用例 采用条件覆盖法设计用例，使判断中的每个条件的可能取值至少满足一次。 分为四种情况： （1）一元二次方程有两个实根(简单起见，将方程有两个相同实根，归类为方程有两个实根)
南京理工大学泰州科技学院实验报告书 课程名称：《软件测试与质量保证》 实验题目：实验三 Junit单元测试 班级： 学号： 姓名： 指导教师：
一、实验目的 1．了解Junit测试框架用途及相关框架组成要素 2．掌握Junit3.8中断言的使用及Assert静态类的相关用法 3．掌握在Eclipse中如何结合JUnit3.8进行单元测试的过程 二、实验内容 1、使用java语言编写一个类，该类用于完成简单的数学四则运算；然后使用Junit单元测试方法对编写的类进行测试。 三、实验步骤及结果 1、 （1）实验程序 package https://www.doczj.com/doc/8f12563109.html,; import https://www.doczj.com/doc/8f12563109.html,.apache.bcel.internal.generic.NEW; import junit.framework.Assert; import junit.framework.TestCase;
public class MathTest extends TestCase{ public void testAdd() { Math math=new Math(); int result=math.add(1,2); Assert.assertEquals(3,result); } public void testMin(){ Math math=new Math(); int result=math.min(1,2); Assert.assertEquals(-1,result); } public void testMui(){ Math math=new Math(); int result=math.mui(1,2); Assert.assertEquals(2,result); } public void testDiv(){ Math math=new Math(); int result=0; try{ result=math.div(6,2);} catch(Exception e){ e.printStackTrace(); } Assert.assertEquals(3,result); } public void testDiv1(){ Throwable throwable=null; Math math=new Math(); try{ int result=math.div(6,0);} catch(Exception e){ throwable=e; } assertNotNull(throwable); assertEquals(Exception.class,throwable.getClass()); assertEquals("除数不能为零",throwable.getMessage()); } } （2）实验结果
实验报告五课程名称：软件测试 学生姓名：董月 班级：浦计1104班 指导教师：韩志刚 实验日期：2014-5-8 南京工业大学电子与信息学院 实验五 一、实验内容 用java语言编写一个计算器类，求实现加、减、乘、除、求平方根、求绝对值、求倒数1/x,方法，并用junit进行对象类的单元测试。参阅帮助文档。（说明，设计求除法、求倒数的方法，可在方法中不检测x是否为0,测试用例用y/0去测试、求平方根可不检测x>0,用负数测试） 二、实验步骤 首先新建一个项目叫JUnit_Test，我们编写一个Calculator类，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。建立一个hzg包: 建立一个Calculator类: 把代码输进类中： package hzg; public class Calculator { private static int result; // 静态变量，用于存储运行结果 public void add(int n) { result = result + n; } public void substract(int n) { result = result - 1; //Bug: 正确的应该是result =result-n } public void multiply(int n) { r esult=result*n; } public void divide(int n) { result = result / n;
} public void square(int n) { result = n * n; } public void squareRoot(int n) { result= (int) Math.sqrt(n); } public void clear() { // 将结果清零 result = 0; } public void reciprocal(int n) { result=1/n; } public void absolute(int n) { result=Math.abs(n); } public int getResult() { return result; } } 第二步，将JUnit4单元测试包引入这个项目：在该项目上点右键，点“属性”，在弹出的属性窗口中，首先在左边选择“Java Build Path”，然后到右上选择“Libraries”标签，之后在最右边点击“Add Library…”按钮，如下图所示： 然后在新弹出的对话框中选择JUnit4并点击确定，如上图所示，JUnit4软件包就被包含进我们这个项目了。 第三步，生成JUnit测试框架：在Eclipse的Package Explorer中用右键点击该类弹出菜单，在弹出的对话框中，进行相应的选择加、减、乘、除，之后系统会自动生成一个新类CalculatorTest，里面包含一些空的测试用例。只需要将这些测试用例稍作修改即可使用。完整的CalculatorTest 代码如下： package hzg; import static import import import import import public class CalculatorTest { private static Calculator calculator = new Calculator(); @BeforeClass public static void setUpBeforeClass() throws Exception { } @AfterClass public static void tearDownAfterClass() throws Exception { }
如何使用JUnit进行自动化测试 1如何利用JUnit在Eclipse中开发自动化脚本 JUnit可以和很多开发工具进行集成来进行单元测试，我们这里选取较常用的java开发工具Eclipse来使用JUnit4进行单元测试。如何在开发工具Eclipse里进行单元测试 首先新建一个项目叫JUnit_Test，我们编写一个Calculator类，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。这个类并不是很完美，我们故意保留了一些Bug用于演示，这些Bug在注释中都有说明。该类代码如下： package andycpp; public class Calculator { private static int result; // 静态变量，用于存储运行结果 public void add(int n) { result = result + n; } public void substract(int n) { result = result - 1; //Bug: 正确的应该是 result =result-n } public void multiply(int n)
{ } // 此方法尚未写好 public void divide(int n) { result = result / n; } public void square(int n) { result = n * n; } public void squareRoot(int n) { for (; ; ) ; //Bug : 死循环} public void clear() { // 将结果清零
Junit学习 （一）TDD简介： 许多书上都讨论了自动测试，但是只有很少的著作注意到这么一个问题，那就是怎样把这些测试组织起来。随着测试的增加，放置和调用这些测试却变得更加麻烦。这将成为一个重要问题，以至于出现了TDD，极限编程（XP）使TDD得以普及。另外，你可以这样理解TDD：通过测试来开发。 TDD（Test-Driven Development：测试驱动开发）本质和优势 测试驱动开发不是一种测试技术，它是一种分析技术、设计技术，更是一种组织所有开发活动的技术。相对于传统的结构化开发过程方法，它具有以下优势： 1) TDD根据客户需求编写测试用例，对功能的过程和接口都进行了设计，而且这种从使用者角度对代码进行的设计通常更符合后期开发的需求。因为关注用户反馈，可以及时响应需求变更，同时因为从使用者角度出发的简单设计，也可以更快地适应变化。 2) 出于易测试和测试独立性的要求，将促使我们实现松耦合的设计，并更多地依赖于接口而非具体的类，提高系统的可扩展性和抗变性。而且TDD明显地缩短了设计决策的反馈循环，是我们几秒或几分钟之内就能获得反馈。 3) 将测试工作提到编码之前，并频繁地运行所有测试，可以尽量地避免和尽早地发现错误，极大地降低了后续测试及修复的成本，提高了代码的质量。在测试的保护下，不断重构代码，以消除重复设计，优化设计结构，提高了代码的重用性，从而提高了软件产品的质量。 4) TDD提供了持续的回归测试，使我们拥有重构的勇气，因为代码的改动导致系统其他部分产生任何异常，测试都会立刻通知我们。完整的测试会帮助我们持续地跟踪整个系统的状态，因此我们就不需要担心会产生什么不可预知的副作用了。 5) TDD所产生的单元测试代码就是最完美的开发者文档，它们展示了所有的API该如何使用以及是如何运作的，而且它们与工作代码保持同步，永远是最新的。 6) TDD可以减轻压力、降低忧虑、提高我们对代码的信心、使我们拥有重构的勇气，这些都是快乐工作的重要前提。 TDD现状 由于发展时间不长，相关应用并不是很成熟。现今越来越多的公司都在尝试实践测试驱动开发，但由于测试驱动开发对开发人员要求比较高，更与开发人员的传统思维习惯相违背，因此实践起来有一定困难。
编制并运行JUnit测试用例程序 一、实验目的： 1、理解JUnit的断言等内容 2、测试Calculator类 3、测试Sorting类 5、测试Triangle类 二、实验内容 1、基于JUnit实现白盒测试用例 2、记录测试结果，截屏或文字 三、实验环境：JUnit Calculator类 package calcu; public class Calculator { public int add(int i, int j) { return i+j; } public int subtract(int i, int j) { return i-j; } public int multiply(int i, int j) { return i*j; } public int divide(int i, int j) { return i/j; } } 如下是类Calculator的测试用例 package calcu; import junit.framework.Assert; import junit.framework.TestCase; public class CalculatorTest extends TestCase { public void testAdd()
{ Calculator calculator = new Calculator(); int result = calculator.add(1, 2); // 判断方法的返回结果 Assert.assertEquals(3, result);// 第一个参数是期望值，第二个参数是要验证的值 } public void testSubtract() { Calculator calculator = new Calculator(); int result = calculator.subtract(1, 2); // 判断方法的返回结果 Assert.assertEquals(-1, result);// 第一个参数是期望值，第二个参数是要验证的值 } public void testMultiply() { Calculator calculator = new Calculator(); int result = calculator.multiply(3, 3); // 判断方法的返回结果 Assert.assertEquals(6, result);// 第一个参数是期望值，第二个参数是要验证的值 } public void testDivide() { Calculator calculator = new Calculator(); int result = calculator.divide(3, 3); Assert.assertEquals(4, result);// 第一个参数是期望值，第二个参数是要验证的值int result = calculator.divide(12, 3); // 判断方法的返回结果 } } Sorting类
在Eclipse中使用JUnit4进行单元测试 JUnit——是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。 回归测试——软件或环境的修复或更正后的“再测试”，自动测试工具对这类测试尤其有用。 单元测试——是最小粒度的测试，以测试某个功能或代码块。一般由程序员来做，因为它需要知道内部程序设计和编码的细节。 单元测试的好处： 1、提高开发速度——测试是以自动化方式执行的，提升了测 试代码的执行效率。 2、提高软件代码质量——它使用小版本发布至集成，便于实 现人员除错。同时引入重构概念，让代码更干净和富有弹性。 3、提升系统的可信赖度——它是回归测试的一种。支持修复 或更正后的“再测试”，可确保代码的正确性。 JUnit就是为Java程序开发者实现单元测试提供一种框架，使得Java单元测试更规范有效，并且更有利于测试的集成。 JUnit的一大主要特点是，它在执行的时候，各个方法之间是相互独立的，一个方法的失败不会导致别的方法失败，方法之间也不存在相互依赖的关系，彼此是独立的。
本文简要介绍一下在Eclipse3.2中使用JUnit4进行单元测试的方法。 首先，我们来一个傻瓜式速成教程，不要问为什么，Follow Me，先来体验一下单元测试的快感! 首先新建一个项目叫JUnit_Test，我们编写一个Calculator类，这是一个能够简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行单元测试。这个类并不是很完美，我们故意保留了一些Bug用于演示，这些Bug在注释中都有说明。该类代码如下： package com.junit; public class Calculator { private static int result; // 静态变量，用于存储运行结果 public void add(int n) { result = result + n; } public void substract(int n){ result = result - 1; //Bug: 正确的应该是 result =result-n } public void multiply(int n){ } // 此方法尚未写好 public void divide(int n){ result = result / n; } public void square(int n){ result = n * n; } public void squareRoot(int n){
JUNIT 开源代码的java测试框架，用于编写和运行可重复测试，是用于单元测试框架体系的将Unit 的一个实例 1、测试： 白盒测试：把测试对象看做一个盒子，程序内部的逻辑结构和其他信息对测试人员公开回归测试：软件或环境的修复或更正后的“在测试”，自动测试工具对其尤其有用 单元测试：测试某个功能或代码块 2、单元测试的好处 提升开发速度；-------已自动方式执行 提高软件代码质量；------便于除错， 提升系统的可信赖度------回归测试的一种，支持“在测试” 3、单元测试的针对对象： 面向过程的软件开发针对过程； 面向对象的软件开发针对对象 可以做类测试、功能测试、接口测试 4、单元测试工具和框架 最流行的单元测试工具是xUnit系列框架，根据语言可划分为java、c++、Net、php等，最杰出的应用是开放源代码的Junit 5、JUnit的好处： 测试代码与产品代码分开， 针对某一类得测试代码通过较少的改动就可以用于另一个类的测试 公开源代码，可以进行二次开发 方便对其扩展 6、JUnit的特征： 使用断言方法判断期望值和实际值差异，返回Boolean值 测试驱动设备使用共同的初始化变量或实例 测试包结构便于组织和集成运行 支持图形交互模式和文本交互模式 7、JUnit框架组成 对测试目标进行测试的方法与过程集合，称为测试用例（TestCase） 测试用例可以容纳多个测试用例，称为测试包（TestSuite） 测试结果的描述与记录（TestResult） 测试过程中的监听着（TestListener） 每个测试方法所发生的与预期不一致的情况的描述，测试失败元素（TestFailuer） JunitFrameWork中的异常（AssertionFailedError） 8、JUnit的安装：
实验4：JUnit单元测试 董瑞志 常熟理工学院软件工程系 实验目的 理解手工编写单元测试的基本方法； 编写简单的基于JUnit的单元测试用例； 课时安排 2课时 实验内容 问题1：软件测试的定义及特点。 软件测试定义：软件测试时一种实际输出与预期输出间的审核或者比较的过程 软件测试的特点：软件测试的开销大 问题2：描述软件测试相关的信息流 信息流输入： 软件配置、测试配置 信息流输出： 调试、测试结果分析 JUnit初步 单元测试可以描述为“确保方法接收预期范围内的输入，并且对每个测试输入返回预期的结果。”单元测试是独立的一个工作单元（一个工作单元是一项任务，它不依赖于其他任何任务的完成）。在Java应用程序中，“独立的一个动作单元”常常指的是一个方法。1．编写Calculator类及其手工测试类TestCalculatorManual
图1：手工测试Calculator 单元测试的一条准则是“若程序的某项功能没有经过测试，那么该功能基本等于不存在”。这里的add方法是Calculator的核心功能之一，这里我们先手工编写测试类TestCalculatorManual。 2．用JUnit进行单元测试 （1）JUnit有很多功能可以简化测试用例的编写和运行,我们编写Test Case—TestCalculatorWithJUnit如下。 图2：使用JUnit设计测试脚本 在Calculator类中添加subtract(), multiply()，divide()后，如何编写手工测试用例和基于JUnit 框架的测试用例应该如何编写？ （2）使用默认的TestSuite, 显式调用Junit TestRunner
JUnit入门简介+实例 1、几个相关的概念 白盒测试——把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的。 回归测试——软件或环境的修复或更正后的“再测试”，自动测试工具对这类测试尤其有用。 单元测试——是最小粒度的测试，以测试某个功能或代码块。一般由程序员来做，因为它需要知道内部程序设计和编码的细节。 JUnit ——是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。 2、单元测试概述 2.1、单元测试的好处 A、提高开发速度——测试是以自动化方式执行的，提升了测试代码的执行效率。 B、提高软件代码质量——它使用小版本发布至集成，便于实现人员除错。同时引入重构概念，让代码更干净和富有弹性。 C、提升系统的可信赖度——它是回归测试的一种。支持修复或更正后的“再测试”，可确保代码的正确性。 2．2、单元测试的针对对象 A、面向过程的软件开发针对过程。 B、面向对象的软件开发针对对象。 C、可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。 2.3、单元测试工具和框架 目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpU nit（Php ）等等。该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设
计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人）提供的开放源代码的JUnit。 3.Junit入门简介 3.1、JUnit的好处和JUnit单元测试编写原则 好处： A、可以使测试代码与产品代码分开。 B、针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。 C、易于集成到测试人员的构建过程中，JUnit和Ant的结合可以实施增量开发。 D、JUnit是公开源代码的，可以进行二次开发。 C、可以方便地对JUnit进行扩展。 编写原则： A、是简化测试的编写，这种简化包括测试框架的学习和实际测试单元的编写。 B、是使测试单元保持持久性。 C、是可以利用既有的测试来编写相关的测试。 3.2、JUnit的特征 A、使用断言方法判断期望值和实际值差异，返回Boolean值。 B、测试驱动设备使用共同的初始化变量或者实例。 C、测试包结构便于组织和集成运行。 D、支持图型交互模式和文本交互模式。 3.3、JUnit框架组成 A、对测试目标进行测试的方法与过程集合，可称为测试用例(TestCase)。 B、测试用例的集合，可容纳多个测试用例(TestCase)，将其称作测试包(T estSuite)。 C、测试结果的描述与记录。(TestResult) 。 D、测试过程中的事件监听者(TestListener)。
实验二Junit单元测试实验报告 实验内容：利用Junit对实验程序Point2d.java进行单元测试 实验目的：掌握单元测试的方法，掌握在Eclipse里进行Junit测试的技术。 实验步骤和结果： 1、修改之前的Calculator的测试结果： (1)自动生成的CalculatorTest类代码： package andycpp; public class Calculator { private static int result; // 静态变量，用于存储运行结果 public void add(int n) { result = result + n; } public void substract(int n) { result = result - 1; //Bug: 正确的应该是 result =result-n } public void multiply(int n) { } // 此方法尚未写好 public void divide(int n) { result = result / n; } public void square(int n) { result = n * n; } public void squareRoot(int n) { for (; ;) ; //Bug : 死循环 } public void clear() { // 将结果清零 result = 0; } public int getResult() { return result; } }
(2)运行结果： 自动生存的测试类 完善测试类后的运行结果
如何使用junit4写单元测试用例 2014年8月21日posted by 大岩不灿 in 编程语言 JUnit4是JUnit框架有史以来的最大改进，其主要目标便是利用Java5的Annotation特性简化测试用例的编写。 先简单解释一下什么是Annotation，这个单词一般是翻译成元数据。元数据是什么？元数据就是描述数据的数据。也就是说，这个东西在Java里面可以用来和public、static等关键字一样来修饰类名、方法名、变量名。修饰的作用描述这个数据是做什么用的，差不多和public描述这个数据是公有的一样。想具体了解可以看Core Java2。废话不多说了，直接进入正题。 我们先看一下在JUnit 3中我们是怎样写一个单元测试的。比如下面一个类： public class AddOperation { public int add(int x,int y){ return x+y; } } 我们要测试add这个方法，我们写单元测试得这么写： import junit.framework.TestCase; import static org.junit.Assert.*; public class AddOperationTest extends TestCase{ public void setUp() throws Exception { } public void tearDown() throws Exception { } public void testAdd() { System.out.println(\”add\”); int x = 0; int y = 0; AddOperation instance = new AddOperation(); int expResult = 0; int result = instance.add(x, y); assertEquals(expResult, result); } } 可以看到上面的类使用了JDK5中的静态导入，这个相对来说就很简单，只要在import关键字后面加上static关键字，就可以把后面的类的static的变量和方法导入到这个类中，调用的时候和调用自己的方法没有任何区别。 我们可以看到上面那个单元测试有一些比较霸道的地方，表现在： 1.单元测试类必须继承自TestCase。 2.要测试的方法必须以test开头。 如果上面那个单元测试在JUnit 4中写就不会这么复杂。代码如下： import junit.framework.TestCase;