java前端框架有哪些，java单元测试框架有哪些

很多朋友对java前端框架有哪些，java单元测试框架有哪些不是很了解，每日小编刚好整理了这方面的知识，今天就来带大家一探究竟。

如果你是刚刚进入Java世界，首先要做的是安装JDK —— Java开发工具包，该工具包带有Java运行时环境(JRE)和JVM(Java运行时环境)。它允许你在自己的计算机上编译、运行和测试你的Java程序。另外，你需要IDE(集成开发环境)。有很多选择，比如IntelliJ，Eclipse，NetBeans。Java 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(极限编程)创始人)提供的开源JUnit。3、 JUnit 3简介。1、 JUnit的好处和JUnit测试编写的原则使用JUnit的好处：

您可以将测试代码与产品代码分开。一个类的测试代码可以应用到另一个类的测试中，只需很少的修改。很容易集成到测试人员的构建过程中，JUnit和Ant的结合可以实现增量开发。JUnit是开源代码，可以重新开发。JUnit很容易扩展。JUnit测试编写原则：简化测试的编写，包括测试框架的学习和实际测试单元的编写。

保持测试单元的持久性。您可以使用现有的测试来编写相关的测试。3.2、JUnit的特性使用断言方法来判断期望值和实际值之间的差异，并返回一个布尔值。测试驱动的设备使用公共的初始化变量或实例。该测试包结构便于组织和集成操作。支持图形交互模式和文本交互模式。3.3 JUnit框架由一组用于测试测试目标的方法和过程组成，可以称为测试用例。

可以容纳多个测试用例的测试用例集合被称为测试套件。测试结果的描述和记录。(测试结果).测试过程中的事件监听器。对每个测试方法的意外情况的描述称为断言test failure)JUnit框架。

JUnit框架是典型的复合模式：TestSuite可以容纳任何从Test派生的对象；当调用TestSuite对象的run()方法时，它会遍历它包含的对象，并逐个调用它们的run()方法。3.5 JUnit中的通用接口和类测试接口：运行测试和收集测试结果。

测试接口使用复合设计模式，这是单个测试用例、聚合测试套件和TestDecorator的公共接口。它的public int countTestCases()方法用于统计测试期间有多少测试用例。另一个方法是public void run( TestResult)，这是实例的TestResult，run方法执行这个测试。Testcase抽象类：定义测试中的固定方法。

TestCase是测试接口的抽象实现。(不能实例化，只能继承。)它的构造器TestCase(string name)根据输入的测试名name创建一个测试用例。因为每个测试用例在创建时都必须有一个名称，如果测试失败了，您可以识别哪个测试失败了。TestCase类中包含的setUp()和tearDown()方法。

setUp()方法设置测试所需的所有变量和实例，在依次调用测试类中的每个测试方法之前，再次执行setUp()方法。tearDown()方法在每个测试方法之后释放测试程序方法中引用的变量和实例。开发人员编写测试用例时，只需要继承测试用例来完成run方法，然后JUnit获取测试用例，执行其run方法，并在测试结果中记录测试结果。

Assert静态类：一组断言方法Assert包含一组静态测试方法，用来比较预期值和实际值，也就是说，如果测试失败，Assert类会抛出AssertionFailedError异常，JUnit测试框架会把这个错误归类为失败并记录下来，标记为测试失败。如果在这种方法中指定了String类型的参数，该参数将被用作AssertionFailedError异常的标识信息，告诉测试人员改变异常的细节。

JUnit提供了6大类31组断言方法，包括基本断言、数值断言、字符断言、布尔断言和对象断言。其中assert Equals(Object expted，Object actual)内部逻辑判断使用equals()方法，表示在断言两个实例的内部哈希值是否相等时，最好使用该方法比较对应类实例的值。

assertSame(Object expected，Object actual)的内部逻辑判断中使用了Java运算符“==”,表示断言判断两个实例是否来自同一个引用，用这种方法比较不同类的实例的值更好。AsserEquals(String message，String expected，String actual)该方法对两个字符串进行逻辑比较，如果不匹配，则显示两个字符串之间的差异。

ComparisonFailure类提供了两个字符串的比较，如果它们不匹配，就会给出详细的差异字符。Testsuite测试包类。多个测试的组合TestSuite类负责组装多个测试用例。要测试的类可能包括对要测试的类的多个测试，TestSuit负责收集这些测试，这样我们就可以在一个测试中完成对要测试的类的所有多个测试。TestSuite类实现测试接口，并且可以包含其他Test suite。它可以处理你加入测试时抛出的所有异常。

