Java Junit测试框架

                                                Java    Junit测试框架

一、相关概念

Ø JUnit：是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。它是用于单元测试框架体系xUnit的一个实例（用于java语言）。主要用于白盒测试，回归测试。
Ø 白盒测试：把测试对象看做一个打开的盒子，程序内部的逻辑结构和其余信息对测试人
员是公开的。
Ø 回归测试：软件或环境的修复或更正后的再测试，自动测试工具对这类测试尤为有用。
Ø 单元测试：最小粒度的测试，以测试某个功能或代码块。通常由程序员来作，由于它须要知道内部程序设计和编码的细节。

二、 单元测试

2.一、单元测试的好处
Ø 提升开发速度，测试是以自动化方式执行的，提高了测试代码的执行效率。
Ø 提升软件代码质量，它使用小版本发布至集成，便于实现人员除错。同时引入重构概念，让代码更干净和富有弹性。
Ø 提高系统的可信赖度，它是回归测试的一种。支持修复或更正后的“再测试”，可确保代码的正确性。

2.二、单元测试的针对对象
Ø 面向过程的软件开发针对过程。
Ø 面向对象的软件开发针对对象。
Ø 能够作类测试，功能测试，接口测试（最经常使用于测试类中的方法）。

2.三、单元测试工具和框架
目前的最流行的单元测试工具是xUnit系列框架，经常使用的根据语言不一样分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（PHP ）等等。
单元测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的做者）和Kent Beck（XP（Extreme Programming）的创始人 ）提供的开放源代码的JUnit。

三、Junit入门简介

3.一、JUnit的好处和JUnit测试编写原则
使用JUnit的好处：
Ø 可使测试代码与产品代码分开。
Ø 针对某一个类的测试代码经过较少的改动即可以应用于另外一个类的测试。
Ø 易于集成到测试人员的构建过程当中，JUnit和Ant的结合能够实施增量开发。
Ø JUnit是公开源代码的，能够进行二次开发。
Ø 能够方便地对JUnit进行扩展。

JUnit测试编写原则：
Ø 简化测试的编写，这种简化包括测试框架的学习和实际测试单元的编写。
Ø 使测试单元保持持久性。
Ø 能够利用既有的测试来编写相关的测试。

3.二、JUnit的特征
Ø 使用断言方法判断指望值和实际值差别，返回Boolean值。
Ø 测试驱动设备使用共同的初始化变量或者实例。
Ø 测试包结构便于组织和集成运行。
Ø 支持图型交互模式和文本交互模式。

3.3 JUnit框架组成
Ø 对测试目标进行测试的方法与过程集合，可称为测试用例(TestCase)。
Ø 测试用例的集合，可容纳多个测试用例(TestCase)，将其称做测试包(TestSuite)。
Ø 测试结果的描述与记录。(TestResult) 。
Ø 测试过程当中的事件监听者(TestListener)。
Ø 每个测试方法所发生的与预期不一致情况的描述，称其测试失败元素(TestFailure)
Ø JUnit Framework中的出错异常（AssertionFailedError）。

    JUnit框架是一个典型的Composite模式：TestSuite能够容纳任何派生自Test的对象；当调用TestSuite对象的run()方法是，会遍历本身容纳的对象，逐个调用它们的run()方法。3.5 JUnit中经常使用的接口和类

Ø Test接口：运行测试和收集测试结果

    Test接口使用了Composite设计模式，是单独测试用例（TestCase），聚合测试模式（TestSuite）及测试扩展（TestDecorator）的共同接口。 它的public int countTestCases（）方法，用来统计测试时有多少个TestCase。另一个方法就是public void　run（ TestResult ），TestResult是实例接受测试结果， run方法执行本次测试。

Ø TestCase抽象类：定义测试中固定方法

    TestCase是Test接口的抽象实现，（不能被实例化，只能被继承）其构造函数TestCase(string name)根据输入的测试名称name建立一个测试实例。因为每个TestCase在建立时都要有一个名称，若测试失败了，即可识别出是哪一个测试失败。
TestCase类中包含的setUp()、tearDown()方法。

    setUp()方法集中初始化测试所需的全部变量和实例，而且在依次调用测试类中的每一个测试方法以前再次执行setUp()方法。
