Junit4教程_比较详细比较了junit3与junit4_例子很全面也很实用

合集下载

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断言方法

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单元测试案例
Junit4是Java编程语言中用于编写单元测试的一个重要框架。

在使用Junit4编写单元测试案例时,您需要按照以下步骤进行:
1. 导入Junit4库,首先,在您的Java项目中,需要在构建路
径中导入Junit4库,以便能够使用Junit4框架提供的各种功能。

2. 编写测试类,您需要创建一个与被测试类对应的测试类,并
在测试类中编写测试方法。

测试方法需要使用`@Test`注解进行标记,以便Junit4能够识别并执行这些测试方法。

3. 准备测试数据,在测试方法中,您需要准备好测试数据,并
调用被测试类的方法进行测试。

4. 断言测试结果,在测试方法中,您需要使用Junit4提供的
断言方法来验证被测试方法的返回结果是否符合预期。

5. 运行测试,最后,您可以使用Junit4提供的测试运行器来
运行测试类,以便执行其中的测试方法并查看测试结果。

总的来说,编写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单元测试高级用法

浅谈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生成代码用例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概述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进行单元测试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。

junit 使用指南及作业规范(对比Junit3与4)

junit 使用指南及作业规范(对比Junit3与4)

使用指南及作业规范V1.0 Keep the bar green keep the code clean!目录1.JUNIT总览 (3)1.1简介 (3)1.2特性 (3)1.3适用对象 (3)2JUNIT使用 (3)2.1JUNIT3.X使用 (3)2.1.1下载与安装 (3)2.1.2使用方法 (4)2.1.2.1基本流程(我们一般都是这么写) (4)2.1.2.2重要概念和类(你必须了解的东西) (5)2.1.2.3JUNIT固件的安装与拆除(测试方法启动和结束之前要做的) (6)2.1.2.4Eclipse中使用junit(有了开发工具对junit的支持后) (8)2.2JUNIT4.X使用 (12)2.2.1下载与安装 (12)2.2.2使用方法 (13)2.2.2.1与3.x版本的异同(看谁更简单) (13)2.2.2.2常用注解(体验annotation的简单便捷) (13)2.2.2.3 4.x新特性实战(实践出真知) (14)3作业规范 (21)4附录 (22)4.1下版计划 (22)4.2修订记录 (23)4.3参考文献 (23)1.JUNIT总览1.1简介JUnit是由Erich Gamma 和Kent Beck 编写的一个回归测试框架。

Junit测试是程序员测试,即所谓白盒测试。

项目主页:/下载地址:https:///KentBeck/junit/downloads/projects/junit/files/junit/目前主要版本有3.X和4.X,它们之间存在很大的差别,故本文档将分别介绍3.X和4.X.1.2特性JUnit是一个开放源代码的Java测试框架,用于编写和运行可重复的测试。

他是用于单元测试框架体系xUnit的一个实例(用于java语言)。

它包括以下特性:1、用于测试期望结果的断言(Assertion)2、用于共享共同测试数据的测试工具3、用于方便的组织和运行测试的测试套件4、图形和文本的测试运行器1.3适用对象JUnit可以用于程序开发人员或专业测试人员进行单元测试。

java 单元测试 junit4 性能框架 junitperf 入门使用说明

java 单元测试 junit4 性能框架 junitperf 入门使用说明

junitperfjunitperf一款为 java 开发者设计的性能测试框架。

缘由在看性能测试相关内容时发现这类框架(Junit 性能测试框架)。

个人初步参考以下2个项目进行实现,后续可能走完全不同的路线。

为什么使用?•可以和 Junit 完美契合。

•使用简单,便于项目开发过程中的测试实用。

•提供拓展,用户可进行自定义开发。

特性•支持 I18N•支持多种报告生成方式,支持自定义•Junt4 完美支持,便于 Java 开发者使用。

