Junit4TestCase
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,这个请随意。
单元测试(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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。
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中的参数化测试文章分类:Java编程为了保证单元测试的严谨性,我们模拟了不同的测试数据来测试方法的处理能力,为此我们编写了大量的单元测试方法。
这些测试方法都是大同小异:代码结构都是相同的,不同的仅仅是测试数据和期望值。
为了解决这个问题,Junit4提供了参数化测试。
1)为准备使用参数化测试的测试类指定特殊的运行器,org.junit.runners.Parameterized2)为测试声明几个变量,非别用于存放期望值和测试所用数据。
3)为测试了类声明一个使用注解org.junit.runners.Parameterized.Parameters修饰的,返回值为java.util.Collection的公共静态方法,并在此方法中初始化所有需要的测试的参数对。
4)为测试类声明一个带有参数的公共构成函数,并在其中为第二个环节中声明的几个变量赋值。
下面是一个测试加法的参数化测试,测试通过程序计算 1+2=3? 0+0=0? -1-3=-4? Java代码1.package demo.junit4;2.3.import static org.junit.Assert.assertEquals;4.5.import java.util.Arrays;6.import java.util.Collection;7.8.import org.junit.Test;9.import org.junit.runner.RunWith;10.import org.junit.runners.Parameterized;11.import org.junit.runners.Parameterized.Parameters;12.13.14./**15. * 参数化设置16. *17. * 1 测试类必须由parameterized测试运行器修饰18. * 2 准备数据,数据的准备需要在一个方法中进行,该方法需要满足一定的要求19. * 1)该方法必须有parameters注解修饰20. * 2)该方法必须为public static的21. * 3)该方法必须返回Collection类型22. * 4)该方法的名字不作要求23. * 5)该方法没有参数24. *25. * int.class == Integer.TYPE != Integer.class26. */27.// 测试运行器28.@RunWith(Parameterized.class)29.public class ParameterTest {30. private int expeted;31. private int input1;32. private int input2;33.34. @Parameters35. @SuppressWarnings("unchecked")36. public static Collection perpareData() {37. Object[][] objects = { {3,1,2}, {0,0,0}, {-4,-1,-3} };38.39. return Arrays.asList(objects);40. }41.42. public ParameterTest(int expected, int input1, int input2){43. this.expeted = expected;44. this.input1 = input1;45. this.input2 = input2;46. }47.48. @Test public void testAdd() {49. Calculator cal = new Calculator();50. assertEquals(expeted, cal.add(input1, input2));51. }52.}。
junit测试实验报告
junit测试实验报告JUnit测试实验报告简介:JUnit是一种用于Java编程语言的测试框架。
它提供了一种简单而有效的方式来编写和运行测试代码,以确保软件的正确性。
在本实验中,我们将介绍JUnit 的基本概念和使用方法,并通过实际案例来展示其应用。
一、什么是JUnit?JUnit是一个开源的Java测试框架,用于编写和运行可重复的自动化测试。
它提供了一套用于测试代码的API,并支持各种断言和异常处理机制。
JUnit的主要目标是提高软件开发的效率和质量,通过自动化测试来减少人工测试的工作量,同时提供可靠的测试结果。
二、为什么使用JUnit?1. 提高开发效率:JUnit可以自动运行测试代码,并提供详细的测试报告,帮助开发人员快速定位和修复问题。
2. 简化测试过程:JUnit提供了一套简单的API,使得编写测试代码变得更加容易和直观。
3. 增强代码质量:通过编写全面的测试用例,可以有效地发现和修复潜在的bug,提高代码的健壮性和可靠性。
三、JUnit的基本使用方法1. 引入JUnit库:在项目的构建文件中添加JUnit的依赖,例如在Maven项目中,在pom.xml文件中添加JUnit的依赖项。
2. 编写测试类:创建一个新的Java类,并使用@Test注解来标记测试方法。
测试方法应该具有独立性,不依赖于其他方法或外部资源。
3. 运行测试:使用JUnit提供的测试运行器来执行测试代码。
可以选择在IDE中直接运行测试类,或者使用构建工具(如Maven或Gradle)来执行测试。
4. 断言和异常处理:使用JUnit提供的断言方法来验证预期结果和实际结果是否一致。
同时,可以使用@ExpectedException注解来测试方法是否会抛出指定的异常。
四、案例演示假设我们要编写一个简单的计算器类Calculator,其中包含加法和减法两个方法。
我们可以使用JUnit来编写测试用例,以验证这两个方法的正确性。
JUnit4中@Before、@After、@Test等注解的作用
JUnit4中@Before、@After、@Test等注解的作⽤JUnit4使⽤Java5中的注解(annotation),以下是JUnit4常⽤的⼏个annotation:@Before:初始化⽅法对于每⼀个测试⽅法都要执⾏⼀次(注意与BeforeClass区别,后者是对于所有⽅法执⾏⼀次)@After:释放资源对于每⼀个测试⽅法都要执⾏⼀次(注意与AfterClass区别,后者是对于所有⽅法执⾏⼀次)@Test:测试⽅法,在这⾥可以测试期望异常和超时时间@Test(expected=ArithmeticException.class)检查被测⽅法是否抛出ArithmeticException异常@Ignore:忽略的测试⽅法@BeforeClass:针对所有测试,只执⾏⼀次,且必须为static void@AfterClass:针对所有测试,只执⾏⼀次,且必须为static void⼀个JUnit4的单元测试⽤例执⾏顺序为:@BeforeClass -> @Before -> @Test -> @After -> @AfterClass;每⼀个测试⽅法的调⽤顺序为:@Before -> @Test -> @After;public class JUnit4Test {@Beforepublic void before() {System.out.println("@Before");}@Test/***Mark your test cases with @Test annotations.*You don’t need to prefix your test cases with “test”.*tested class does not need to extend from “TestCase” class.*/public void test() {System.out.println("@Test");assertEquals(5 + 5, 10);}@Ignore@Testpublic void testIgnore() {System.out.println("@Ignore");}@Test(timeout = 50)public void testTimeout() {System.out.println("@Test(timeout = 50)");assertEquals(5 + 5, 10);}@Test(expected = ArithmeticException.class)public void testExpected() {System.out.println("@Test(expected = Exception.class)");throw new ArithmeticException();}@Afterpublic void after() {System.out.println("@After");}@BeforeClasspublic static void beforeClass() {System.out.println("@BeforeClass");};@AfterClasspublic static void afterClass() {System.out.println("@AfterClass");};};输出结果:@BeforeClass@Before@Test(timeout = 50)@After@Before@Test(expected = Exception.class)@After@Before@Test@After@AfterClass@BeforeClass and @AfterClass@Before and @After在⼀个类中只可以出现⼀次在⼀个类中可以出现多次,即可以在多个⽅法的声明前加上这两个Annotaion标签,执⾏顺序不确定⽅法名不做限制⽅法名不做限制在类中只运⾏⼀次在每个测试⽅法之前或者之后都会运⾏⼀次@BeforeClass⽗类中标识了该Annotation的⽅法将会先于当前类中标识了该Annotation的⽅法执⾏。
Junit4单元测试
Junit4单元测试Junit4单元测试第⼀部分⽤法1.1 常见功能典型配置:/*⽤于配置spring Boot中测试的环境*/@RunWith(SpringJUnit4ClassRunner.class)@SpringApplicationConfiguration(classes = MyBlogApplication.class)/* 开启事务,测试完成默认⾃动回滚,不会弄脏数据库 */@Transactionalpublic class WhoHaveWhatTagsMapperTest {@BeforeClasspublic static void beforeClass() {}@Beforepublic void setUp() throws Exception {}@Afterpublic void tearDown() throws Exception {}@Testpublic void insertWhoHaveWhatTags() throws Exception {}@Testpublic void selectBlogByTag() throws Exception {}@Testpublic void deleteWhoHaveWhatTags() throws Exception {}}@Test:把⼀个⽅法标记为测试⽅法两个属性:excepted;表⽰测试在执⾏中期望抛出的异常类型,如果不抛出,反⽽报错。
timeout:超时抛出异常。
单位毫秒@Test(timeout = 2000)@Test(expected = Exception.class)public void testFactorialException() throws Exception {new Math().factorial(-1);fail("factorial参数为负数没有抛出异常");}@Before:每⼀个测试⽅法执⾏前⾃动调⽤⼀次@After:每⼀个测试⽅法执⾏完⾃动调⽤⼀次@BeforeClass:所有测试⽅法执⾏前执⾏⼀次,在测试类还没有实例化就已经被加载,所以⽤static修饰@AfterClass:所有测试⽅法执⾏完执⾏⼀次,在测试类还没有实例化就已经被加载,所以⽤static修饰@Ignore:暂不执⾏该测试⽅法setup⽅法主要实现测试前的初始化⼯作teardown⽅法主要实现测试完成后垃圾回收⼯作!setup⽅法主要实现测试前的初始化⼯作,teardown⽅法主要实现测试完成后垃圾回收⼯作!测试⽅法的声明要求:名字可以随便取,没有任何限制,但是返回值必须为void,⽽且不能有任何参数。
junit测试实验报告
junit测试实验报告
《Junit测试实验报告》
在软件开发过程中,测试是非常重要的一环。
而Junit作为一个广泛应用的Java 单元测试框架,可以帮助开发人员快速、方便地进行测试。
本文将通过一个实验报告,介绍Junit测试的基本原理和使用方法。
实验目的:
1. 了解Junit测试框架的基本原理和使用方法
2. 掌握Junit测试的常用注解和断言方法
3. 通过实际示例,展示Junit测试的实际应用
实验内容:
本次实验将以一个简单的Java类为例,演示如何使用Junit进行单元测试。
该Java类包含一个简单的方法,用于计算两个整数的和。
实验步骤:
1. 导入Junit测试框架
2. 创建一个测试类,并在该类中编写测试方法
3. 使用Junit的注解和断言方法,对目标方法进行测试
4. 运行测试,并查看测试结果
实验结果:
经过测试,目标方法运行正常,测试结果符合预期。
实验总结:
通过本次实验,我们了解了Junit测试框架的基本原理和使用方法。
Junit提供了丰富的注解和断言方法,可以帮助开发人员编写简洁、高效的测试代码。
通
过Junit测试,可以有效地提高软件质量,减少bug的产生。
在实际开发中,我们应该充分利用Junit测试框架,编写完善的测试用例,保证软件的稳定性和可靠性。
同时,我们也应该不断学习和探索,掌握更多的测试技巧和方法,为软件开发贡献自己的力量。
总之,Junit测试是软件开发过程中不可或缺的一部分,希望通过本次实验,能够对Junit测试有更深入的了解,为我们的软件开发工作带来更大的帮助。
KC06110000004_习题试题库_单元4 单元测试
一、单选题所属项目项目四题型单选题出题人题目编号分值 2 难易程度易知识点关联单元测试题目内容软件测试是软件质量保证的重要手段,下述()测试是软件测试的最基础环节?A.功能测试B.单元测试C.结构测试D.验收测试标准答案B所属项目项目四题型单选题出题人题目编号分值 2 难易程度中知识点关联单元测试题目内容自底向上单元测试的策略是首先对模块调用图上的哪一层模块进行测试()A.最底层B.下一层C.最高层D.上一层标准答案 A所属项目项目四题型单选题出题人题目编号分值 2 难易程度中知识点关联单元测试题目内容单元测试的主要任务不包括()。
A.出错处理B.全局数据结构C.独立路径D.模块接口标准答案B所属项目项目四题型单选题出题人题目编号分值 2 难易程度中知识点关联测试用例题目内容通常,在()的基础上,将所有模块按照设计要求组装成系统A.组装测试B.系统测试C.验收测试D.单元测试标准答案D所属项目项目四题型单选题出题人题目编号分值 2 难易程度易题目内容单元测试主要针对模块的几个基本特征进行测试,该阶段不能完成的测试是()。
A. 系统功能B. 局部数据结构C. 重要的执行路径D. 错误处理标准答案A所属项目项目四题型单选题出题人题目编号分值 2 难易程度易知识点关联单元测试题目内容下面的哪一项测试步骤中需要进行局部数据结构测试:()A.单元测试B.集成测试C.确认测试D.系统测试标准答案 A所属项目项目四题型单选题出题人题目编号分值 2 难易程度易知识点关联单元测试题目内容单元测试将根据在( )阶段中产生的规格说明进行A. 可行性研究与计划 B. 需求分析C. 概要设计 D. 详细设计标准答案 D所属项目项目四题型单选题出题人题目编号分值 2 难易程度中知识点关联黒盒测试、白盒测试、单元测试题目内容在进行单元测试时,常用的方法是()A.采用黑盒测试,辅之以白盒测试B.采用白盒测试,辅之以黑盒测试C.只使用黑盒测试D.只使用白盒测试标准答案 B所属项目项目四题型单选题出题人题目编号分值 2 难易程度难题目内容下列那种测试不属于面向对象单元测试考虑的范畴()A.成员方法的测试B.类的测试C.类树的测试D.多个相互协作的类树的测试标准答案 D所属项目项目四题型单选题出题人题目编号分值2难易程度易知识点关联JUnit的基本概念题目内容以下关于使用JUnit的说法,正确的有()A.对每个测试类,都要定义一个测试用例B.Error错误是一个期望的被assert方法检查到的结果C.Faile失败则是意外的问题引起的D.当JUnit执行测试时,它在执行每个testXXXX()方法前都调用setUp(),初始化所有测试的Fixture,而在执行每个testXXXX()方法后都调用testDown(),释放在setUp()中分配的永久性资源。
软件测试实验JUnit单元测试
第三章JUnit单元测试实验1 开始使用JUnit【实验目的】1、学习使用JUnit4.X进行单元测试;2、掌握JUnit4.X编写测试代码的方法;3、应用JUnit进行单元测试,掌握最佳实践编写测试代码。
【实验环境】1、Windows环境,MyEclipse或Eclipse,JUnit4.x。
2、每个学生操作1台电脑。
【实验原理】JUnit是一个开源的Java编程语言的单元测试框架,最初由Erich Gamma 和Kent Beck 编写。
Junit测试是一种白盒测试工具。
JUnit是一套框架,继承TestCase类,就可以用Junit 进行自动测试了。
具有JUnit经验对于应用“测试驱动开发(TDD)”的程序开发模型是非常重要的。
JUnit本质上是一套框架,即开发者制定了一套条条框框,遵循这此条条框框要求编写测试代码,如继承某个类,实现某个接口,就可以用JUnit进行自动测试了。
由于JUnit相对独立于所编写的代码,可以测试代码的编写可以先于实现代码的编写,XP 中推崇的test first design的实现有了现成的手段:用JUnit写测试代码,写实现代码,运行测试,测试失败,修改实现代码,再运行测试,直到测试成功。
以后对代码的修改和优化,运行测试成功,则修改成功。
Java 下的team 开发,采用cvs(版本控制) + ant(项目管理) + JUnit (集成测试) 的模式时,通过对ant的配置,可以很简单地实现测试自动化。
【实验内容】根据下面的实验步骤完成实验。
1、JUnit包下载。
(1) 从下载Junit,打开该链接,会有一个下载链接,下载Junit4.X.zip,保存在用户机的文件系统中。
(2) 解包Junit-4.X,得到如图3-1的解包文件。
图1 Junit解包文件文件/目录描述JUnit框架结构、扩展和测试运行器的二进制发布src.jar JUnit的源代码,包括一个Ant 的buildfile文件junit 是个目录,内有JUnit自带的用JUnit编写的测试示例程序javadoc JUnit完整的API文档doc 一些文档和文章,包括“Test Inf ected: Programmers Love Writing Tests”和其它一些资料,可以帮助我们入门。
junit使用简明手册
junit使用简明手册来自网辉在使用XP进行开发的过程,unit test是必不可少的环节。
作为unit test,junit是首选的工具。
本文从使用目的、如何使用、以及使用中需要考虑的问题,简略描述了junit的基本用法。
使用目的junit是java中书写unit test的framework,目前一些流行的unit test工具大都都是在junit上扩展而来的。
目前它的版本是junit3.8.1,可以从上下载。
用法1. 基本使用步骤,Junit的使用非常简单,它的基本使用步骤:- 创建,从junit.framework.TestCase派生unit test需要的test case- 书写测试方法,提供类似于如下函数签名的测试方法:public void testXXXXX();- 编译,书写完test case后,编译所写的test case类- 运行,启动junit test runner,来运行这个test case。
Junit提供了2个基本的test runner:字符界面和图形界面。
启动命令分别如下:a 图形界面:java junit.swingui.TestRunner XXXXXb 字符界面:java junit.textui.TestRunner XXXXX2. 使用例子:import junit.frmework.TestCase;public class TestSample extends TestCaset{public void testMethod1(){assertTrue( true);}3. setUp与tearDown,这两个函数是junit framework中提供初始化和反初始化每个测试方法的。
setUp 在每个测试方法调用前被调用,负责初始化测试方法所需要的测试环境;tearDown在每个测试方法被调用之后被调用,负责撤销测试环境。
它们与测试方法的关系可以描述如下:测试开始-> setUp -> testXXXX -> tearDown ->测试结束4. 使用例子:import junit.frmework.TestCase;public class TestSample extends TestCaset{protected void setUp(){//初始化……}public void testMethod1(){assertTrue( true);}potected void tearDown(){//撤销初始化……}}5. 区分fail、exception。
junit单元测试步骤
junit单元测试步骤:1、导入包junit测试包:JUnit测试版本,3.81版,4.0版,导入对应的jar包; 2、写一个类扩展(继承) TestCase; 3、在需要测试的方法名前加test生成新的测试方法;4、运行测试,用断言(assert***)的方法测试成功(显示绿色)或失败(显示红色),或者自己判断结果正确与否。
junit单元测试:
1、单元测试(unittesting),是在计算机编程中,针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作。
2、单元测试(模块测试)是开发者编写的一小段代码,用于检验被测代码的一个很小的、很明确的功能是否正确。
3、单元测试会为我们的承诺做保证。
编写单元测试就是用来验证这段代码的行为是否与我们期望的一致。
在实践工作中,进行了完整计划的单元测试和编写实际的代码所花费的精力大致上是相同的。
一旦完成了这些单元测试工作,很多Bug将被纠正,在确信他们手头拥有稳定可靠的部件的情况下,开发人员能够进行更高效的系统集成工作。
Junit源码分析
先得到TestResult的对象,然后通过它的对象把TestListener的子类加到TestResult里面去。
再通过Test来得到TestSuite对象,构造方法传了Class进去,然后对这个Class进行判断,看是不是Test
能。
使用组合模式能够很好的解决这个问题。
好处:
1)JUnit可以统一地处理组合结构TestSuite和单个对象TestCase,避免了条件判断
2)很容易增加新的TestCase。
TestResult,负责收集TestCase所执行的结果,它将结果分为两类,客户可预测的Failure和没有预测的Error。同时负责将测试结果转发到TestListener(该接口由TestRunner继承)处理;
结果的地方。而Test接口是为了统一TestCase和TestSuite的类型,
---------------------------------------------------------------
Assert类提供了JUnit使用的一整套的断言,这套断言都被TestCase继承下来,Assert也就变成了透明的
证代码的的少量变动不会破坏整个系统。
存在一定的优点:源代码是公开的,不需要去购买框架,易于集成到构建。针对某一个类的测试代
码通过较少的改动便于应用另一个类的测试,还可以便于Junit的扩展。
TestSuite负责包装和运行所有的TestCase。待测得类中可能包括了对被测类的多个测试,而TestSuit负
他包括两个添加错误和失败的方法,开始测试和结束测试的方法
在Eclipse中使用JUnit4进行单元测试(初级篇)
我们在编写大型程序的时候,需要写成千上万个方法或函数,这些函数的功能可能很强大,但我们在程序中只用到该函数的一小部分功能,并且经过调试可以确定,这一小部分功能是正确的。
但是,我们同时应该确保每一个函数都完全正确,因为如果我们今后如果对程序进行扩展,用到了某个函数的其他功能,而这个功能有bug的话,那绝对是一件非常郁闷的事情。
所以说,每编写完一个函数之后,都应该对这个函数的方方面面进行测试,这样的测试我们称之为单元测试。
传统的编程方式,进行单元测试是一件很麻烦的事情,你要重新写另外一个程序,在该程序中调用你需要测试的方法,并且仔细观察运行结果,看看是否有错。
正因为如此麻烦,所以程序员们编写单元测试的热情不是很高。
于是有一个牛人推出了单元测试包,大大简化了进行单元测试所要做的工作,这就是JUnit4。
本文简要介绍一下在Eclipse3.2中使用JUn it4进行单元测试的方法。
首先,我们来一个傻瓜式速成教程,不要问为什么,Follow Me ,先来体验一下单元测试的快感!首先新建一个项目叫JUnit_Test,我们编写一个Calculator类,这是一个能够简单实现加减乘除、平方、开方的计算器类,然后对这些功能进行单元测试。
这个类并不是很完美,我们故意保留了一些Bug 用于演示,这些Bug在注释中都有说明。
该类代码如下: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 -npublic 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() { // 将结果清零public int getResult() { return result;第二步,将JUnit4单元测试包引入这个项目:在该项目上点右键, 点属性”如图:—卜艸result = 0;File Edit Scirce Reactor Maviqate Search Project Run Wfridcw, Help ■希書吐&〒 訂 &—JUnft:占 Formaklest''S 日JI 丁锻 2 GUITestlr _r I.'.I? ILaveRennennberWartls J T J*戸JUn#4 Testil> src卜 ft :P£ Sysl 卜» JUhit 吟'M/CbckLzr Servers s> 'U test|::严pr ivate stat lc Ca leu la. tor calculstt-or@Beicre13puti 1 ic void setUp () throwsExc&ptiDncalculator , clear ():国 Gaku^tWijsvaljO C^kul^rT^tlijoya 圖 NewCo Into—叮pen in Mew WindowOpen Type Hieurch^网void testAddU { Lculator . add.(2);二 <op/Ctrl+<sertEquals (5 f tor. getReaCop/ Quaff isd Nam&^7=. PasteCtrl+V乂 CeleteD&latevoid tescSut )stracE ()(B LI I L I Path► Lculator , ^dd.( 10):Source ^lt+Shift+-5Lculatcir.suijstraLct (2):Fefac^orAlt+ShiFt-hT卜 5er tEquals ( S f .tar ・ get-Res^Import...口 Expirt .. iP* Multiply () Wot 7&c imp 1 erne nrF呂_ RefreshClose PnojectClose Unrelated Projectsvoid teatMult ip 1y (){Run As Cetiuci As Erohle As Validate TgamCofnpare WithRestore From Lot ml Hestor^...PDE TQils」nv 日Persisten 匚亡Declaration 匚onsole在弹出的属性窗口中,首先在左边选择 “Java Build Path ”,然后到右上选择“Libraries标签,之后在最右边点击 “Add Library …按钮,如下图所示:然后在新弹出的对话框中选择JUnit4并点击确定,如上图所示,JUnit4软件包就被包含进我们这个项目了。
junit里面TestCase的执行顺序
junit⾥⾯TestCase的执⾏顺序这⾥讨论的是junit在ant运⾏的情况,其他build⼯具应该也适⽤,但具体没试验过。
⾸先运⾏junit时是按照脚本中⽂件夹的顺序执⾏,如下脚本会先执⾏test1⽬录下的测试,其实是test2⽬录的,最后是test3⽬录的。
build.xml1 2 3 4 5 6 7 8 9 10 11<batchtest todir="${junit.dir}"><fileset dir="${test1.dir}"><include name="**/*Test.java"/> </fileset><fileset dir="${test2.dir}"><include name="**/*Test.java"/> </fileset><fileset dir="${test3.dir}"><include name="**/*Test.java"/> </fileset></batchtest>其次在同⼀个⽬录下,test case 的运⾏顺序是根据包名的顺序来执⾏的。
⽐如:a.a.a这个包名⾥⾯的test case会⽐a.a.b这个包名的test case先跑。
再次如果是同⼀个⽬录,且在同⼀个包名下的,会根据类名的顺序来执⾏test case。
⽐如:a.a.a.A.java会⽐a.a.a.B.java先执⾏。
最后如果是同个类的test case,则依照TestClass⾥⾯test case的顺序从上往下执⾏。
Junit Test case 的执⾏顺序有时候⽐较重要,可能⼀些test case会依赖与其他test case产⽣的结果才能执⾏,这个时候把要先执⾏的类按照上⾯的规则放在前⾯即可保证整个测试执⾏正确。
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;事实上,它们不必须扩展任何内容。
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之TestCase和TestSuite详解
TestCase:
在进行单元测试的时候,在JUNIT4之前,我们需要测试的代码所在的类一般都需要直接或者间接继承自TestCase,对于我们创建的 这个TestCase的子类,我们需要注意在我们这个类的测试流程,假设我们创建的TestCase子类中有两个测试用例testMethod1和 testMethod2,则执行顺序可以蚕食图3所示:
public static Test testFromSuiteMethod(Class<?> klass) throws Throwable { Method suiteMethod= null; Test suite= null; try { suiteMethod= klass.getMethod("suite"); if (! Modifier.isStatic(suiteMethod.getModifiers())) { throw new Exception(klass.getName() + ".suite() must be static"); } suite= (Test) suiteMethod.invoke(null); // static method } catch (InvocationTargetException e) { throw e.getCause(); } return suite; } 所以suite方法命名规则如下: 1).必须以“suite”方法命名; 2).suite方法的访问修饰权限必须为static; 3).suite方法必须为静态方法; 4).suite方法必须没有参数。
总结:
TestCase和TestSuite类是JUNIT中比较重要的两个类,TestCase和TestSuite可以认为是JAVA的合成设计模式在单元测试中的应用, 其实即便我们没有自己声明和创建TestSuite的子类,而且运行的TestCase子类的过程中也会创建TestSuite类,并将要执行的TestCase子 类的实例对象添加到TestSuite中去执行,其执行过程可以如图7所示:
实验4 白盒测试-JUnit
实验四 白盒测试-JUNIT【实验目的】通过上机使用JUNIT 工具, 体会单元测试、白盒测试的逻辑覆盖的方法。
【实验环境】Eclipse, JAVA5以上, JUNIT4【实验要求】根据书上第3章后的第6题(P63页)的流程图,用最少的测试用例完成覆盖要求:路径覆盖+条件组合覆盖。
要求:1)根据流程图进行单元测试用例设计;(函数输入:整型x 和y ,函数输出:y ) 2)完成源代码和测试代码。
3)执行JUNIT 输出测试结果,满足覆盖率且用例通过率100%(说明:如果你想体验TDD(TestDrivenDevelope),可以先完成测试代码,再写源代码,直至所有的测试代码全部Pass 。
)【实验指导】1、JUNIT 工具的使用说明·JUNIT 简介JUNIT 工具最初是由Erich Gamma 和 Kent Beck 编写的一个单元测试(Unit Test )的支持框架。
用来编写和执行单元测试,即所谓白盒测试。
本次实验我们采用的是JUNIT4,与以前的JUNIT3相比,使用起来简单方便许多。
在JUNIT3中,测试用例必须继承TestCase 类、且测试方法必须以test 开头,在JUnit4中,测试用例无需继承TestCase 类,只需要使用@Test 等注解。
·JUNIT 环境配置Eclipse 已带有JINIT 插件,无须安装只需要配置即可。
具体步骤: 1) 创建java Project 。
例:将项目命名为TDD2) 添加Junit4 libraires 。
选择对应项目 (在Package Explorer 中) -> 右击鼠标 -> 选择properties -> 选择Java Build Path (在左边的菜单中) -> 在右边选择标签 Libraries -> 单击按钮“Add Library” -> 选择JUnit , 单击按钮 “Next>” -> 选择eJUnit library version 为:JUnit4 -> 单击按钮“Finish” –> 单击按钮“OK”即可。
JUnit之TestCase和TestSuite详解
} 运行结果,如图4所示:
(图4) 有两个test函数,testMethod1和testMethod2,在生命周期的开始函数setUp以及结尾函数tearDown中分别产生了两次不同的 hashCode,根据Java语言中HashCode的概念我们可以知道这分别导致了我们的TestDemo类型的对象创建了两次。因此如果测试的 case增多,我们的TestDemo对象也会创建和case相同的个数。 对于测试用例testMethod1和testMethod2的函数声明,在我们书写用例函数的时候需要注意他们有一个共同的特点:
(图5) 一个简单的例子了解一下TestSuite: import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite;
public class TestSuiteDemo extends TestSuite{ public static Test suite(){ //创建TestSuite对象 TestSuite suite = new TestSuite(); //为TestSuite添加一个测试用例集合,参数为:Class<? extends TestCase> testClass //通过参数可以知道,其实该参数就是TestCase的子类 suite.addTestSuite(TestDemo.class); //创建具体的测试用例 Test test = TestSuite.createTest(TestDemo.class, "testMethod1"); //添加一个具体的测试用例
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.为什么用Junit?在我们写好一个模块后,经常会遇到一些问题,但是不知道问题出在哪一层,因此我们就对service层、dao层进行测试,来确定问题出现在哪一层。
2.T estCase Demo方案一:1.右击我们的Project,选择new Source Folder,将新文件夹命名为test。
2.已Service为例,右击我们要测试的Service,选择new other,选择JUnit TestCase点击next,选择要测试的方法,选择上setUpBeforeClass点击finish。
3.在测试类中声明一个service类型的静态属性。
private static UserService userService;在生成的setUpBeforeClass()方法中,加载配置文件,并拿到一个UserService的实例。
ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext-infrastructure.xml");userService = (UserService) context.getBean("userService");4.重写domain类的hashCode()和equals()方法,可以用eclipse自动生成。
自动生成时选上所有的属性。
5.每个Junit Test方法都必须遵循的原则是运行完成后不能改变数据。
可以将增删放在一起测试,将要新增的对象为ojbect1,在新增之后查出新增的数据,通过object1的id得到对象object2,判断object1是否equals(object2)(相等则新增测试通过),然后删除,再通过id查询得到对象object3,判断object3是否为null(为null则删除测试通过)。
改操作测试,先根据id查要修改的数据object4,再根据object5修改数据库中的数据(object5.id=objcet4.id),再根据id查修改后的数据得到object6,判断object5是否equals (object6),(相等则修改测试通过),然后将object4做为参数修改数据库中的数据,根据id从数据库拿出数据得到object6,判断object4是否equals(object6),相等则修改测试通过。
方法介绍:assertEquals():一般写三个参数,第二个参数o1和第三个参数o2都为object类型,当o1.equals(o2)为true时,测试通过,第一个参数str为String类型,当测试不通过(o1.equals(o2)为false时),str会在Failure Trace中显示出来。
assertNull():判断参数是否为空,为空则通过,否则,则不通过。
assertNotNull():预言参数非空,非空则通过,否则,则不通过。
assertTrue():预言参数为True,True则通过,False,则不通过。
还有一些方法不经常用,没列出来,在一个test方法中,如果用上述assert方法断言失败(没通过),则下面的代码不会执行。
各个test方法是一个独立的test unit。
@Testpublic void testAdd_Find_RemoveUser() {User user = new User(1,"Damon");userService.addUser(user);User u = new User();u = userService.findUser(1);assertEquals("insert fail",user,u);userService.removeUser(1);u = userService.findUser(1);assertEquals("delete fail",u,null);}@Testpublic void testModifyUser() {User user1 = new User();user1 = userService.findUser(2);User user2 = new User(2,"Gene");userService.modifyUser(user2);user2 = userService.findUser(2);userService.modifyUser(user1);User user3 = new User();user3 = userService.findUser(2);assertEquals("update fail",user1,user3);}6.如果想测试该类所有的方法,可以选中该测试类,右键Run As Junit Test,如果所有的方法测试都通过,则会出现显示所有的方法都通过。
如果有方法没通过则可以根据方法名和提示信息定位到出错的位置。
7.Junit Test的其他用法@Ignore:如果想测试整个类中除个别方法以外的其他方法,则可以在不想测试的方法上面加上@Ignore如果你像一个一个方法测试,那就没必要加@Ignore,在测试类中选中方法名,右键Run As Junit Test,这样就只会测试你选中的方法。
@Test中可以加参数expected=Exception.class,timeout=1000Expected的参数指的是,如果要测试的方法抛出你指定的异常,该方法才能通过。
Timeout可以测试循环,判断测试方法内有没有死循环,单位是毫秒8.Mapper层的测试和Service的测试基本一致,只是static属性定义你要测的mapper在beforeClass中,只需要修改getBean的参数和强制类型转换的类型。
方案二:方案一中的操作比较死板,为了在运行测试方法后不改变数据库中的数据,我们可以用sping-test包中的类,继承某些类可以只生成一个service对象,并支持自动回滚(进行玩增删改操作之后,事务会自动回滚,不用自己还原数据了)。
注意:er类的hashCode()和equals()仍需要重写。
2.Mapper方法中的<cache />要去掉,即不用cache。
1.测试类继承AbstractTransactionalDataSourceSpringContextTests,在类体中定义private static UserService userService;protected String[] getConfigLocations(){return new String[]{"applicationContext-infrastructure.xml"}; }@Overrideprotected void onSetUpInTransaction() throws Exception{u serService =(UserService)applicationContext.getBean("userService");}@Testpublic void testRemoveUser(){User u = new User();userService.removeUser(2);u = userService.findUser(2);assertNull(u);}@Testpublic void testAddUser(){User user = new User(1,"Damon");userService.addUser(user);User u = new User();u = userService.findUser(1);assertEquals("insert fail",user,u);}@Testpublic void testFindUser(){U ser user = new User();u ser = userService.findUser(2);S ystem.out.println(user.getId()+":"+user.getName());}@Testpublic void testModifyUser() {User user1 = new User();user1 = userService.findUser(2);User user4 = new User();User user2 = new User(2,"Gene");user4 = user2;userService.modifyUser(user2);user2 = userService.findUser(2);assertEquals("4 2",user4,user2);userService.modifyUser(user1);User user3 = new User();user3 = userService.findUser(2);assertEquals("update fail",user1,user3);}2.经测试该方法中的事物是可以回滚的。
但是继承的方法类是过时的。
方案三:(推荐使用)方案二中的继承类过时了,所以我们找到了另外一个类完成此功能AbstractTransactionalJUnit4SpringContextTests。
注意:er类的hashCode()和equals()仍需要重写。
2.Mapper方法中的<cache />要去掉,即不用cache。
1.该测试类继承AbstractTransactionalJUnit4SpringContextTests类。
在类上加注解@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations="/applicationContext-infrastructure.x ml")2.在类体中定义将要测试的service或mapper@Autowiredprivate UserMapper userMapper;3.像方案二中写测试方法就可以了,userMapper可以拿过来直接用。
@Testpublic void testInsertUser() {User user = new User(1, "Damon");userMapper.insertUser(user);User u = new User();u = userMapper.selectUser(1);assertEquals("insert fail", user, u);}@Testpublic void testSelectUser() {User user = new User();user = userMapper.selectUser(2);System.out.println(user.getId()+":"+user.getName());}// 四个test方法一起跑,该测试方法有问题,但是单独跑该测试方法,没有问题。