tearDown()方法则是在每一个测试方法以后，释放测试程序方法中引用的变量和实例。

    开发人员编写测试用例时，只需继承TestCase，来完成run方法便可，而后JUnit得到测试用例，执行它的run方法，把测试结果记录在TestResult之中。

Ø Assert静态类：一系列断言方法的集合

    Assert包含了一组静态的测试方法，用于指望值和实际值比对是否正确，即测试失败，Assert类就会抛出一AssertionFailedError异常，JUnit测试框架将这种错误纳入Failes并加以记录，同时标志为未经过测试。若是该类方法中指定一个String类型的传参则该参数将被作为AssertionFailedError异常的标识信息，告诉测试人员改异常的详细信息。

    JUnit 提供了6大类31组断言方法，包括基础断言、数字断言、字符断言、布尔断言、对象断言。其中assertEquals（Object expcted,Object actual)内部逻辑判断使用equals()方法，这代表断言两个实例的内部哈希值是否相等时，最好使用该方法对相应类实例的值进行比较。

    而assertSame（Object expected,Object actual）内部逻辑判断使用了Java运算符“==”，这代表该断言判断两个实例是否来自于同一个引用（Reference），最好使用该方法对不一样类的实例的值进行比对。
asserEquals(String message,String expected,String actual)该方法对两个字符串进行逻辑比对，若是不匹配则显示着两个字符串有差别的地方。

    ComparisonFailure类提供两个字符串的比对，不匹配则给出详细的差别字符。

Ø TestSuite测试包类??多个测试的组合

    TestSuite类负责组装多个Test Cases。待测得类中可能包括了对被测类的多个测试，而TestSuit负责收集这些测试，使咱们能够在一个测试中，完成所有的对被测类的多个测试。TestSuite类实现了Test接口，且能够包含其它的TestSuites。它能够处理加入Test时的全部抛出的异常。

TestSuite处理测试用例有6个规约（不然会被拒绝执行测试）
² 测试用例必须是公有类（Public）
² 用例必须继承与TestCase类
² 测试用例的测试方法必须是公有的（ Public ）
² 测试用例的测试方法必须被声明为Void
² 测试用例中测试方法的前置名词必须是test
² 测试用例中测试方法误任何传递参数

Ø TestResult结果类和其它类与接口
    TestResult结果类集合了任意测试累加结果，经过TestResult实例传递个每一个测试的Run（）方法。TestResult在执行TestCase是若是失败会异常抛出。 

    TestListener接口是个事件监听规约，可供TestRunner类使用。它通知listener的对象相关事件，方法包括测试开始startTest(Test test)，测试结束endTest(Test test),错误，增长异常addError(Test test,Throwable t)和增长失败addFailure(Test test,AssertionFailedError t)。

    TestFailure失败类是个“失败”情况的收集类，解释每次测试执行过程当中出现的异常状况。其toString()方法返回“失败”情况的简要描述

四、Eclipse中JUnit的使用

    测试对于保证软件开发质量有着很是重要的做用，单元测试更是必不可少，JUnit是一个很是强大的单元测试包，能够对一个/多个类的单个/多个方法测试，还能够将不一样的TestCase组合成TestSuit，使测试任务自动化。
Eclipse一样集成了JUnit，能够很是方便地编写TestCase。Eclipse自带了一个JUnit的插件，不用安装就能够在你的项目中开始测试相关的类，而且能够调试你的测试用例和被测试类。

4.一、Eclipse中JUint使用步骤

如下步骤环境为Eclipse SDK 3.2.2及JUnit3.8.1
Ø 新建一个测试用例或选择已有的所想测试的JAVA文件，点击“File->New->…”菜单项或右击文件，在弹出的“New”对话框中选择“JUnit Test Case”，就进入“New JUnit Test Case”对话框

Ø 在“New JUnit TestCase”对话框填写相应的栏目，主要有Name（测试用例名），SuperClass（若JUnit的版本是3.8.1，则测试的超类通常默认为junit.framework.TestCase； 若JUnit版本是JUnit 4.4，则默认超类为java.lang.Object。），Class Under Test（被测试的类），Source Folder（测试用例保存的目录），Package（测试用例包名），及是否自动生成main，setUp，tearDown方法。在此通常填写NAME及选上复选上setUpt和teardown便可。