TestSuite有六个处理测试用例的协议(否则，它将被拒绝执行测试)。测试用例必须是公共的。测试用例的测试方法必须是公共的。测试用例的测试方法必须声明为Void。测试用例中测试方法的前缀必须是测试方法在任何传递参数、测试结果类以及其他类和接口中的错误。

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（）方法返回“失败”状况的简要描述

4、Eclipse中JUnit的使用

测试对于保证软件开发质量有着非常重要的作用，单元测试更是必不可少，JUnit是一个非常强大的单元测试包，可以对一个/多个类的单个/多个方法测试，还可以将不同的TestCase组合成TestSuit，使测试任务自动化。

Eclipse同样集成了JUnit，可以非常方便地编写TestCase。Eclipse自带了一个JUnit的插件，不用安装就可以在你的项目中开始测试相关的类，并且可以调试你的测试用例和被测试类。

4.1、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.2、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个测试未通过，就会显示红色并列出未通过测试的方法。

5、后记

从上面的来看，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代码进行单元测试中的常用工具，

问题：

1、目前测试存在的问题

2、Junit注意的细节

3、Junit使用规范

4、断言

5、案例

junit（单元测试框架）

1、目前存在的问题

1、目前的测试方法如果需要测试，都需要在main方法上调用

2、目前的结果都需要我们人工比对

2、Junit 注意的细节

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

2、如果点击方法名、类名、包名、工程名运行junit分别测试的是对于的方法，类、包中的所有类的test方法，工程中所有test的方法

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

4、如果测试一个方法的时候需要准备测试的环境或者是清理测试的环境，那么可以@Before、@After、@BeforeClass、@AfterClass 这四个注释，@Before、@After 是在每个测试方法测试的时候都会调用一次，@AfterClass、@BeforeClass是在所有的测试方法测试之前与之后都会调用一次，这个方法必须是静态的

3、junit使用规范

1、一个类如果需要测试，那么该类就应该对应着一个测试类，测试类的命名规范：被测试类的类名+Test

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

4、断言

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

5Assert.assertSame（5， max）; //底层是用了==

Assert.assertSame（new String（“abc”）， “abc”）;

Assert.assertEquals（new String（“abc”）， “abc”）; //底层是使用Equals方法比较的

Assert.assertNull（“aa”）;

Assert.assertTrue（true）;

5、案例

？

28package 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=newFileInputStream（“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（“清理测试环境。”）;

}

}

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

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

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

测试类Person：

java view plain copy

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：

java view plain copy

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中我们是怎样写一个单元测试的。比如下面一个类：

java view plain copy

public class AddOperation {

public int add（int x，int y）{

return x+y;

}

}

我们要测试add这个方法，我们写单元测试得这么写：

java view plain copy

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中写就不会这么复杂。代码如下：

java view plain copy

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

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

2

创建一个source folder 资源文件夹test，资源文件夹和普通的文件夹区别是，资源文件夹中的java文件可以被自动编译。

3

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

4

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

@Before表示在所有方法运行前运行的方法；

@After表示在所有的方法运行之后执行的方法；

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

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

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

5

如果是对某一个方法进行测试，在方法的名称上点击右键--》 run as --》 JUnit Test

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。

一、 包含必要地Package

在测试类中用到了JUnit4框架，自然要把相应地Package包含进来。最主要地一个Package就是org.junit.*。把它包含进来之后，绝大部分功能就有了。还有一句话也非常地重要“import static org.junit.Assert.*;”，我们在测试的时候使用的一系列assertEquals方法就来自这个包。大家注意一下，这是一个静态包含（static），是JDK5中新增添的一个功能。

也就是说，assertEquals是Assert类中的一系列的静态方法，一般的使用方式是Assert. assertEquals（），但是使用了静态包含后，前面的类名就可以省略了，使用起来更加的方便。

二、 测试类的声明

大家注意到，我们的测试类是一个独立的类，没有任何父类。测试类的名字也可以任意命名，没有任何局限性。所以我们不能通过类的声明来判断它是不是一个测试类，它与普通类的区别在于它内部的方法的声明，我们接着会讲到。

三、 创建一个待测试的对象。

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

private static Calculator calculator=new Calculator（）;

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

四、 测试方法的声明

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

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

首先，你要在方法的前面使用@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（））;就是来判断期待结果和实际结果是否相等，第一个参数填写期待结果，第二个参数填写实际结果，也就是通过计算得到的结果。

这样写好之后，J

　　六、 忽略测试某些尚未完成的方法。

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

　　七、 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”来运行我们的测试，如下图所示：

　　运行结果如下：

　　1、Junit简介：

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

　　它包括了以下的特性：

　　1 对预期结果作断言

　　2 提供测试装备的生成与销毁

　　3 易于组织执行测试

　　4 图形与文字界面的测试器

　　2、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、总结一下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”））;

以上知识分享希望能够帮助到大家！