http://junit.org/上详细介绍了Junit。JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.(Junit是一个可用于编写可复用测试集的简单框架,是xUnit的一个子集,而xUnit是一个基于测试驱动开发的测试框架(例如面向python的PythonUnit、面向C++的CppUnit和面向Java的单元测试框架Junit)),Junit的源代码托管在了github上https://github.com/junit-team/junit。java doc地址:http://junit.org/javadoc/latest/index.html

  这个页面提供了快速上手的示例https://github.com/junit-team/junit/wiki/Getting-started

  Junit使用断言机制将程序的运行结果和我们预期的结果进行比对。

快速上手

  由于Eclipse中集成了Junit4,所以我们不需要单独下载jar包。

  首先,建立一个被用于测试的类:

 package org.gpf.util;
/**
* 被测试的类
* 包含+、-、*、/的4个方法
*/
public class Calculate { public int add(int num1,int num2){
return num1 + num2;
} public int sub(int num1,int num2){
return num1 - num2;
} public int mul(int num1,int num2){
return num1 * num2;
} public int div(int num1,int num2){
return num1 / num2;
}
}

  然后,导入Junit4的jar包。在项目中单击右键--->BuildPath--->Add Libraries--->Juint.

  接下来,在当前包中新建一个测试用例。在被测试类所在的包中右键--->新建--->Juint Test Case。如下图所示

  Eclipse会自动为我们生成模板:

 package org.gpf.util;

 import static org.junit.Assert.*;

 import org.junit.Test;

 public class CalculateTest {

     @Test
public void test() {
fail("Not yet implemented");
} }

  接下来仿照以上的模板,测试自己的方法:

 package org.gpf.util;

 import static org.junit.Assert.*;

 import org.junit.Test;

 public class CalculateTest {

     @Test
public void testAdd(){
assertEquals(9, new Calculate().add(3, 6)); // 断言3+6 = 9
}
}

  最后,运行测试用例(Run As Junit Test)

Junit使用详解

  在以上的简单上手的示例中将程序的源代码和测试代码放在同一目录下,这样就比较混乱。一个最佳实践就是在项目下新建一个test源代码目录,在test目录下新建新建测试用例,当产品测试完成上线之后删除test目录即可。

  

 package org.gpf.util;

 import static org.junit.Assert.*;

 import org.junit.Test;

 public class CalculateTest {

     @Test
public void testAdd(){
assertEquals(9, new Calculate().add(3, 6)); // 断言3+6 = 9
} @Test
public void testSub(){
assertEquals(0, new Calculate().sub(3, 6));// 断言3-6 =0
} @Test
public void testMul(){
assertEquals(18, new Calculate().mul(3, 6));// 断言3*6 = 18
} @Test
public void testDiv(){
assertEquals(9, new Calculate().div(3, 6)); // 断言3/6 = 9
}
}

  在Eclipse中右键Run As Junit Test,将会测试所有的方法。如果只需要测试特定的方法只需要在包视图中选定特定的方法,运行Junit测试即可。

  总结:

  1. 测试方法必须使用@Test注解;
  2. 测试方法必须使用public void进行修饰,不能带任何的参数;
  3. 新建源代码目录来存放我们的测试代码;
  4. 测试类的包应该和被测试类保持一致;
  5. 测试单元中的每个方法必须可以独立测试,测试方法见不能存在任何的依赖;
  6. 测试类推荐使用Test最为类名的后缀;
  7. 测试方法推荐使用test作为方法名的前缀。

测试失败的2种情况

  “测试用例不是用来证明你是对的,而是用来证明你没有错。”——测试用例用来表达预期结果,但对于逻辑错误却无能为力。

  新建一个测试用例,命名为ErrorAndFailureTest,测试add方法:

 public class ErrorAndFailureTest {

     @Test
public void testAdd(){
assertEquals(10, new Calculate().add(3, 6)); // 断言3+6 = 10
} }

  运行此测试用例:

  现在注释掉testAdd测试方法,加入testDiv测试方法,在testDiv方法中我们断言3/0=9.

 public class ErrorAndFailureTest {

     @Test
public void testDiv(){
assertEquals(9, new Calculate().div(3, 0)); // 断言3/0 = 9
}
}

  运行此测试用例,

小结:

  1. Failure一般是由单元测试使用的断言方法判断失败所引起的,表名测试点发现了问题,就是说程序的输出结果和我们预期的不一样。
  2. Error是由代码异常引起的,它可以产生于测试代码本身的错误,也可以是被测试代码中的一个隐藏的bug;
  3. 测试用例不是用来证明你是对的,而是用来证明你没有错。

Junit的运行流程

  打开开发工具,新建一个Junit Test Case,选中4个方法:

  我们在它自动生成的4个方法中各打印一句话,同时加入两个我们自己的测试方法:

 package org.gpf.util;

 import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test; public class JunitFlowTest { @BeforeClass
public static void setUpBeforeClass() throws Exception {
System.out.println("这是BeforeClass---静态方法");
} @AfterClass
public static void tearDownAfterClass() throws Exception {
System.out.println("这是AfterClass---静态方法");
} @Before
public void setUp() throws Exception {
System.out.println("这是Before");
} @After
public void tearDown() throws Exception {
System.out.println("这是After");
} @Test
public void test1(){
System.out.println("这是test1");
} @Test
public void test2(){
System.out.println("这是test2");
}
}

