Junit4教程

合集下载

java的单元测试JUnit4

java的单元测试JUnit4

java的单元测试JUnit4 java的单元测试1. 概念java单元测试是最⼩的功能单元测试代码, 单元测试就是针对单个java⽅法的测试java程序的最⼩功能单元是⽅法2. 单元测试的优点main⽅法进⾏测试的缺点:只能有⼀个main()⽅法, 不能把测试代码分离出来⽆法打印出测试结果和期望结果.例如: expected: 3628800, but actual: 123456单元测试的优点:确保单个⽅法正常运⾏如果修改了⽅法代码, 只需要保其对应的单元测试通过就可以了测试代码本省就可以作为⽰例代码可以⾃动化运⾏所有测试并获得报告3. Junit单元测试JUnit是⼀个开源的java语⾔的单元测试框架专门针对java语⾔设计, 使⽤最⼴泛, JUnit是标准的单元测试架构3.1 JUnit特点使⽤断⾔(Assertion)测试期望结果可以⽅便的组织和运⾏测试可以⽅便的查看测试结果常⽤的开发⼯具IDEA, Eclipse都集成了JUnit可以⽅便的继承到maven中3.2 maven依赖<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><!-- junit的版本有3.x, 4.x, 5.x 5.x还没有发布, 现在都⽤是4.x --></dependency>3.3 在IDE中使⽤快捷键进⾏单元测试测试类的使⽤⽬录必须是如下, 测试类规定标准是在test⽬录中进⾏测试localhost:javatest lingjing$ tree -d -L 3.├── src│├── main││└── java│└── test│└── javaIDE的快捷键是:ctrl+shift+t --> create new test然后选择对应的⽅法进⾏测试就好了3.4 断⾔3.4.1 断⾔的例⼦断⾔的使⽤, 必须先引⼊必须的包: IDE⾃动创建的会⾃动引⼊import static org.junit.Assert.*;例⼦: 在main包中的编写的⼀个正则表达式的类import java.util.Arrays;/*** @ClassName Calculator* @Description 在main中的主要类* @Author lingxiangxiang* @Date 10:07 AM* @Version 1.0**/public class Calculator {public int calculate(String expression) {String[] ss = expression.split("\\+");System.out.println(expression + " => " + Arrays.toString(ss));int sum = 0;for (String s: ss) {sum += Integer.parseInt(s.trim());}return sum;}}测试类:import org.junit.Test;import static org.junit.Assert.*;public class CalculatorTest {@Testpublic void calculate() {assertEquals(3, new Calculator().calculate("1 + 2"));assertEquals(3, new Calculator().calculate("1 + 2 + 3"));}}测试类执⾏结果如下:1 +2 => [1 , 2]1 +2 +3 => [1 , 2 , 3]ng.AssertionError:Expected :3Actual :6<Click to see difference>at javatest.CalculatorTest.calculate(CalculatorTest.java:12)第⼀个⽅法: 1 + 2 => [1 , 2], 最终的结果3是正确的, 所有没有任何报错, 正常显⽰第⼆个⽅法: 1 + 2 + 3 => [1 , 2 , 3], 最终报错, 并提⽰在代码的位置: CalculatorTest.java:12, 并且罗列出Expected和Actual的值, 清楚的显⽰了结果的对⽐情况, 和代码出现的位置3.4.2 断⾔的常⽤⽅法assertEquals(100, x): 断⾔相等assertArrayEquals({1, 2, 3}, x): 断⾔数组相等assertEquals(3.1416, x, 0.0001): 浮点数组断⾔相等assertNull(x): 断⾔为nullassertTrue(x > 0): 断⾔为trueassertFalse(x < 0): 断⾔为false;assertNotEquals: 断⾔不相等assertNotNull: 断⾔不为null3.5 使⽤@Before和@After在@Before⽅法中初始化测试资源在@After⽅法中释放测试资源@BeforeClass: 初始化⾮常耗时的资源, 例如创建数据库@AfterClass: 清理@BeforeClass创建的资源, 例如创建数据库3.5.1 对于每⼀个@Test⽅法的执⾏顺序注意:** 单个@Test⽅法执⾏前会创建新的XxxTest实例, 实例变量的状态不会传递给下⼀个@Test⽅法, 单个@Test⽅法执⾏前后会执⾏@Before和@After⽅法1. 执⾏类的构造函数2. 执⾏@Before⽅法3. 执⾏@Test⽅法4. 执⾏@After⽅法3.5.2 代码实例:写⼀个整体的测试类如下:package javatest;/*** @ClassName SequenceTest* @Description TODO* @Author lingxiangxiang* @Date 1:54 PM* @Version 1.0**/import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;public class SequenceTest {@BeforeClasspublic static void setUpBeforeClass() throws Exception {System.out.println("BeforeClass()");}@AfterClasspublic static void tearDownAfterClass() throws Exception {System.out.println("AfterClass()");}@Beforepublic void setUp() throws Exception {System.out.println(" Before()");}@Afterpublic void tearDown() throws Exception {System.out.println(" After()");}public SequenceTest() {System.out.println(" new SequenceTest()");}@Testpublic void testA() {System.out.println(" testA()");}@Testpublic void testB() {System.out.println(" testB()");}@Testpublic void testC() {System.out.println(" testC()");}}如果运⾏整个类, 运⾏结果如下:BeforeClass()new SequenceTest()Before()testA()After()new SequenceTest()Before()testB()After()new SequenceTest()Before()testC()After()AfterClass()如果运⾏单个@Test类BeforeClass()new SequenceTest()Before()testA()After()AfterClass()3.6 异常测试异常测试可以通过@Test(expected=Exception.class), 对可能发⽣的每种类型的异常进⾏测试如果抛出了指定类型的异常, 测试成功如果没有抛出指定类型的异常, 或者抛出的异常类型不对, 测试失败例⼦:运⾏如下代码: 正常通过// 运⾏如下代码, 正常运⾏, 确实发⽣了ArithmeticException异常, 代码通过@Test(expected = ArithmeticException.class)public void testException() {int i = 1 / 0;}运⾏如下代码: 有报错信息@Test(expected = ArithmeticException.class)public void testException() {int i = 1 / 1;}执⾏结果如下:ng.AssertionError: Expected exception: ng.ArithmeticException3.7 参数化测试@RunWith: 当类被@RunWith注释修饰, 或者类继承了⼀个被该注解类修饰的类, JUnit将会使⽤这个注解所指明的运⾏器(runner)来运⾏测试, ⽽不是JUni默认的运⾏器要进⾏参数化测试,需要在类上⾯指定如下的运⾏器: @RunWith (Parameterized.class)然后,在提供数据的⽅法上加上⼀个@Parameters注解,这个⽅法必须是静态static的,并且返回⼀个集合Collection。