Ø 点击“Next>”按钮，则进入Test Methods，在此你能够直接勾选你想测试的被测试类的方法，Eclipse将自动生成与被选方法相应的测试方法，点击“Fishish”按钮后一个测试用例就建立好了。

Ø 编写完成测试用例后，点击“Run”按钮就能够看到运行结果了。

    补充：要使用JUnit，您必须首先将JUnit JAR保存在项目的Build路径上并建立一个测试类。将JUnit保存在项目的Build路径上的步骤为：

    右击项目—>选择菜单底部的Properties选择Java Build Path—>选择Libraries—>点击Add Variable按钮—>查看已有的列表中有无JUnit文件，若没有，则点击Configure Variable—>New按钮，输入JUNIT_LIB做为变量名称，编辑该变量并指向解压后的JUnit目录中的一个名为JUnit.jar的文件—>而后在选择刚才添加的jar文件依次点击OK便可。

4.二、Eclipse中JUnit应用示例

    下面咱们做一个在Eclipse中利用JUnit对HelloWorld的测试 测试方法：
Ø HelloWorld.sayHello()是否执行正常，而且结果也符合要求
Ø HelloWorld.add()方法是否与咱们预期同样执行

    下一步，咱们准备对这两个方法进行测试，确保功能正常。选中HelloWorld.java，右键点击，选择New->JUnit Test Case：

    进入下面这个页面，在此诸多栏目已经填好，便是这个须要测试的文件的相关信息，如果想在测试完以后即删除测试文件，也可更改路径。（本机在Eclipse已有的JUnit3.8.1的基础上又添加了一个新版本JUnit4.4）

    点击Next进入Test Methods，在此选择所要测试的方法sayHello及add。

    点击Finish，最后编写完成测试用例代码以下：

    直接运行Run->Run As->JUnit Test，就能够看到JUnit测试结果：

    绿色表示测试经过，只要有1个测试未经过，就会显示红色并列出未经过测试的方法。

五、后记

    从上面的来看，JUnit的使用并不很难，但关键就是最后一步完成测试码，即编写TestCase。要编写一个好的TestCase却并不是易事。一个很差的TestCase每每是既浪费了时间，也起不了实际的做用。相反，一个好的TestCase，不只能够很好的指出代码中存在的问题，并且也能够做为代码更准确的文档，同时还在持续集成的过程当中起很是重要的做用。咱们在做测试写TestCase时须要注意的几点：

Ø 测试的独立性：一次只测试一个对象，方便定位出错的位置。这有两层意思：一个TestCase，只测试一个对象；一个TestMethod，只测试这个对象中的一个方法。

Ø 给测试方法一个合适的名字。 通常取名为原来的方法名后加一个Test。

Ø 在assert函数中给出失败的缘由，如：assertTrue( “… should be true”, ……)，方便查错。在这个例子中，若是没法经过assertTrue，那么给出的消息将被显示。在junit中每一个assert函数都有第一个参数是出错时显示消息的函数原型。

Ø 测试全部可能引发失败的地方，如：一个类中频繁改动的函数。对于那些仅仅只含有getter/setter的类，若是是由IDE（如Eclipse）产生的，则可不测；若是是人工写，那么最好测试一下。

Ø 在setUp和tearDown中的代码不该该是与测试方法相关的，而应该是全局相关的。如针对与测试方法A和B，在setUp和tearDown中的代码应该是A和B都须要的代码。

Ø 测试代码的组织：相同的包，不一样的目录。这样，测试代码能够访问被测试类的protected变量/方法，方便测试代码的编写。放在不一样的目录，则方便了测试代码的管理以及代码的打包和发布。

阐述JUnit的测试流程架构。咱们将从不一样的角度来详细分析这个图。

图 测试序列图

 

 

TestNG和JUnit是针对Java语言的两个比较经常使用的测试框架。JUnit出现的比较早，可是早期的JUnit 3对测试代码有很是多的限制，使用起来很不方便，后来的JUnit 4获得很大的改进。TestNG的出现介于JUnit 3和JUnit 4，可是TestNG在不少方面还要优于JUnit 4。下面从总体上对TestNG和JUnit 4进行比较全面的比较。