快速开始项目依赖•jdkjdk1.7 及其以上版本•junitJunit4 及其以上版本入门案例入门案例地址•jar 包引入<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>com.github.houbb</groupId><artifactId>junitperf</artifactId><version>1.0.2</version></dependency>•使用例子/***入门测试** @author houbinbin*@version 1.0.0*@since 1.0.0,2018/01/14*/public class HelloWorldTest {@Rulepublic JunitPerfRule junitPerfRule = new JunitPerfRule();/***单一线程,执行1000ms,默认以 html 输出测试结果* @throws InterruptedException if any*/@Test@JunitPerfConfig(duration = 1000)public void helloWorldTest() throws InterruptedException { //This is what you want to test.System.out.println("hello world");Thread.sleep(20);}}配置说明声明 Rule@Rulepublic JunitPerfRule junitPerfRule = new JunitPerfRule();这里主要是对于性能测试统计的输出方式。

Android单元测试(四)JUnit介绍

Android单元测试(四)JUnit介绍

Android单元测试(四)JUnit介绍JUnit是java开发人员的一个主要的测试工具,做Android开发同样是离不开java 的,所以Android单元测试依然可以基于JUnit来写测试。

但是JUnit只能运行在纯java环境上,前面我们介绍过MVP架构下,可以将View层隔离开来,单独针对Presenter层、Model层来测试。

4.1 JUnit4配置在build.gradle中加入依赖配置,采用JUnit4框架。

JUnit文件夹在工程中的位置,工程创建后,在app -> src目录下,会有3个文件夹:androidTest, main, test。

test文件目录就是JUnit单元测试默认的目录。

创建工程时,默认会生成一个单元测试例子ExampleUnitTest.java,且看看一个最简单的Junit单元测试是怎么写的:“OK”表示单元测试运行通过,到这里我们已经在Android上执行了一次单元测试。

4.2 JUnit4基础方法注解JUnit3是通过对测试类和测试方法的命名来确定是否是测试,如测试方法必须以test开头。

而在JUnit4中,是通过注解来确定的。

执行后打印结果如下:------init(------ ------setUp(------ ------test1(------ ------tearDown(------ ------setUp(------------test2(------ ------tearDown(------ ------finish(------4.3 JUnit4常用断言JUnit提供了一些辅助函数,他们用来帮助我们确定被测试的方法是否按照预期正常执行,这些辅助函数我们称之为断言(Assertion)。

JUnit4所有的断言都在org.junit.Assert类中,Assert类包含了一组静态的测试方法,用于验证期望值expected与实际值actual之间的逻辑关系是否正确,如果不符合我们的预期则表示测试未通过。

JUnit4快速入门

JUnit4快速入门

1.JUnit 4JUnit 4是JUnit框架有史以来的最大改进,其主要目标便是利用Java 5的Annotation特性简化测试用例的编写。

让我们看看如何使用JUnit 4来进行Unit测试。

请注意:本文主要介绍JUnit 4的最新特性和用法,并不会讲解Unit测试的基础。

如果你对JUnit框架还不熟悉,请先参考“Eclipse快速上手指南(2) 使用JUnit测试”一文,学习如何编写JUnit测试。

我们使用的开发环境是Eclipse 3.2,它已经自带了JUnit 4.1,你需要将JUnit 4 Library添加到项目用到的Library中。

另外,必须使用JDK 5.0或更高版本。

要在Eclipse环境之外运行JUnit,需要下载JUnit 4.1,具体请访问。

我们先看一个简单的Math类:package com.javaeedev.junit4;public class Math {public int abs(int value) {return value>=0 ? value : (-value);}public int div(int a, int b) {return a / b;}/*** BUG: if b less than 0!*/public float exp(int a, int b) {float r = 1;for(int i=0; i<b; i++)r = r * a;return r;}}注意exp()方法是有Bug的,如果传入参数2, -1,则期待的返回值应为0.5F,但实际返回值为1.0F。

下面我们看看传统的JUnit的TestCase:public class MathTest extends TestCase {public void setUp() { super.setUp(); }public void tearDown() { super.tearDown(); }public void testAbs() { assertTrue(true); }public void testDiv() {...}public void testExp() {...}}JUnit依赖反射来执行每个以test开头的方法。

JUnit4使用入门指南

JUnit4使用入门指南

JUnit4使用入门指南*以下的内容以Eclipse上的JUnit为准现在的Eclipse中一般都自带了JUnit组件,包含两个版本:JUnit3和JUnit4,由于Junit4引入了java 5.0的注释技术,所以写起测试用例更方便,有些注解方法非常人性化。

简单介绍一下JUnit4的特性:1. JUnit4引入了类范围的setUp() 和tearDown() 方法。

任何用@BeforeClass 注释的方法都将在该类中的测试方法运行之前刚好运行一次,而任何用@AfterClass注释的方法都将在该类中的所有测试都运行之后刚好运行一次。

2. 异常测试:异常测试是Junit4中的最大改进。

Junit3的异常测试是在抛出异常的代码中放入try块,然后在try块的末尾加入一个fail()语句。

例如除法方法测试一个被零除抛出一个ArithmeticException:该方法不仅难看,而且试图挑战代码覆盖工具,因为不管测试是否通过还是失败,总有一些代码不被执行。

在JUni4中,可以编写抛出异常的代码,并使用注释来声明该异常是预期的:如果没有异常抛出或者抛出一个不同的异常,那么测试就将失败。

3. JUnit4添加了两个比较数组的assert() 方法:public static void assertEquals(Object[] expected,Object[]actual)public static void assertEquals(String message, Object[]expected,Object[] actual)这两个方法以最直接的方式比较数组:如果数组长度相同,且每个对应的元素相同,则两个数组相等,否则不相等。

数组为空的情况也作了考虑。

4. JUnit 4引入了注解技术,下面列出常用的几个annotation 介绍a). @Before:初始化方法,在任何一个测试执行之前必须执行的代码;b). @After:释放资源,在任何测试执行之后需要进行的收尾工作;c). @Test:测试方法,表明这是一个测试方法。

junit3与junit4的区别

junit3与junit4的区别

JUnit 4的新特征一、引言在本文开始,我将假定,你已经了解由Kent Beck和Erich Gamma发明的这个Java单元测试框架并因此而略过必要的简介。

所以,我将集中分析从JUnit 3.8到最新版本JUnit 4的迁移过程以及其在IDE和Ant中的集成。

JUnit 4是一种与其之前的版本完全不同的API,它根据Java 5.0中的新特征(注解,静态导入等)构建而成。

如你所见,JUnit 4更简单、更丰富和更易于使用,而且它引入了更为灵活的初始化和清理工作,还有限时的和参数化测试用例。

代码实例最能说明问题。

因此,在本文中,我将使用一个例子来展示不同的测试用例:一个计算器。

该示例计算器很简单,效率并不高,甚至还有一些错误;它仅仅操作整数,并且把结果存储在一个静态变量中。

Substract方法并不返回一个有效的结果,而且也没有实现乘法运算,而且看上去在 squareRoot方法中还存在一个错误:无限循环。

这些错误将帮助说明使用JUnit 4进行测试的有效性。

你可以打开和关闭这个计算器,而且你可以清除这些结果。

下面是其实现代码:二、迁移一个测试类现在,我将把一个已经使用JUnit 3.8编写成的简单的测试类迁移到JUnit 4。

这个类有一些缺陷:它没有测试所有的业务方法,而且看上去在testDivide方法中还存在一个错误(8/2不等于5)。

因为还没有实现乘法运算功能,所以对其测试将被忽略。

下面,我们把两个版本的框架之间的差别以粗体显示出现于表格1中。

表格1.分别以JUnit 3.8和JUnit 4实现的CaculatorTest。

JUnit 3.8JUnit 4#p#三、包首先,你可以看到,JUnit 4使用org.junit.*包而JUnit 3.8使用的是junit.Framework.*。

当然,为了向后兼容性起见,JUnit 4jar文件发行中加入了这两种包。

四、继承在中,测试类不必再扩展junit.framework.TestCase;事实上,它们不必须扩展任何内容。

junit4 用法

junit4 用法

JUnit 4是 Java 中广泛使用的单元测试框架,它使得开发人员可以快速地编写和运行自动化测试以验证代码正确性。

以下简要介绍了JUnit 4的基本用法。

1. 在你的项目中添加 JUnit 4 依赖。

对于 Maven 项目,在 `pom.xml` 文件中加入以下依赖:<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency>对于 Gradle 项目,在 `build.gradle` 文件中加入以下依赖:dependencies {testImplementation 'junit:junit:4.13.2'}1. 创建一个测试类。

选择一个要测试的类并创建一个新的测试类。

通常,测试类的命名约定是将 "Test" 附加到所测试类的名称。

例如,要为名为 `Calculator` 的类编写测试,创建一个名为 `CalculatorTest` 的新类。

1. 导入JUnit 4 注解和其他依赖。

在您的测试类中,导入以下依赖项:import org.junit.Test;import static org.junit.Assert.*;1. 编写测试方法。

在您的测试类中,使用 `@Test` 注解来标记测试方法。

测试方法应该是公共的、无参数的,并返回 `void`。

通过使用 `Assert` 类中的断言方法,如`assertEquals`,来验证代码行为。

例如,在`CalculatorTest` 类中,可以添加以下方法来测试`Calculator` 类的`add` 方法:@Testpublic void testAdd() {Calculator calculator = new Calculator();int result = calculator.add(5, 3);assertEquals("Sum of 5 and 3 should be 8", 8, result);}1. 运行测试。

java单元测试JUnit框架原理与用法实例教程

java单元测试JUnit框架原理与用法实例教程

java单元测试JUnit框架原理与⽤法实例教程本⽂实例讲述了java单元测试JUnit框架原理与⽤法。

分享给⼤家供⼤家参考,具体如下:1 简介JUnit是⼀个Java语⾔的单元测试框架,它由 Kent Beck 和 Erich Gamma 建⽴,逐渐成为 xUnit 家族中最为成功的⼀个。

JUnit有它⾃⼰的JUnit扩展⽣态圈,多数Java的开发环境都已经集成了JUnit作为单元测试的⼯具。

在这⾥,⼀个单元可以是⼀个⽅法、类、包或者⼦系统。

因此,单元测试是指对代码中的最⼩可测试单元进⾏检查和验证,以便确保它们正常⼯作。

例如,我们可以给予⼀定的输⼊测试输出是否是所希望得到的结果。

在本篇博客中,作者将着重介绍 JUnit 4.X 版本的特性,这也是我们在⽇常开发中使⽤最多的版本。

2 特点JUnit提供了注释以及确定的测试⽅法;JUnit提供了断⾔⽤于测试预期的结果;JUnit测试优雅简洁不需要花费太多的时间;JUnit测试让⼤家可以更快地编写代码并且提⾼质量;JUnit测试可以组织成测试套件包含测试案例,甚⾄其他测试套件;Junit显⽰测试进度,如果测试是没有问题条形是绿⾊的,测试失败则会变成红⾊;JUnit测试可以⾃动运⾏,检查⾃⼰的结果,并提供即时反馈,没有必要通过测试结果报告来⼿动梳理。

3 内容3.1 注解@Test :该注释表⽰,⽤其附着的公共⽆效⽅法(即⽤public修饰的void类型的⽅法)可以作为⼀个测试⽤例;@Before :该注释表⽰,⽤其附着的⽅法必须在类中的每个测试之前执⾏,以便执⾏测试某些必要的先决条件;@BeforeClass :该注释表⽰,⽤其附着的静态⽅法必须执⾏⼀次并在类的所有测试之前,发⽣这种情况时⼀般是测试计算共享配置⽅法,如连接到数据库;@After :该注释表⽰,⽤其附着的⽅法在执⾏每项测试后执⾏,如执⾏每⼀个测试后重置某些变量,删除临时变量等;@AfterClass :该注释表⽰,当需要执⾏所有的测试在JUnit测试⽤例类后执⾏,AfterClass注解可以使⽤以清理建⽴⽅法,如断开数据库连接,注意:附有此批注(类似于BeforeClass)的⽅法必须定义为静态;@Ignore :该注释表⽰,当想暂时禁⽤特定的测试执⾏可以使⽤忽略注释,每个被注解为@Ignore的⽅法将不被执⾏。

junit 教程

junit 教程

junit 教程JUnit是一个Java语言的开源单元测试框架,主要用于编写和运行单元测试。

它广泛应用于Java开发中,是Java开发人员进行单元测试的首选工具之一。

本教程将为初学者介绍JUnit 的基本概念、用法和最佳实践,帮助读者快速入门并掌握JUnit的使用。

第一部分:JUnit 简介JUnit是一个简单且易于使用的测试框架,它提供了一种用于编写和运行单元测试的标准方式。

JUnit可以帮助开发人员对代码进行有效的测试,减少错误出现的概率,并提高代码的质量。

JUnit由Kent Beck和Erich Gamma于1998年创建,并在JUnit 3中被引入,至今已经发展到JUnit 5。

第二部分:JUnit 的基本用法在本部分,我们将介绍JUnit的基本用法。

首先,我们将创建一个简单的Java项目,并添加JUnit相关依赖。

然后,我们将学习如何编写一个简单的单元测试,并使用JUnit的注解来标记测试方法。

我们还将了解如何使用断言来验证代码的预期行为,并学习如何使用JUnit的一些附加功能,比如超时测试和忽略测试。

第三部分:JUnit 的高级特性在本部分,我们将介绍JUnit的一些高级特性,帮助读者进一步提升单元测试的质量和效率。

我们将讨论如何使用参数化测试来减少重复代码,并展示如何使用测试套件来组织和执行多个测试类。

我们还将学习如何处理异常和超时,并了解如何使用Mockito等测试框架来模拟对象和交互。

第四部分:JUnit 的最佳实践在本部分,我们将探讨一些JUnit的最佳实践,帮助开发人员编写可维护、可靠的单元测试。

我们将讨论测试命名规范、测试覆盖率和测试代码的组织结构。

我们还将学习如何处理测试数据和测试环境的管理,以及如何使用测试运行器和扩展点来扩展JUnit的功能。

第五部分:其他测试框架与工具在本部分,我们将介绍一些与JUnit相关的其他测试框架和工具。

我们将讨论如何使用Spring Test、TestNG和Mockito等框架来进行更复杂的测试。

junit4使用说明

junit4使用说明

测试任何可能的错误。

单元测试不是用来证明您是对的,而是为了证明您没有错。

2、单元测试代码和被测试代码使用一样的包,不同的目录。

--junit4.0使用注意说明;3、测试方法必须按照规范书写1. 测试方法必须使用注解修饰。

2. 测试方法必须使用 public void 修饰,而且不能带有任何参数。

@Test public void wordFormat4DBegin(){String target = "EmployeeInfo";String result = WordDealUtil.wordFormat4DB(target);assertEquals("employee_info", result);}4、同一测试类中的所有测试方法都可以共用它来初始化 Fixture 和注销 Fixture。

和编写 JUnit 测试方法一样,公共 Fixture 的设置也很简单,您只需要:1. 使用注解 org,junit.Before 修饰用于初始化 Fixture 的方法。

2. 使用注解修饰用于注销 Fixture 的方法。

3. 保证这两种方法都使用 public void 修饰,而且不能带有任何参数。

//初始化Fixture方法@Before public void init(){……}//注销Fixture方法@After public void destroy(){……}引入了类级别的 Fixture 设置方法,编写规范如下:1. 使用注解 org,junit.BeforeClass 修饰用于初始化 Fixture 的方法。

2. 使用注解修饰用于注销 Fixture 的方法。

3. 保证这两种方法都使用 public static void 修饰,而且不能带有任何参数//类级别Fixture初始化方法@BeforeClass public static void dbInit(){……}//类级别Fixture注销方法@AfterClass public static void dbClose(){……}类级别的 Fixture 仅会在测试类中所有测试方法执行之前执行初始化,并在全部测试方法测试完毕之后执行注销方法。

实验4JUnit 3.x和JUnit 4.x的测试框架

实验4JUnit 3.x和JUnit 4.x的测试框架

河北科技大学实验报告级专业班学号年月日姓名同组人指导教师实验名称成绩实验类型验证型批阅教师一、实验目的熟悉JUnit 3.x和JUnit 4.x的测试框架。

二、实验内容和步骤这里的计算器程序是在NetBeans中实现的,在NetBeans中的JUnit测试方法如下。

第一步:首先在NetBeans中新建一个项目,并新建包calculator,在该包中建立若干类,实现一个类似于windows计算器的简单程序,主要用于测试加,减,乘,除运算的功能。

其中实现四则运算的类为MyMath.java,第二步:检查项目下的“测试库”中是否有JUnit3,JUnit4的单元测试包,如果没有,通过在“测试库”上单击右键,选择“添加库”添加单元测试包。

第三步:生成JUnit测试框架。

在要测试MyMath.java类上,单击右键,在弹出的快捷菜单中依次选择【工具】→【创建JUnit测试】,或按下Ctrl+Shift+U键。

第四步:在弹出的“选择JUnit版本”窗口中选择创建测试框架的JUnit版本,有JUnit 3.x和JUnit 4.x两个版本,选择其中一个并单击【选择】按钮。

第五步:在弹出的“创建测试”窗口中,选择测试类的位置,默认是在项目中的“测试包”中,并选择“代码生成”的相关选项,单击【确定】按钮,在项目的“测试包”中新增calculator 项目,并在项目下新增MyMath.java类的测试类MyMathTest.java类,同时在编辑窗口显示自动生成的MyMathTest.java测试类的源代码。

第六步:执行测试。

依次选择菜单【运行】→【测试项目】,在窗口下方的控制台中出现测试结果。

进度条为绿色表示通过的测试,红色表示未通过的测试。

该测试中有3个测试通过,一个测试出现错误,主要是因为测试中进行了“除0”的操作。

三、记录并分析测试脚本的内容package calculator;import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;import static org.junit.Assert.*;/**** @author Administrator*/public class MyMathTest {public MyMathTest() {}@BeforeClasspublic static void setUpClass() throws Exception {}@AfterClasspublic static void tearDownClass() throws Exception { }@Beforepublic void setUp() {}@Afterpublic void tearDown() {}/*** Test of add method, of class MyMath.*/@Testpublic void testAdd() {System.out.println("add");double num1 = 0.0;double num2 = 0.0;double expResult = 0.0;double result = MyMath.add(num1, num2);assertEquals(expResult, result, 0.0);// TODO review the generated test code and remove the default call to fail. //fail("The test case is a prototype.");}/*** Test of subtract method, of class MyMath.*/@Testpublic void testSubtract() {System.out.println("subtract");double num1 = 0.0;double num2 = 0.0;double expResult = 0.0;double result = MyMath.subtract(num1, num2);assertEquals(expResult, result, 0.0);// TODO review the generated test code and remove the default call to fail. //fail("The test case is a prototype.");}/*** Test of multiply method, of class MyMath.*/@Testpublic void testMultiply() {System.out.println("multiply");double num1 = 0.0;double num2 = 0.0;double expResult = 0.0;double result = MyMath.multiply(num1, num2);assertEquals(expResult, result, 0.0);// TODO review the generated test code and remove the default call to fail. //fail("The test case is a prototype.");}/*** Test of div method, of class MyMath.*/@Testpublic void testDiv() {System.out.println("div");double num1 =2.0;double num2 = 0.5;double expResult = 4.0;double result = MyMath.div(num1, num2);assertEquals(expResult, result, 0.0);// TODO review the generated test code and remove the default call to fail. // fail("The test case is a prototype.");}}四、实验总结通过本次实验使我初步了解到了JUnit 4.x的测试框架。

相关主题
  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的方法。

相关文档
最新文档