JUnit如何使用介绍

JUnit如何使用介绍

JUnit如何使用介绍第一步,使用前的环境配置准备工作。

(在此文档中我使用JUnit的版本为JUnit4.3.1)先检查一下你的Eclipse环境是否已经有编写JUnit测试类的环境了,如果有了就可以直接使用了,如果没有安装,请参考以下操作,如:在Eclipse要安装那些插件和写JUnit测试类时,项目中要导入那些相应的.jar包。

按照下列步骤执行:1,从官方网站或其他途径下载你需要版本的JUnit包。

2,把你下载的包释放在自己电脑的某个目录。

(比如:D:\java)3,把你释放文件中的如:org.junit4_4.3.1文件拷贝Eclipse的\plugins目录下,如果你的电脑上的环境安装了MyEclipse6.0插件了,这个文件也就存在\plugins目录下了,也就是说你要写JUnit的测试类环境已经好了,可以直接写了。

在\plugins目录下需要的JUnit文件为:4,以下是如何检验JUnit是否已经安装成功:第一种方法:在Eclipse→Window→Preferences→Java→JUnit是否存在,如果存在JUnit 就算安装好了。

如下图所示:另一种方法:在Eclipse→Window→ShowView→Other→Java→JUnit是否存在,如果存在JUnit 就算安装好了。

如下图所示:接下来,我们要来往要使用JUnit测试的项目中,导入JUnit相应的版本包,如下所示:在项目中要导入的.jar文件:第二步,我们来编写第一个JUnit测试类,从数据库中取出一条记录的测试类。

1,要在项目里选中的test路径下创建测试类,如下图所示:2,在选中的test路径上右击New→Other→JUnit→JUnit Test Case如下图所示:3,在选中JUnit Test Case时,点击Next按钮出现下图所示:4,在红框中有Name:输入框里填写上测试类的名称,如:TestGetOneData,点击Finish按钮即可,TestGetOneData.java测试类就创建完成了。