　　TestNG与JUnit的相同点：
1. 使用annotation，且大部分annotation相同。
2. 均可以进行单元测试（Unit test）。
3. 都是针对Java测试的工具。


　　TestNG与JUnit的不一样点：
1. JUnit只能进行单元测试，TestNG能够进行单元测试(unit test)，功能测试(function test)，端到端测试(e2e test)，集成测试(Integration test)等。
2. TestNG须要一个额外的xml配置文件，配置测试的class、method甚至package。
3. TestNG的运行方式更加灵活：命令行、ant和IDE，JUnit只能使用IDE。
4. TestNG的annotation更加丰富，好比@ExpectedExceptions、@DataProvider等。
5. 测试套件运行失败，JUnit 4会从新运行整个测试套件。TestNG运行失败时，会建立一个XML文件说明失败的测试，利用这个文件执行程序，就不会重复运行已经成功的测试。


　　TestNG比JUnit 4灵活性的体现：
1. JUnit 4中必须把@BeforeClass修饰的方法声明为public static，这就限制了该方法中使用的变量必须是static。而TestNG中@BeforeClass修饰的方法能够跟普通函数彻底同样。
2. JUnit 4测试的依赖性很是强，测试用例间有严格的前后顺序。前一个测试不成功，后续全部的依赖测试都会失败。TestNG 利用@Test 的dependsOnMethods属性来应对测试依赖性问题。某方法依赖的方法失败，它将被跳过，而不是标记为失败。
3. 对于n个不一样参数组合的测试，JUnit 4要写n个测试用例。每一个测试用例完成的任务基本是相同的，只是受测方法的参数有所改变。TestNG的参数化测试只须要一个测试用例，而后把所须要的参数加到TestNG的xml配置文件中。这样的好处是参数与测试代码分离，非程序员也能够修改参数，同时修改无需从新编译测试代码。
4. 为了测试没法用String或原语值表示的复杂参数化类型，TestNG提供的@DataProvider使它们映射到某个测试方法。
5. JUnit 4的测试结果经过Green/Red bar体现，TestNG的结果除了Green/Red bar，还有Console窗口和test-output文件夹，对测试结果的描述更加详细，方便定位错误。


　　简单说就是TestNG比Junit强大, 可是那些更强大的功能你所有都用不到的话, 那你仍是就用junit, 比较简单, 国人用的多, 出了问题中文也比较好查.  英文还不错而且有想要了解除了单元测试之外的测试的话, 就用TestNG吧。

详解Java单元测试Junit框架实例

主要介绍了Java的异常测试框架JUnit使用上手指南,JUnit是Java代码进行单元测试中的经常使用工具,

 

问题：

一、目前测试存在的问题

二、Junit注意的细节

三、Junit使用规范

四、断言

五、案例

junit(单元测试框架)

一、目前存在的问题

一、目前的测试方法若是须要测试，都须要在main方法上调用

二、目前的结果都须要咱们人工比对

二、Junit 注意的细节

一、若是使用junit测试一个方法的时候，在junit窗口上显示绿色那么表示测试正确，若是显示了红色，则表明该方法测试出现了异常不经过

二、若是点击方法名、类名、包名、工程名运行junit分别测试的是对于的方法，类、包中的全部类的test方法，工程中全部test的方法

三、@Test测试的方法不能是static修饰与不能带有形参

四、若是测试一个方法的时候须要准备测试的环境或者是清理测试的环境，那么能够@Before、@After、@BeforeClass、@AfterClass 这四个注释，@Before、@After 是在每一个测试方法测试的时候都会调用一次，@AfterClass、@BeforeClass是在全部的测试方法测试以前与以后都会调用一次，这个方法必须是静态的

三、junit使用规范

一、一个类若是须要测试，那么该类就应该对应着一个测试类，测试类的命名规范：被测试类的类名+Test

二、一个被测试的方法通常对应一个测试的方法，测试的方法的命名规范是：test+被测试的方法的方法名

四、断言

断言就是不显示结果，按照程序运行的预期值和实际值进行比对，显示运行的状态。

?

1 2 3 4 5

Assert.assertSame( 5 , max); // 底层是用了  == Assert.assertSame( new String( "abc" ), "abc" ); Assert.assertEquals( new String( "abc" ), "abc" ); //底层是使用Equals方法比较的 Assert.assertNull( "aa" ); Assert.assertTrue( true );

