Junit4教程_比较详细比较了junit3与junit4_例子很全面也很实用
Junit4单元测试框架的常用方法介绍

Junit4单元测试框架的常⽤⽅法介绍Junit 介绍:Junit是⼀套框架(⽤于JAVA语⾔),由 Erich Gamma 和 Kent Beck 编写的⼀个回归测试框架(regression testing framework),即⽤于⽩盒测试。
本⽂介绍的内容:1 Junit Myeclipse测试类的⽣成2 JUnit 4 常⽤的⼏个annotation 介绍与使⽤ (@Before @After @Test @Ignore @BeforeClass @AfterClass)3 常⽤的断⾔介绍4 特殊的处理(限时测试,异常测试)5 参数化配置(@Parameters)准备测试代码测试的⽅法(正确、错误⽅法、死循环、抛异常)LogicServicepackage com.logic;public class LogicService {public int add(int x ,int y){ //加法return x+y;}public int sub(int x ,int y){ //减法return x-y;}public int div(int x ,int y){ //除法return x/y;}public int div2(int x ,int y){ //除法做了异常判断try {int z = x/y;} catch (Exception e) {e.printStackTrace();}return x/y;}public void loop(int x ,int y){ //死循环for(;;)x=y;}public void unCompleted(int x ,int y){ //未完成的模块//还在开发中}}⼀ Myeclipse测试类的⽣成1 对需要测试的类点右键 NEW ⼀个Junit Test Case2 点击NEXT注意 1 选择NEW Junit 4 test2 source folder 是默认会填写上之前右键NEW的那个类,如果不是的话,请⾃⾏进⾏修改3 package 默认会填写当前的包名个⼈建议重新开个测试包-即在包后⾯加上.test 表⽰是单元测试⽤例专⽤包与源代码分离4 name 默认会在之前右键NEW的那个类的基础的后⾯加上Test 如果不是的话,建议⾃⾏进⾏修改,便于标⽰5 初始化的⽅法,我⼀般会勾上个setUp,这个请随意。
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单元测试案例
Junit4是Java编程语言中用于编写单元测试的一个重要框架。
在使用Junit4编写单元测试案例时,您需要按照以下步骤进行:
1. 导入Junit4库,首先,在您的Java项目中,需要在构建路
径中导入Junit4库,以便能够使用Junit4框架提供的各种功能。
2. 编写测试类,您需要创建一个与被测试类对应的测试类,并
在测试类中编写测试方法。
测试方法需要使用`@Test`注解进行标记,以便Junit4能够识别并执行这些测试方法。
3. 准备测试数据,在测试方法中,您需要准备好测试数据,并
调用被测试类的方法进行测试。
4. 断言测试结果,在测试方法中,您需要使用Junit4提供的
断言方法来验证被测试方法的返回结果是否符合预期。
5. 运行测试,最后,您可以使用Junit4提供的测试运行器来
运行测试类,以便执行其中的测试方法并查看测试结果。
总的来说,编写Junit4单元测试案例需要您导入Junit4库、编写测试类和测试方法、准备测试数据、使用断言验证测试结果,并最后运行测试以检查代码的正确性。
希望这些信息能够帮助您更好地理解Junit4单元测试案例的编写过程。
junit4源码浅析

junit4源码浅析junit4源码浅析博客分类:测试SpringjunitEclipseXMLmavenjunit3和junit4是两个⾮常不同的版本,不能简单的理解为是后者是前者的⼀个升级,⼆者的内部实现有很⼤的不同。
这⾥只针对junit4以后的版本。
所有的testcase都是在Runner下执⾏的,可以将Runner理解为junit运⾏的容器,默认情况下junit会使⽤JUnit4ClassRunner作为所有testcase的执⾏容器。
如果要定制⾃⼰的junit,则可以实现⾃⼰的Runner,最简单的办法就是Junit4ClassRunner继承, spring-test, unitils这些框架就是采⽤这样的做法。
如在spring中是SpringJUnit4ClassRunner,在unitils中是UnitilsJUnit4TestClassRunner,⼀般我们的testcase都是在通过eclipse插件来执⾏的, eclipse的junit插件会在执⾏的时候会初始化指定的Runner。
初始化的过程可以在ClassRequest中找到:Java代码1.@Override2.public Runner getRunner() {3. return buildRunner(getRunnerClass(fTestClass));4.}5.6.public Runner buildRunner(Class runnerClass){7. try {8. return runnerClass.getConstructor(Class.class).newInstance(new Object[] { fTestClass });9. } catch (NoSuchMethodException e) {10. String simpleName= runnerClass.getSimpleName();11. InitializationError error= new InitializationError(String.format(12. CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName));13. return Request.errorReport(fTestClass, error).getRunner();14. } catch (Exception e) {15. return Request.errorReport(fTestClass, e).getRunner();16. }19.Class getRunnerClass(final Class testClass) {20. if (testClass.getAnnotation(Ignore.class) != null)21. return new IgnoredClassRunner(testClass).getClass();22. RunWith annotation= testClass.getAnnotation(RunWith.class);23. if (annotation != null) {24. return annotation.value();25. } else if (hasSuiteMethod() && fCanUseSuiteMethod) {26. return AllTests.class;27. } else if (isPre4Test(testClass)) {28. return JUnit38ClassRunner.class;29. } else {30. return JUnit4ClassRunner.class;31. }32.}这⾥的局部变量fTestClass是当前的testcase类, 如果使⽤了注解, 它会从RunWith中拿到指定的Runner, 所以要定制的话, 最⽅便的做法就是通过@RunWith指定定制的Runner, Spring-test, Unitils都是这么⼲的^_^下⾯来看JUnit4ClassRunner的构造器:Java代码1.public JUnit4ClassRunner(Class klass) throws InitializationError {2. fTestClass= new TestClass(klass);3. fTestMethods= getTestMethods();4. validate();5. }JUnit4ClassRunner没有默认的构造器, 从构造器中我们可以看出, 它需要⼀个参数, 这个参数就是我们当前要运⾏的testcase class, Runner拿到了要执⾏的testcase类之后, 就可以进⼀步拿到需要执⾏的测试⽅法, 这个是通过注解拿到的:2.protected List getTestMethods() {3. return fTestClass.getTestMethods();4.}5.6.List getTestMethods() {7. return getAnnotatedMethods(Test.class);8.}9.10.public List getAnnotatedMethods(Classion> annotationClass) {11. List results= new ArrayList();12. for (Class eachClass : getSuperClasses(fClass)) {13. Method[] methods= eachClass.getDeclaredMethods();14. for (Method eachMethod : methods) {15. Annotation annotation= eachMethod.getAnnotation(annotationClass);16. if (annotation != null && ! isShadowed(eachMethod,results))17. results.add(eachMethod);18. }19. }20. if (runsTopToBottom(annotationClass))21. Collections.reverse(results);22. return results;23.}初始化完成之后, 就可以根据拿到的Runner, 调⽤其run⽅法,执⾏所有的测试⽅法了:Java代码1.@Override2.public void run(final RunNotifier notifier) {3. new ClassRoadie(notifier, fTestClass, getDescription(), new4. public void run() {5. runMethods(notifier);6. }7. }).runProtected();8.}9.10.protected void runMethods(final RunNotifier notifier) {11. for (Method method : fTestMethods)12. invokeTestMethod(method, notifier);13.}14.15.protected void invokeTestMethod(Method method, RunNotifier notifier) {16. Description description= methodDescription(method);17. Object test;18. try {19. test= createTest();20. } catch (InvocationTargetException e) {21. notifier.testAborted(description, e.getCause());22. return;23. } catch (Exception e) {24. notifier.testAborted(description, e);25. return;26. }27. TestMethod testMethod= wrapMethod(method);28. new MethodRoadie(test, testMethod, notifier, description).run();29.}这⾥很多地⽅都利⽤了线程技术, 可以忽略不管, 最终都是要通过反射拿到需要执⾏的测试⽅法并调⽤, 最终的调⽤在MethodRoadie中:Java代码3. fNotifier.fireTestIgnored(fDescription);4. return;5. }6. fNotifier.fireTestStarted(fDescription);7. try {8. long timeout= fTestMethod.getTimeout();9. if (timeout > 0)10. runWithTimeout(timeout);11. else12. runTest();13. } finally {14. fNotifier.fireTestFinished(fDescription);15. }16.}17.18.public void runTest() {19. runBeforesThenTestThenAfters(new Runnable() {20. public void run() {21. runTestMethod();22. }23. });24.}25.26.public void runBeforesThenTestThenAfters(Runnable test) {27. try {28. runBefores();29. test.run();30. } catch (FailedBefore e) {31. } catch (Exception e) {32. throw new RuntimeException("test should never throw an exception to this level");33. } finally {34. runAfters();35. }38.protected void runTestMethod() {39. try {40. fTestMethod.invoke(fTest);41. if (fTestMethod.expectsException())42. addFailure(new AssertionError("Expected exception:" + fTestMethod.getExpectedException().getName()));43. } catch (InvocationTargetException e) {44. Throwable actual= e.getTargetException();45. if (actual instanceof AssumptionViolatedException)46. return;47. else if (!fTestMethod.expectsException())48. addFailure(actual);49. else if (fTestMethod.isUnexpected(actual)) {50. String message= "Unexpected exception, expected<" + fTestMethod.getExpectedException().getName() + "> but was<"51. + actual.getClass().getName() + ">";52. addFailure(new Exception(message, actual));53. }54. } catch (Throwable e) {55. addFailure(e);56. }57.}下⾯是使⽤spring-test的runner如何来写testcase, 将会有不少简化(推荐懒⼈使⽤):要测试的⽅法:Java代码1.public class ExampleObject {2.3. public boolean getSomethingTrue() {4. return true;7. public boolean getSomethingFalse() {8. return false;9. }10.}测试⽤例:Java代码1.@RunWith(SpringJUnit4ClassRunner.class)2.@ContextConfiguration(locations = { "classpath:/applicationCont ext.xml" })3.public class ExampleTest {4.@Autowired5. ExampleObject objectUnderTest;6.7.@Test8. public void testSomethingTrue() {9. Assert.assertNotNull(objectUnderTest);10. Assert.assertTrue(objectUnderTest.getSomethingTrue());11. }12.13. @Test14. @Ignore15. public void testSomethingElse() {16. Assert.assertNotNull(objectUnderTest);17. Assert.assertTrue(objectUnderTest.getSomethingFalse());18. }19.}xml配置:2./doc/9bd2fc1d10a6f524ccbf853b.html /dtd/spring-beans.dtd"> 3.4.5.。
浅谈junit4单元测试高级用法

浅谈junit4单元测试⾼级⽤法Junit单元测试框架是程序开发必备的测试利器,现在最常⽤的就是Junit4了,在Junit4中所有的测试⽤例都使⽤了注解的形式,这⽐Junit3更加灵活与⽅便。
之前在公司的关于单元测试的培训课程中,讲师仅仅讲述了Junit4的基本的与⽣命周期相关的注解的使⽤,主要包括@BeforeClass、@Before、@Test、@After、@AfterClass这些注解,这些在应付普通简单的单元测试已经⾜够,然⽽有很多更加复杂且也会经常遇到的测试需求依靠这些⽣命周期注解并不能完成!因此这篇分享将为您呈现Junit4的另⼀⽚新⼤陆,且看陈述…其实,在单元测试培训课程中,讲师并没有讲到Junit4的核⼼,例如为什么Junit没有main()⽅法就能运⾏(因为我们知道⽆论是什么程序都必须得有⼀个程序⼊⼝,⽽它通常是main);在例如Junit的核⼼组成部分是什么?如何更改Junit在运⾏单元测试时获取数据和执⾏测试的⾏为?更具体⼀点,如果我要为⼀个需要两个参数的⽅法进⾏测试,如何使⽤我所提供的参数的所有排列组合对⽅法进⾏测试?如果我需要在茫茫的测试⽤例中只测试与特定类相关的⽤例该怎么做…….在这之前,先纠正⼀点------Junit4可以直接运⾏我们的某个⽅法,没有main⼊⼝函数是断然不⾏的。
正如我之前给我们组的⼀个妹⼦讲Spring的时候告诉她,在测试⽅法中,对测试⽅法所在的类添加Spring的 (Compent注解或者为该类的成员变量添加)Resource注解并没有什么卵⽤,即Spring根本不会来扫描这个测试类,更不会为这个类注⼊属性值。
为什么这么说呢?因为Spring是在测试类中由被@Before标注的⽅法所启动的,这时候,JVM已经将此测试类实例化了,⽽这并不是由Spring实例化的,Spring晚了⼀步,所以在Spring的容器中并没有此类的实例。
那么Junit4真的有main⽅法吗?没错,既然它能直接运⾏我们的⽅法,那它必然⾃⼰为JVM提供了程序⼊⼝。
junit4生成代码用例

junit4生成代码用例JUnit4是一个Java编程语言的单元测试框架,它允许开发人员以一种简单、快捷和可重复的方式编写和执行代码用例。
在本文中,我们将探讨如何使用JUnit4生成代码用例。
JUnit4提供了一套丰富的注解和断言方法,使得编写和运行单元测试变得非常简单。
通过使用JUnit4,开发人员可以快速、准确地验证其代码的功能和正确性,并且可以自动化测试过程,从而减少人工错误和提高代码质量。
要使用JUnit4生成代码用例,我们需要按照以下步骤进行操作:第一步,导入JUnit4依赖。
在项目的构建文件中,我们需要添加JUnit4的依赖项,以便我们可以在项目中使用JUnit4的功能。
具体的依赖项配置取决于项目使用的构建工具,例如Maven或Gradle。
第二步,创建测试类。
在项目的测试代码目录中,我们需要创建一个或多个测试类来编写和组织我们的代码用例。
测试类应该以Test作为后缀,并且应该使用JUnit4的@Test注解来标记测试方法。
例如:```javaimport org.junit.Test;public class MyTestClass {@Testpublic void testMethod() {// 测试方法的代码逻辑}}```在测试方法中,我们可以编写代码来验证我们的代码的功能和正确性。
我们可以使用JUnit4提供的断言方法来断言某些条件是否为真。
例如,我们可以使用`assertEquals`方法来断言预期结果和实际结果是否相等:```javaimport org.junit.Test;import static org.junit.Assert.*;public class MyTestClass {@Testpublic void testMethod() {int result = someMethod();assertEquals(5, result);}}```第三步,运行测试。
自己整理的Junit4学习教程

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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。
(完整版)Junit4教程(实验指导书)

《软件测试技术》上机指导书之(一)使用JUNIT4进行单元测试JUnit4概述 (2)在Eclipse中使用JUnit4进行单元测试(初级篇) (5)在Eclipse中使用JUnit4进行单元测试(中级篇) (14)在Eclipse中使用JUnit4进行单元测试(高级篇) (16)实验目的:单元测试。
实验学时:4(2学时学习,2学时检查)实验要求:掌握JUNIT的使用方法。
检查要求:按学号每5人一组,分组检查掌握情况。
(1)初始成绩:1人为优秀,2-3人良好,1-2人中等。
组内推荐。
(2)最差的那个同学演示答辩,其成绩决定组内其他同学的成绩的整体水平。
(3)组内同学的成绩跟随答辩同学的成绩上下浮动。
张金荣重庆理工大学计算机科学与工程学院2013年3月9日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。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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的方法。