Junit4Tutorials(Junit4教程)三、Junit4断言方法

Junit4Tutorials(Junit4教程)三、Junit4断言方法

Junit4Tutorials (Junit4教程)三、Junit4断言方法Junit 4 断言方法允许检查测试方法的期望结果值和真实返回值。

Junit 的org.junit.Assert 类提供了各种断言方法来写junit 测试。

这些方法被用来检查方法的真实结果值和期望值。

下列一些有用的断言方法列表:Junit 4 Assert MethodsMethodDescription assertNull(ng.Object object)检查对象是否为空 assertNotNull(ng.Object object)检查对象是否不为空 assertEquals(long expected, long actual) 检查long 类型的值是否相等 assertEquals(double expected, double actual, double delta)检查指定精度的double 值是否相等 assertFalse(boolean condition)检查条件是否为假 assertTrue(boolean condition) 检查条件是否为真assertSame(ng.Object expected, ng.Object actual) 检查两个对象引用是否引用同一对象(即对象是否相等)assertNotSame(ng.Objectunexpected, ng.Object actual) 检查两个对象引用是否不引用统一对象(即对象不等)Junit 4断言方法样例AssertionsTest.java junit 测试用例,显示各种断言方法:1.import static org.junit.Assert.*; 2.3.import java.util.ArrayList; 4.import java.util.List; 5.6.import org.junit.Test; 7.8./** 9.* @author javatutorials.co.in 10.*/ 11.public class AssertionsTest { 12.13.@Test14.public void testAssertNull() {15.String str = null;16.assertNull(str);17.}18.19.@Test20.public void testAssertNotNull() {21.String str = "hello Java!!";22.assertNotNull(str);23.}24.25.@Test26.public void testAssertEqualsLong() {27.long long1 = 2;28.long long2 = 2;29.assertEquals(long1, long2);30.}31.32.@Test33.public void testAssertEqualsDouble() {34.// test case is successfull as double1 and double 235.// differ by 0.001 which is less than our specified delta36.double double1 = 1.236;37.double double2 = 1.237;38.double delta = 0.002;39.assertEquals(double1, double2, delta);40.}41.42.@Test43.public void testAssertTrue() {44.List<String> list = new ArrayList<String>();45.assertTrue(list.isEmpty());46.}47.48.@Test49.public void testAssertFalse() {50.List<String> list = new ArrayList<String>();51.list.add("hello");52.assertFalse(list.isEmpty());53.}54.55.@Test56.public void testAssertSame() {57.String str1 = "hello world!!";58.String str2 = "hello world!!";59.assertSame(str2, str1);60.}61.62.@Test63.public void testAssertNotSame() {64.String str1 = "hello world!!";65.String str3 = "hello Java!!";66.assertNotSame(str1, str3);67.}68.}样例输出在eclipse Junit 窗口的输出如下:。

JUnit4详细教程

JUnit4详细教程

悦成移动—移动互联网黄埔军校8万学员只要12周年薪14万网址:/it/index.html或百度悦成因jdk5中的新特性,JUnit4也因此有了很大的改变。

确切的说,Junit4简直就不是3的扩展版本,而是一个全新的测试框架。

下面详细介绍JUnit4的使用方法1.测试方法:在junit4之前,测试类通过继承TestCase类,并使用命名约束来定位测试,测试方法必须以“test”开头。

Junit4中使用注释类识别:@Test,也不必约束测试方法的名字。

当然,TestCase 类仍然可以工作,只不过不用这么繁琐而已。

Junit中还因JDK5而增加了一项新特性,静态导入(static import)。

2.固件测试所谓固件测试(Fixture),就是测试运行运行程序(test runner)会在测试方法之前自动初始化、和回收资源的工作。

JUnit4之前是通过setUp、TearDown方法完成。

在Junit4中,仍然可以在每个测试方法运行之前初始化字段,和配置环境,当然也是通过注释完成。

Junit4中,通过@befroe替代setUp方法;@After替代tearDown方法。

在一个测试类中,甚至可以使用多个@Before来注释多个方法,这些方法都是在每个测试之前运行。

说明一点,@Before是在每个测试方法运行前均初始化一次,同理@Ater是在每个测试方法运行完毕后,均匀性一次就是说,经这两个注释的初始化和注销,可以保证各个测试之间的独立性而互不干扰,他的缺点是效率低。

另外,不需要在朝类中显示调用初始化和清除方法,只要他们不被覆盖,测试运行程序将根据需要自动调用这些方法。

超类中的@Before方法在自来的@Before方法之前调用(与构造函数调用顺序一致),@After方法是子类中的在超类之前运行。

在JUnit4中加入了一项新特性。

加入了两个注释:@BeforeClass和@AfterClass,使用这两个注释的方法,在该测试类中,的测试方法之前、后各运行一次,而不是按照方法各运行一次。

在Eclipse中如何进行JUnit4版本的单元测试

在Eclipse中如何进行JUnit4版本的单元测试
try{ int n = 2 / 0; fail("Divided by zero!");
} catch(ArithmeticException success){
assertNotNull(success.getMessage()); }
杨教授工作室,版权所有,盗版必究, 10/19 页
return oneDigit+twoDigit; } public int sub(int oneDigit, int twoDigit){
return oneDigit-twoDigit; } public int mul(int oneDigit, int twoDigit){
杨教授工作室,版权所有,盗版必究, 3/19 页
杨教授工作室,版权所有,盗版必究, 5/19 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
5、对被测试的 Calculator 类添加对应的测试用例类 TestCalculatorJUnit4 (1)测试用例类的名称遵守“Test + 原类名”
(2)选择被测试的目标方法
杨教授工作室,版权所有,盗版必究, 6/19 页
fail("Not yet implemented"); } @Test public void testSub() {
fail("Not yet implemented"); } @Test
杨教授工作室,版权所有,盗版必究, 7/19 页
杨教授工作室 精心创作的优秀程序员 职业提升必读系列资料
public void testMul() { fail("Not yet implemented");

junit4osgi的使用

junit4osgi的使用

junit4osgi的使用介绍1.简介Junit4OSGi继承于junit的简单测试框架,可以在OSGI运行环境中进行测试。

针对集成测试或是需要在一个OSGI环境中进行单元测试。

结构如下:它分为三个部分:(1)Testsy stem 是真正的应用,被测试的系统(比如:声明式服务部分的测试)。

(2)Tests是包含测试代码的bundle,用来测试被测试的系统。

(3)Framework是测试框架,包括启动测试Runner和执行测试Runtime,在测试声明式服务中我们使用内嵌的loong框架作为测试框架。

2.使用Junit4OSGi进行测试的操作说明:(1)要对被测试的系统进行测试时,Tests必须是一个新建maven工程,测试的代码必须在src/main/java目录下,而不能在被测试部分src\test\java目录下直接写测试代码(比如要测试声明式服务loong-dservice-impl中的服务注册方面,我们不能在它的src\test\java目录下写测试代码)。

(2)所写的测试用例必须继承OSGiTestCase,这个类这个类继承自TestCase,并在它的基础上对OSGI中应用到的一些方法进行了封装,比如getBundle,getContext,getServiceObjects 等,方便在写测试代码时获取bundle或是服务的一些信息。

(3)在测试之前,要对测试代码所在工程的pom文件中进行如下信息的配置:1)添加测试时所需的依赖。

测试时所要用到的bundle通过添加依赖的方式添加到pom 文件中,其中loong-junit4osgi、loong-dservice-metadata为必须添加的依赖。

具体操作如下:<dependency><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-junit4osgi</artifactId><version>0.1.0-SNAPSHOT</version></dependency><dependency><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-dservice-metadata</artifactId><version>0.1.0-SNAPSHOT</version></dependency>2)配置所需的插件,必须配置loong-junit4osgi-plugin插件,如果对声明式服务进行测试时必需配置loong-dservice-plugin插件,具体操作如下:<plugin><groupId>org.trustie.loong.modules.loong-dservice</groupI><artifactId>loong-junit4osgi-plugin</artifactId><version>0.1.0-SNAPSHOT</version><executions><execution><goals><goal>test</goal></goals><configuration><framework>loong</framework></configuration></execution></executions></plugin><plugin><groupId>org.trustie.loong.modules.loong-dservice</groupId><artifactId>loong-dservice-plugin</artifactId><version>0.1.0-SNAPSHOT</version><executions><execution><goals><goal>dservice-bundle</goal></goals></execution></executions></plugin>其中在configuration中配置的框架为测试执行的框架,目前支持loong和Felix这两种。