五、案例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

package cn.xlucas.junit; import java.io.*; import org.junit.*; public class JunitDemo1 {   //准备测试的环境   //@Before   @BeforeClass   public static void beforeRead(){     System.out.println("准备测试环境成功...");   }   //读取文件数据，把把文件数据都   @Test   public void readFile() throws IOException{     FileInputStream fileInputStream = new FileInputStream("F:\\a.txt");     int content = fileInputStream.read();     System.out.println("内容："+content);   }   @Test   public void sort(){     System.out.println("读取文件数据排序..");   }    //清理测试环境的方法 // @After    @AfterClass   public static void afterRead(){     System.out.println("清理测试环境..");   } }

1、JUnit4是JUnit框架有史以来的最大改进，其主要目标即是利用Java5的Annotation特性简化测试用例的编写。

 

2、先简单解释一下什么是Annotation，这个单词通常是翻译成元数据。元数据是什么？元数据就是描述数据的数据。也就是说，这个东西在Java里面能够用来和public、static等关键字同样来修饰类名、方法名、变量名。修饰的做用描述这个数据是作什么用的，差很少和public描述这个数据是公有的同样

 

3、对Person类的方法进行测试：

 

测试类Person：

 

package com.ren.junit;

public class Person {

    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

测试该类的方法PersonTest:

package com.ren.junit;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

//对Person类进行测试
public class PersonTest {

    private Person p;

    @BeforeClass
    public static void beforeClass() {
        System.out.println("boforeClass");
    }

    @Before
    public void before() {
        p = new Person("lisi",20);
        System.out.println("before");
    }

    @Test
    public void testGetName() {

        System.out.println(p.getName());
    }

    @Test
    public void testGetAge() {

        System.out.println(p.getAge());
    }

    @After
    public void after() {
        System.out.println("after");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("afterClass");
    }
}

输出结果：
boforeClass
before
lisi
after
before
20
after
afterClass

如下是转载：

咱们先看一下在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;
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);
      }

}

咱们能够看到，采用Annotation的JUnit已经不会霸道的要求你必须继承自TestCase了，并且测试方法也没必要以test开头了，只要以@Test元数据来描述便可。
从上面的例子能够看到在JUnit 4中还引入了一些其余的元数据，下面一一介绍：
@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(“该方法尚未实现”)，在执行的时候，仅会报告该方法没有实现，而不会运行测试方法。

 

 

junit测试是如今编写测试代码的手段之一,本文简要介绍如何快速搭建一个junit测试环境.

 

工具/原料

 

• eclipse工具
• junit包

 

方法/步骤

 

 

 

1. 1

   首先建立一个java Project；将junit包和hamcrest-core包导入到项目中
2. 2

   建立一个source folder 资源文件夹 test，资源文件夹和普通的文件夹区别是，资源文件夹中的java文件能够被自动编译。
3. 3

   在java文件中编写java代码UserMananger.java，在test文件中建立一个与须要进行测试的java代码同包名称的TestUserManager.java文件。
4. 4

   junit4采用的是经过注解的方式（在方法的上面加上@）.

   @Before表示在全部方法运行前运行的方法;

   @After表示在全部的方法运行以后执行的方法;

   @Test表示这是一个测试方法

   @BeforeClass表示在这个测试类构造以前执行的方法

   @AfterClass表示在这个测试类构造以后执行的方法
5. 5

   若是是对某一个方法进行测试，在方法的名称上点击右键 --> run as --> JUnit Test