小结

  1. @BeforeClass修饰的方法会在所有的方法被调用前执行,而且该方法是静态的,所以当测试类被加载后会接着运行它,在内存中只存在一份实例。比较适合加载一些配置文件。
  2. @AfterClass所修饰的方法通常用来对资源的清理。例如:关闭DB连接。
  3. @Before和@After会在每个测试方法的前后各执行一次。
  4. @BeforeClass和@AfterClass是固定代码,一定会被执行到。

Junit的常用注解

注解 说明
@Test 将一个普通的方法修饰成为测试方法。(expected=XX.class,用于预期捕获某种异常,使其通过测试;timeout=毫秒,用于对方法的运行时间进行限定,防止死循环和进行性能测试)
@BeforeClass 在所有的方法运行前被执行,static修饰
@afterClass 在所有的方法运行后被执行,static修饰
@Before 每个测试方法运行前执行
@After 每个测试方法运行后执行
@Ignore 所修饰的方法会被测试运行器忽略
@RunWith 可以更改测试运行器,自定义自己的运行器需要继承org.junit.runner.Runner抽象类。但是一般情况下使用默认的测试运行器即可
 public class AnnotationTest {

     @Test(expected=ArithmeticException.class)
public void testDiv(){
assertEquals(9, new Calculate().div(3, 0)); // 断言3/0 = 9
} }

  在以上的程序中我们断言3/0 = 9,运行Junit本身应该是红色,但是运行以上程序,发现Junit的状态条变成了绿色,测试竟然通过了!

 /**
* 防止出现死循环
*/
@Test(timeout=3000)
public void testWhile(){
while (true) {
System.out.println("此段代码永远运行!");
}
} /**
* 性能测试:读取文件的操作必须在3s内完成
*/
@Test(timeout=3000)
public void testReadFile(){
try {
Thread.sleep(2000); // 模拟读文件需要2s
} catch (InterruptedException e) {
e.printStackTrace();
}
}

  加入@Ignore注解的方法会被测试运行器忽略:

 public class AnnotationTest {

     @Test(expected=ArithmeticException.class)
public void testDiv(){
assertEquals(9, new Calculate().div(3, 0)); // 断言3/0 = 9
} /**
* 防止出现死循环,加上@Ignore后会被测试运行器忽略
*/
@Ignore("该方法被测试忽略")
@Test(timeout=3000)
public void testWhile(){
while (true) {
System.out.println("此段代码永远运行!");
}
} /**
* 性能测试:读取文件的操作必须在2s内完成
*/
@Test(timeout=3000)
public void testReadFile(){
try {
Thread.sleep(2000); // 模拟读文件需要2s
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Junit深入使用

测试套件的使用

  使用测试套件可以将多个测试类集成到一个测试套件中,这样需要验证系统功能的时候只需要执行一次测试套件即可。需要将多个测试类集成到一个测试套件中只需要在测试所在的包上右键--->New--->Junit--->JunitTestCase即可。

 package org.gpf.util;

 import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses; @RunWith(Suite.class)
@SuiteClasses({ AnnotationTest.class, CalculateTest.class,
ErrorAndFailureTest.class, JunitFlowTest.class })
public class AllTests { }

  

  测试套件中可以包含其他的测试套件,直接像包含测试类那样在@SuiteClasses中加入测试套件的类名即可。

编写一个测试套件的步骤:

  1. 写一个作为测试套件的入口类,这个类中不包含其他的方法;
  2. 更改测试运行器(@RunWith())为Suite.class;
  3. 将测试类作为数组传递到@SuiteClasses({})中。

Junit参数化设置

  对于相同的测试方法,例如加法操作,如果我们要进行多组数据的加法操作,就需要写多个测试加法的方法。代码结构都是相同的,不同的仅仅是测试的数据和预期值。Junit4可以通过参数化配置提高代码的可重用度。

  

 import static org.junit.Assert.*;

 import java.util.Arrays;
import java.util.Collection; import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters; @RunWith(Parameterized.class)
public class ParameterTest { int expected = 0;
int input1 = 0;
int input2 = 0; @Parameters
public static Collection<Object[]> t(){ return Arrays.asList(new Object[][]{
{3,1,2},
{4,2,2},
{9,3,3}
});
} /**
* 提供一个构造方法,初始化预期值和2个输入数据
* @param expected 预期值
* @param input1 输入参数1
* @param input2 输入参数2
*/
public ParameterTest(int expected,int input1,int input2) {
this.expected = expected;
this.input1 = input1;
this.input2 = input2;
} @Test
public void addTest(){
assertEquals(expected, new Calculate().add(input1, input2)); // 该测试方法将对3组测试用例进行测试
}
}

  配置参数化测试的步骤:

  1. 更改默认的测试运行器为@RunWith(Parameterized.class);
  2. 声明变量来存放预期值和输入参数;
  3. 声明一个返回值为Collection的公共静态方法,并使用@Parameters注解修饰;
  4. 为测试类声明一个带有参数的公共构造方法,在构造方法中为声明变量赋值。

使用Junit整合Spring和Hibernate

  待续。。。。。

Junit使用详解的更多相关文章

  1. junit 常用注解 + junit 断言详解

    @Test: 在junit3中,是通过对测试类和测试方法的命名来确定是否是测试,且所有的测试类必须继承junit的测试基类.在junit4中,定义一个测试方法变得简单很多,只需要在方法前加上@Test ...

  2. 单元测试junit框架详解

    首先在给出一个类Operator,加入如下代码: public class Operator { // 加法 运算 public int add(int i,int j){ return i+j; } ...

  3. 详解intellij idea搭建SSM框架(spring+maven+mybatis+mysql+junit)(下)

    在上一篇(详解intellij idea 搭建SSM框架(spring+maven+mybatis+mysql+junit)(上))博文中已经介绍了关于SSM框架的各种基础配置,(对于SSM配置不熟悉 ...

  4. [原创]mybatis详解说明

    mybatis详解 2017-01-05MyBatis之代理开发模式1 mybatis-Dao的代理开发模式 Dao:数据访问对象 原来:定义dao接口,在定义dao的实现类 dao的代理开发模式 只 ...

  5. (十)Maven依赖详解

    1.何为依赖? 比如你是个男的,你要生孩子,呸呸呸...男的怎么生孩子,所以你得依赖你老婆,不过也不一定咯,你也可以依赖其她妹子. 我们在平时的项目开发中也是同理,你需要依赖一些东西才能实现相应的功能 ...

  6. Myeclipse Templates详解(一) —— Java模板基础

    目录 Templates简介 MyEclipse自带Templates详解 新建Template 自定义Template 因为自己比较懒,尤其是对敲重复代码比较厌恶,所以经常喜欢用快捷键和模板,Mye ...

  7. Spring jar包详解

    Spring jar包详解 org.springframework.aop ——Spring的面向切面编程,提供AOP(面向切面编程)的实现 org.springframework.asm——spri ...

  8. Spring——jar包详解(转)

    Spring——jar包详解 org.springframework.aop ——Spring的面向切面编程,提供AOP(面向切面编程)的实现 org.springframework.asm——spr ...

  9. Spring 3.x jar 包详解 与 依赖关系

    以下的内容我会持续更新(当然是我有新发现的时候); 以下内容是我在网上搜索.整理.修改的而成的内容.由于很多内容都是转载了,无法追溯到源头,因此无法一一对原作者进行道谢. 这几天,我查阅大量的官方的文 ...

随机推荐

  1. Apple 远程推送APNS 服务

    APP注册APNS流程 http://mobiforge.com/design-development/programming-apple-push-notification-services 服务器 ...

  2. 图片转成base64, base64转成图片

    1.我们在看代码时经常在img或css背景图片中看到: src=”data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4CAMAAAAOusbgA ...

  3. ES6 变量解构用法

    1.数组解构,可以设置默认值 'use strict'; let [x, y = 'b'] = ['a']; //控制台输出b console.log(y); 2.对象解构 'use strict'; ...

  4. jsfiddle在线測试Html、CSS、JavaScript——http://jsfiddle.net/

    jsfiddle在线測试Html.CSS.JavaScript,并展示測试结果 1.选择jQuery1.9.1 2.选择jQuery UI 1.9.2 3.Html <ul id="n ...

  5. (七)Oracle学习笔记—— 游标

    1.游标简介 游标用来处理从数据库中检索的多行记录(使用SELECT语句).利用游标,程序可以逐个地处理和遍历一次检索返回的整个记录集. 为了处理SQL语句,Oracle将在内存中分配一个区域,这就是 ...

  6. oracle 使用REGEXP_SUBSTR正则表达式拆分字符串

    SELECT REGEXP_SUBSTR ('first field, second field , third field', '[^,]+', 1,rownum) FROM DUAL CONNEC ...

  7. NE2018届校招内推笔试——数据挖掘

    [单选题|2分/题] 1.在只有两类的情况下,二维特征向量通过共享相同的协方差矩阵的正态分布生成,其中协方差矩阵为: 均值向量分别为:,则根据贝叶斯分类,样本分类为:() A. 分类2 B. 无法确定 ...

  8. 【转】C# 视频监控系列(12):H264播放器——播放录像文件

    原文地址:http://www.cnblogs.com/over140/archive/2009/03/23/1419643.html?spm=5176.100239.blogcont51182.16 ...

  9. Asp.Net MVC4的学习概况

    周一正式开始了毕业工作.然后学习调试了近4天,刚刚总算在同事的帮助下做出了一个基于Asp.Net MVC4的Hello World显示. 这是一篇最为基础的记录教程,记录内容可能有点混乱,旨在能在刚调 ...

  10. 算法----堆排序(heap sort)

    堆排序是利用堆进行排序的高效算法,其能实现O(NlogN)的排序时间复杂度,详细算法分析能够点击堆排序算法时间复杂度分析. 算法实现: 调整堆: void sort::sink(int* a, con ...