Junit4.12+powermock+mock单元测试静态方法、普通方法、私有方法

Junit4.12+powermock+mock单元测试静态方法、普通方法、私有方法

Junit4.12+powermock+mock单元测试静态⽅法、普通⽅法、私有⽅法⾸先,我先引⽤⼤神的⼀些语⾔解释⼀下mock对单元测试的作⽤。

参考博客:1、为什么要⽤mock我的⼀本书的解释: (1)创建所需的DB数据可能需要很长时间,如:调⽤别的接⼝,模拟很多数据 (2)调⽤第三⽅API接⼝,测试很慢, (3)编写满⾜所有外部依赖的测试可能很复杂,复杂到不值得编写,Mock模拟内部或外部依赖可以帮助我们解决这些问题另⼀本TDD书的解释: (1)对象的结果不确定,如每获取当前时间,得到的结果都不⼀样,⽆法符合我们的预期; (2)实现这个接⼝的对象不存在; (3)对象速度缓慢 对于TDD还有⼀个更重要原因:通过模拟可以隔离当前⽅法使⽤的的所有依赖,让我们更加专注于单个单元,忽略其调⽤的代码的内部⼯作原理⼀本博客的⼲货: (1)Mock可以⽤来解除测试对象对外部服务的依赖(⽐如数据库,第三⽅接⼝等),使得测试⽤例可以独⽴运⾏。