6. 6

   若是是对全部的方法都执行一遍,在类体上右键--Run as--> JunitTest .

   绿色的表示运行经过的方法,红x的表示运行失败的方法.

    

    

   本文简要介绍一下在 Eclipse3.2 中使用 JUnit4 进行单元测试的方法。

   首先，咱们来一个傻瓜式速成教程，不要问为何，Follow Me，先来体验一下单元测试的快感！

   首先新建一个项目叫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() {     // 将结果清零
           result = 0;
       }
       public int getResult() {
           return result;
       }
   }

   第二步，将JUnit4单元测试包引入这个项目：在该项目上点右键，点“属性”，如图：

    

   
   在弹出的属性窗口中，首先在左边选择“ Java Build Path ”，而后到右上选择“ Libraries ”标签，以后在最右边点击“ Add Library… ”按钮，以下图所示：
   
   
   而后在新弹出的对话框中选择 JUnit4 并点击肯定，如上图所示， JUnit4 软件包就被包含进咱们这个项目了。
   
       第三步，生成 JUnit 测试框架：在 Eclipse 的 Package Explorer 中用右键点击该类弹出菜单，选择“ New à JUnit Test Case ”。以下图所示：
   
   
   在弹出的对话框中，进行相应的选择，以下图所示：
   
   
       点击“下一步”后，系统会自动列出你这个类中包含的方法，选择你要进行测试的方法。此例中，咱们仅对“加、减、乘、除”四个方法进行测试。以下图所示：
   
   
   

   以后系统会自动生成一个新类CalculatorTest，里面包含一些空的测试用例。你只须要将这些测试用例稍做修改便可使用。完整的CalculatorTest代码以下：

   
   

   package andycpp;
   
   import static org.junit.Assert.*;
   import org.junit.Before;
   import org.junit.Ignore;
   import org.junit.Test;
   
   public class CalculatorTest {
   
       private static Calculator calculator = new Calculator();
       
       @Before
       public void setUp() throws Exception {
           calculator.clear();
       }
   
       @Test
       public void testAdd() {
           calculator.add(2);
           calculator.add(3);
           assertEquals(5, calculator.getResult());
       }
   
       @Test
       public void testSubstract() {
           calculator.add(10);
           calculator.substract(2);
           assertEquals(8, calculator.getResult());
       }
   
       @Ignore("Multiply() Not yet implemented")
       @Test
       public void testMultiply() {
       }
   
       @Test
       public void testDivide() {
           calculator.add(8);
           calculator.divide(2);
           assertEquals(4, calculator.getResult());
       }
   }

   第四步，运行测试代码：按照上述代码修改完毕后，咱们在CalculatorTest类上点右键，选择“Run As à JUnit Test”来运行咱们的测试，以下图所示：

    

   运行结果以下：

    

    

   进度条是红颜色表示发现错误，具体的测试结果在进度条上面有表示“共进行了4个测试，其中1个测试被忽略，一个测试失败”。

    

   咱们继续对初级篇中的例子进行分析。初级篇中咱们使用Eclipse自动生成了一个测试框架，在这篇文章中，咱们来仔细分析一下这个测试框架中的每个细节，知其然更要知其因此然，才能更加熟练地应用JUnit4。

   1、     包含必要地Package

   在测试类中用到了JUnit4框架，天然要把相应地Package包含进来。最主要地一个Package就是org.junit.*。把它包含进来以后，绝大部分功能就有了。还有一句话也很是地重要“import static org.junit.Assert.*;”，咱们在测试的时候使用的一系列assertEquals方法就来自这个包。你们注意一下，这是一个静态包含（static），是JDK5中新增添的一个功能。也就是说，assertEquals是Assert类中的一系列的静态方法，通常的使用方式是Assert. assertEquals()，可是使用了静态包含后，前面的类名就能够省略了，使用起来更加的方便。

   2、     测试类的声明

   你们注意到，咱们的测试类是一个独立的类，没有任何父类。测试类的名字也能够任意命名，没有任何局限性。因此咱们不能经过类的声明来判断它是否是一个测试类，它与普通类的区别在于它内部的方法的声明，咱们接着会讲到。

   3、     建立一个待测试的对象。

   你要测试哪一个类，那么你首先就要建立一个该类的对象。正如上一篇文章中的代码：

    

   private static Calculator calculator = new Calculator();

    

   为了测试Calculator类，咱们必须建立一个calculator对象。

   4、     测试方法的声明

   在测试类中，并非每个方法都是用于测试的，你必须使用“标注”来明确代表哪些是测试方法。“标注”也是JDK5的一个新特性，用在此处很是恰当。咱们能够看到，在某些方法的前有@Before、@Test、@Ignore等字样，这些就是标注，以一个“@”做为开头。这些标注都是JUnit4自定义的，熟练掌握这些标注的含义很是重要。

   5、     编写一个简单的测试方法。

   首先，你要在方法的前面使用@Test标注，以代表这是一个测试方法。对于方法的声明也有以下要求：名字能够随便取，没有任何限制，可是返回值必须为void，并且不能有任何参数。若是违反这些规定，会在运行时抛出一个异常。至于方法内该写些什么，那就要看你须要测试些什么了。好比：

    

       @Test
   
       public void testAdd() {
   
             calculator.add(2);
   
             calculator.add(3);
   
             assertEquals(5, calculator.getResult());
   
       }

    

   咱们想测试一下“加法”功能时候正确，就在测试方法中调用几回add函数，初始值为0，先加2，再加3，咱们期待的结果应该是5。若是最终实际结果也是5，则说明add方法是正确的，反之说明它是错的。assertEquals(5, calculator.getResult());就是来判断期待结果和实际结果是否相等，第一个参数填写期待结果，第二个参数填写实际结果，也就是经过计算获得的结果。这样写好以后，JUnit会自动进行测试并把测试结果反馈给用户。

   6、     忽略测试某些还没有完成的方法。

   若是你在写程序前作了很好的规划，那么哪些方法是什么功能都应该实现定下来。所以，即便该方法还没有完成，他的具体功能也是肯定的，这也就意味着你能够为他编写测试用例。可是，若是你已经把该方法的测试用例写完，但该方法还没有完成，那么测试的时候必定是“失败”。这种失败和真正的失败是有区别的，所以JUnit提供了一种方法来区别他们，那就是在这种测试函数的前面加上@Ignore标注，这个标注的含义就是“某些方法还没有完成，暂不参与这次测试”。这样的话测试结果就会提示你有几个测试被忽略，而不是失败。一旦你完成了相应函数，只须要把@Ignore标注删去，就能够进行正常的测试。

   7、     Fixture（暂且翻译为“固定代码段”）

   Fixture的含义就是“在某些阶段必然被调用的代码”。好比咱们上面的测试，因为只声明了一个Calculator对象，他的初始值是0，可是测试完加法操做后，他的值就不是0了；接下来测试减法操做，就必然要考虑上次加法操做的结果。这绝对是一个很糟糕的设计！咱们很是但愿每个测试都是独立的，相互之间没有任何耦合度。所以，咱们就颇有必要在执行每个测试以前，对Calculator对象进行一个“复原”操做，以消除其余测试形成的影响。所以，“在任何一个测试执行以前必须执行的代码”就是一个Fixture，咱们用@Before来标注它，如前面例子所示：

    

         @Before
   
         public void setUp() throws Exception {
   
              calculator.clear();
   
         }

    

   这里不在须要@Test标注，由于这不是一个test，而是一个Fixture。同理，若是“在任何测试执行以后须要进行的收尾工做”也是一个Fixture，使用@After来标注。因为本例比较简单，没有用到此功能。

           JUnit4的一些基本知识就介绍到此，还有一些更灵活的用法放在本系列的高级篇中给你们介绍！

    

    

   1.类的定义：类是同一事物的总称，类是封装对象的属性和行为的载体，反过来讲具备相同属性和行为的一类实体被称为类。

    

   2.Junit工具的使用：

    

   第一步

    

   首先新建一个项目叫JUnit_Test，咱们编写一个Calculator类，这是一个可以简单实现加减乘除、平方、开方的计算器类，而后对这些功能进行单体测试。

    

   第二步，将JUnit4单元测试包引入这个项目：在该项目上点右键，点“属性”，如图：

    

   在弹出的属性窗口中，首先在左边选择“Java Build Path”，而后到右上选择“Libraries”标签，以后在最右边点击“Add Library…”按钮，以下图所示：

    

    

   而后在新弹出的对话框中选择JUnit4并点击肯定，如上图所示，JUnit4软件包就被包含进咱们这个项目了。
   
       第三步，生成JUnit测试框架：在Eclipse的Package Explorer中用右键点击该类弹出菜单，选择“New à JUnit Test Case”。以下图所示：

    

    

    

    

   点击“下一步”后，系统会自动列出你这个类中包含的方法，选择你要进行测试的方法。此例中，咱们仅对“加、减、乘、除”四个方法进行测试。

    

    

    

   以后系统会自动生成一个新类CalculatorTest，里面包含一些空的测试用例。你只须要将这些测试用例稍做修改便可使用。

    

   第四步，运行测试代码：按照上述代码修改完毕后，咱们在CalculatorTest类上点右键，选择“Run As à JUnit Test”来运行咱们的测试，以下图所示：

    

    

    

    

   运行结果以下：

    

    

   4.记录各个阶段的时间

   1.类的定义：类是同一事物的总称，类是封装对象的属性和行为的载体，反过来讲具备相同属性和行为的一类实体被称为类。

   2.Junit工具的使用：

   第一步

   首先新建一个项目叫JUnit_Test，咱们编写一个Calculator类，这是一个可以简单实现加减乘除、平方、开方的计算器类，而后对这些功能进行单体测试。

   第二步，将JUnit4单元测试包引入这个项目：在该项目上点右键，点“属性”，如图：

   在弹出的属性窗口中，首先在左边选择“Java Build Path”，而后到右上选择“Libraries”标签，以后在最右边点击“Add Library…”按钮，以下图所示：

   而后在新弹出的对话框中选择JUnit4并点击肯定，如上图所示，JUnit4软件包就被包含进咱们这个项目了。
   
       第三步，生成JUnit测试框架：在Eclipse的Package Explorer中用右键点击该类弹出菜单，选择“New à JUnit Test Case”。以下图所示：

    

   点击“下一步”后，系统会自动列出你这个类中包含的方法，选择你要进行测试的方法。此例中，咱们仅对“加、减、乘、除”四个方法进行测试。

    

   以后系统会自动生成一个新类CalculatorTest，里面包含一些空的测试用例。你只须要将这些测试用例稍做修改便可使用。

   第四步，运行测试代码：按照上述代码修改完毕后，咱们在CalculatorTest类上点右键，选择“Run As à JUnit Test”来运行咱们的测试，以下图所示：

    

   运行结果以下：

   一、Junit简介：

       Junit最初是由Erich Gamma 和 Kent Beck 编写的一个回归测试框架(regression testing framework)，为单元测试（Unit Test）的支持框架。用来编写和执行重覆性的测试。即所谓白盒测试。

    

   它包括了如下的特性：

    

     1 对预期结果做断言
     2 提供测试装备的生成与销毁
     3 易于组织执行测试
     4 图形与文字界面的测试器
   二、Junit的环境配置
   环境：Eclipse 中配置junit，选择项目Junit4(在Package Explorer中) -> 右击鼠标 -> 选择properties -> 选择Java Build Path (在左边的菜单中) -> 在右边选择标签 Libraries  -> 单击按钮“Add Library”  -> 选择JUnit , 单击按钮 “Next>”  -> 选择JUnit library version 为： JUnit4 -> 单击按钮“Finish” –> 单击按钮 “OK”

    

    Junit4是Junit框架有史以来的最大改进，其主要目标是利用java5的Annotation特性来简化测试用例的编写。Junit4的官方网址是http://www.junit.org/。

    

    

    

   三、总结一下3-4的不一样,及4的改进

    

   下面咱们以一个简单的例子来介绍如何使用 Junit4同Junit3编写测试用例：
   public Class XXXX{

    

        public String hello(){

    

        return “hello”;

    

         }

    

   }

    

   对于这个类的用junit3编写测试用例：

    

   import junit.framework.TestCase;

    

      public Class XXXXTest extends TestCase{

    

      public void testHello(){

    

      asssertEqual(new XXXX().Hello(),”hello”);

    

     }

    

   }

    

   用junit4编写测试用例：

    

   import static org.junit.framework.assertEqual;

    

   import org.junit.Test;

    

   //这两个是junit4中必须导入的s

    

   public Class XXXXTest{

    

   @Test

    

   public void helloTest(){

    

       asssertEqual(new XXXX().Hello(),”hello”);

    

   }

    

   }

    

   从上面例子咱们对Junit3和Junit4有了一个初步的印象，下面咱们重点介绍Junit4与Junit3的主要区别。

    

   JUnit3  JUnit4 必须引入类TestCase import junit.framework.TestCase; 必须引入 import org.junit.Test; import static org.junit.Assert.*; 必须继承类TestCase class BaseClassTest extends TestCase 不须要 测试方法必须以test开头 public void testMethod () 不须要， 可是类开始的时候要标记 @Test 经过assert*方法来判断结果 assertTrue(baseClass.method ().equals(“test.junit.BaseClass”));