不管是传统的单体应⽤,还是现在流⾏的微服务,这点都特别重要,因为任何外部依赖的存在都会极⼤的限制测试⽤例的可迁移性和稳定性。

(2)Mock的第⼆个好处是替换外部服务调⽤,提升测试⽤例的运⾏速度。

任何外部服务调⽤⾄少是跨进程级别的消耗,甚⾄是跨系统、跨⽹络的消耗,⽽Mock可以把消耗降低到进程内。

⽐如原来⼀次秒级的⽹络请求,通过Mock可以降⾄毫秒级,整整3个数量级的差别。

(3)Mock的第三个好处是提升测试效率。

这⾥说的测试效率有两层含义。

第⼀层含义是单位时间运⾏的测试⽤例数,这是运⾏速度提升带来的直接好处。

⽽第⼆层含义是⼀个测试⼈员单位时间创建的测试⽤例数。

以单体应⽤为例,随着业务复杂度的上升,为了运⾏⼀个测试⽤例可能需要准备很多测试数据,与此同时还要尽量保证多个测试⽤例之间的测试数据互不⼲扰。

为了做到这⼀点,测试⼈员往往需要花费⼤量的时间来维护⼀套可运⾏的测试数据。

Junit4入门参考手册.

Junit4入门参考手册.

Junit4入门参考手册.在实际运用中,借助Eclipse或者MyEclipse工具,将Junit 的包导入到工程中即可。

在需要做测试的类上点击鼠标左键,选择new→other→junit test case.即可看到如下界面。

点击Finish后会报错,原因是junit包未和工程关联。

在报错部分点击红叉,然后选中要添加的包即可。

以下部分内容,只对注解及部分参数使用进行说明。

JAVA源码部分(需要测试的类)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;}}基本的测试import static org.junit.Assert.*;import org.junit.Before;import org.junit.Ignore;import org.junit.Test;import org.junit.runner.Description;import org.junit.runner.RunWith;import org.junit.runner.Runner;import org.junit.runner.notification.RunNotifier;/*** @author Administrator**/public class CalculatorTest{//每个测试类只能有一个方法被标注为@BeforeClass 或 @AfterClass,//并且该方法必须是Public和Static的// @Test(timeout = 1000)防止死循环设定测试的超时时间//@Test(expected = ArithmeticException.class)private static Calculator calculator = new Calculator();/*** @throws ng.Exception* before方法是一个复原方法会将各部分测试的值独立开来*/@Beforepublic void setUp() throws Exception {//将结果清0calculator.clear();}/*** Test method for {@link com.my.calculator.Calculator#add(int)}. */@Testpublic void testAdd() {//fail("Not yet implemented");calculator.add(2);calculator.add(3);assertEquals(5, calculator.getResult());}/*** Test method for {@link com.my.calculator.Calculator#substract(int)}. */@Testpublic void testSubstract() {//result作为全局变量经过上面的相加运算后变成了15//减法实为15-1 所以结果应该是14calculator.add(10);calculator.substract(2);assertEquals(9, calculator.getResult());}/*** Test method for {@link com.my.calculator.Calculator#multiply(int)}. * @Ignore忽略*/@Ignore("multiply() Not yet implemented")@Testpublic void testMultiply() {//fail("Not yet implemented");}/*** Test method for {@link com.my.calculator.Calculator#divide(int)}.*/@Testpublic void testDivide() {calculator.add(8);calculator.divide(2);assertEquals(4, calculator.getResult());}}通过参数方式进行测试import static org.junit.Assert.assertEquals;import org.junit.Test;import org.junit.runner.RunWith;import org.junit.runners.Parameterized;import org.junit.runners.Parameterized.Parameters;import java.util.Arrays;import java.util.Collection;/*** 通过参数方式进行测试* @author Administrator**/@RunWith(Parameterized.class)public class SquareTest {private static Calculator calculator = new Calculator(); private int param;private int result;//参数和预想得到的结果通过如下方式定义//以下内容中{2,4} 2为参数 4为结果//位置取决于构造函数的定义@Parameterspublic static Collection data(){return Arrays.asList(new Object[][]{{2, 4},{0, 0},{-3, 9},});}//构造函数,对变量进行初始化public SquareTest(int param, int result){this.param = param;this.result = result;}@Testpublic void square(){//为乘法运算赋予参数calculator.square(param);assertEquals(result, calculator.getResult());}}多个测试单元打包测试import org.junit.runner.RunWith;import org.junit.runners.Suite;/*** @author Administrator*打包测试针对多个测试类的测试就可以采用这种方式*/@RunWith(Suite.class)@Suite.SuiteClasses({CalculatorTest.class,SquareTest.class})public class AllCalculatorTests { }。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。

我们可以看到上面那个单元测试有一些比较霸道的地方,表现在: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() {}@Beforepublic void setUp() throws Exception {}@Afterpublic void tearDown() throws Exception {}@Testpublic 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(“该方法还没有实现”),在执行的时候,仅会报告该方法没有实现,而不会运行测试方法。

在Eclipse中使用JUnit4进行单元测试(初级篇)我们在编写大型程序的时候,需要写成千上万个方法或函数,这些函数的功能可能很强大,但我们在程序中只用到该函数的一小部分功能,并且经过调试可以确定,这一小部分功能是正确的。

但是,我们同时应该确保每一个函数都完全正确,因为如果我们今后如果对程序进行扩展,用到了某个函数的其他功能,而这个功能有bug的话,那绝对是一件非常郁闷的事情。

所以说,每编写完一个函数之后,都应该对这个函数的方方面面进行测试,这样的测试我们称之为单元测试。

传统的编程方式,进行单元测试是一件很麻烦的事情,你要重新写另外一个程序,在该程序中调用你需要测试的方法,并且仔细观察运行结果,看看是否有错。

正因为如此麻烦,所以程序员们编写单元测试的热情不是很高。

于是有一个牛人推出了单元测试包,大大简化了进行单元测试所要做的工作,这就是JUnit4。

本文简要介绍一下在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();@Beforepublic void setUp() throws Exception ...{calculator.clear();}@Testpublic void testAdd() ...{calculator.add(2);calculator.add(3);assertEquals(5, calculator.getResult());}@Testpublic void testSubstract() ...{calculator.add(10);calculator.substract(2);assertEquals(8, calculator.getResult());}@Ignore("Multiply() Not yet implemented")@Testpublic void testMultiply() ...{}@Testpublic void testDivide() ...{calculator.add(8);calculator.divide(2);assertEquals(4, calculator.getResult());}}第四步,运行测试代码:按照上述代码修改完毕后,我们在CalculatorTest类上点右键,选择“Run As à JUnit Test”来运行我们的测试,如下图所示:运行结果如下:进度条是红颜色表示发现错误,具体的测试结果在进度条上面有表示“共进行了4个测试,其中1个测试被忽略,一个测试失败”至此,我们已经完整体验了在Eclipse中使用JUnit的方法。

相关文档
最新文档