在Eclipse中使用JUnit4进行单元测试
Junit4单元测试框架的常用方法介绍
![Junit4单元测试框架的常用方法介绍](https://img.taocdn.com/s3/m/0bc411dd77eeaeaad1f34693daef5ef7ba0d1219.png)
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教程)[试题]](https://img.taocdn.com/s3/m/3e37a7fc6394dd88d0d233d4b14e852458fb39aa.png)
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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。
实验03.基本路径测试法和单元测试工具JUnit的使用
![实验03.基本路径测试法和单元测试工具JUnit的使用](https://img.taocdn.com/s3/m/9baec21f814d2b160b4e767f5acfa1c7aa008296.png)
实验报告
实验序号:03 实验项目名称:白盒测试工具JUnit的使用
学号122
姓名专业、班
实验地点实1-511 指导教师实验时间2013/4/18
一、实验目的
●掌握在Eclipse环境下JUnit单元测试工具的安装和使用方法;
●针对一个实际问题,在JUnit环境下设计并执行测试用例。
二、实验要求
●开发环境:Eclipse v3.7及以上版本;JUnit v4.10及以上版本;文本编辑软件。
●硬件要求:CPU PIV 以上,256M 内存,1G 硬盘空间。
●系统要求:Windows98/Me/XP/NT/2000,IE 5 以上。
三、实验内容与步骤
先将junit软件放入Eclipse安装目录下的plugins文件中,然后开始实验:
1、新建Java project命名...:
2、添加junit单元测试软件:
3、a、新建待测试类SaleMachine.java
b、新建Junit Test Case测试类SaleMachineTest.java:
C、对operation进行测试:d、
4、运行测试类(只测试一个用例),可以正确通过:
5、修改测试代码(添加新的测试用例),可以正确通过运行:
6、修改测试代码(添加第3个测试用例),运行出现错误:
7、查看错误提示:
8、根据错误修改代码:a、
b、
运行,任提示出错:
根据错误继续修改:a:
b:
运行,任提示出错:
继续修改错误:
a、
b、
9、修改完,运行测试代码,可以通过:。
JUnit4中的参数化测试
![JUnit4中的参数化测试](https://img.taocdn.com/s3/m/18c5a6ea551810a6f52486c9.png)
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.}。
Junit4单元测试
![Junit4单元测试](https://img.taocdn.com/s3/m/604cb2fd4bfe04a1b0717fd5360cba1aa8118c43.png)
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进行代码测试](https://img.taocdn.com/s3/m/2a02c4f664ce0508763231126edb6f1aff0071ec.png)
使用JUnit进行代码测试在软件开发过程中,代码测试是一个关键的环节,它可以帮助我们发现代码中存在的问题,并及时修复,从而提高软件的质量。
然而,传统的手动测试方式需要耗费大量的时间和人力,而使用JUnit进行代码测试则可以自动化测试过程,提高测试效率。
JUnit是基于Java语言的一个开源测试框架,它主要用于编写和运行单元测试。
在JUnit中,我们可以通过编写测试用例对程序的各个部分进行测试,从而验证代码的正确性和鲁棒性。
下面,我们来看一下如何使用JUnit进行代码测试。
1. 添加JUnit库首先,我们需要在项目中添加JUnit库。
在Eclipse中,可以通过如下步骤添加JUnit库:1) 右键单击项目名称,选择“Build Path” -> “Configure Build Path”。
2) 选择“Libraries”选项卡,点击“Add Library”按钮。
3) 选择“JUnit”库,点击“Next”按钮。
4) 选择JUnit版本,点击“Finish”按钮。
2. 编写测试用例在JUnit中,每个测试用例都是由一个或多个测试方法组成的。
测试方法以@Test注解标记,表示这是一个测试方法。
下面是一个简单的测试用例:import static org.junit.Assert.assertEquals;import org.junit.Test;public class MyTest {@Testpublic void testAdd() {int a = 1;int b = 2;assertEquals(3, a + b);}}在测试用例中,我们可以使用JUnit提供的断言方法进行测试,比如assertEquals()方法用于判断实际值是否等于期望值。
3. 运行测试用例当我们编写好测试用例后,就可以运行测试用例了。
在Eclipse 中,可以通过右键单击测试用例所在类的名称,选择“Run As” -> “JUnit Test”来运行测试用例。
eclipse中Junit的配置
![eclipse中Junit的配置](https://img.taocdn.com/s3/m/2a76dc8b0129bd64783e0912a216147917117e9c.png)
eclipse中Junit的配置Eclipse中的JUnit环境配置实例一、简介JUnit是一款由Erich Gamma(《设计模式》的作者)和Kent Beck(极限编程的提出者)编写的开源的回归测试框架,供Java编码人员做单元测试之用。
当前版本4.1,可以从/doc/1517492055.html网站上获得。
与早期的JUnit 3相比,JUnit 4.1依赖于Java 5.0的新特性,因此无法兼容于jdk 1.4,可以说是一个全新的框架。
由于这里使用的IDE是Eclipse 3.2.1加语言包,已经集成了junit 4.1,因此便免去下载和配置类库的麻烦了^_^二、创建项目下面打开Eclipse,点击菜单“文件”->“新建”->“项目”或“新建”按钮,打开“新建”对话框:请选中“Java项目”,点击“下一步”,进入“新建Java项目”对话框:在这个对话框中需要设置项目的名称以及项目所在目录,我为自己的项目起名为JUnitTest,目录为F:\YPJCCK\JUnit\Eclipse\JUnitTest。
由于Eclipse自带了JUnit类库,因此此时点击“完成”即可。
三、编写用于测试的JavaBean用于测试的JavaBean很简单,名为Book,只有id和name两个属性,这两个属性将分别用于两个用例当中。
下面开始编写该JavaBean。
请点击“文件”->“新建”->“类”,打开“新建Java类”对话框,设置包为net.test.unit.junit,名称为Book,并确保“public static void main(String[] args)”选项没有选中,然后点击“完成”。
修改代码如下:package net.test.unit.junit;public class Book {private String id = null;private String name = null;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}publicvoid setName(String name) {/doc/1517492055.html= name;}}至此,用于测试的JavaBean编写完成。
java编程之单元测试(Junit)实例分析(附实例源码)
![java编程之单元测试(Junit)实例分析(附实例源码)](https://img.taocdn.com/s3/m/1fabcbdf0408763231126edb6f1aff00bed5707c.png)
java编程之单元测试(Junit)实例分析(附实例源码)本⽂实例讲述了java编程之单元测试。
分享给⼤家供⼤家参考,具体如下:完整实例代码代码点击此处。
在有些时候,我们需要对我们⾃⼰编写的代码进⾏单元测试(好处是,减少后期维护的精⼒和费⽤),这是⼀些最基本的模块测试。
当然,在进⾏单元测试的同时也必然得清楚我们测试的代码的内部逻辑实现,这样在测试的时候才能清楚地将我们希望代码逻辑实现得到的结果和测试实际得到的结果进⾏验证对⽐。
废话少说,上代码:⾸先创建⼀个java⼯程,在⼯程中创建⼀个被单元测试的Student数据类,如下:package com.phicomme.hu;public class Student{private String name;private String sex;private int high;private int age;private String school;public Student(String name, String sex ,int high, int age, String school){ = name;this.sex = sex;this.high = high;this.age = age;this.school = school;}public String getName(){return name;}public void setName(String name){ = name;}public String getSex(){return sex;}public void setSex(String sex){this.sex = sex;}public int getHigh(){return high;}public void setHigh(int high){this.high = high;}public int getAge(){return age;}public boolean setAge(int age){if (age >25){return false;}else{this.age = age;return true;}}public String getSchool(){return school;}public void setSchool(String school){this.school = school;}}在eclipse下单元测试这个类:⾸先导⼊Junit包:选中java⼯程,点击⿏标右键--->选择properties---->在窗⼝中选Java Build Path---->在右侧点击Add Library---->在弹出的窗⼝列表中选中Junit---->下⼀步----->Junit 4(我⽤的是Junit 4)---->finish这样Junit 4包就导完了,接下来就是创建测试类:将测试类和被测试类放在不同的包中(也可以放在同⼀个包中,此处只是为了区别),代码如下:测试类1:package com.phicomme.test;import com.phicomme.hu.Student;import junit.framework.TestCase;public class StudentTest01 extends TestCase{Student testStudent;//此⽅法在执⾏每⼀个测试⽅法之前(测试⽤例)之前调⽤@Overrideprotected void setUp() throws Exception{// TODO Auto-generated method stubsuper.setUp();testStudent = new Student("djm", "boy", 178, 24, "华东政法");System.out.println("setUp()");}//此⽅法在执⾏每⼀个测试⽅法之后调⽤@Overrideprotected void tearDown() throws Exception{// TODO Auto-generated method stubsuper.tearDown();System.out.println("tearDown()");}//测试⽤例,测试Person对象的getSex()⽅法public void testGetSex(){assertEquals("boy", testStudent.getSex());System.out.println("testGetSex()");}//测试Person对象的getAge()⽅法public void testGetAge(){assertEquals(24, testStudent.getAge());System.out.println("testGetAge()");}}测试类2:package com.phicomme.test;import junit.framework.TestCase;import com.phicomme.hu.Student;public class StudentTest extends TestCase{private Student testStudent;@Overrideprotected void setUp() throws Exception{// TODO Auto-generated method stubsuper.setUp();testStudent = new Student("steven_hu", "boy", 170 , 23, "上海理⼯");}@Overrideprotected void tearDown() throws Exception{// TODO Auto-generated method stubsuper.tearDown();}public void testSetage(){assertTrue(testStudent.setAge(21));}public void testGetSchool(){//预期值和实际值不⼀样,测试时出现失败(Failure)assertEquals("南昌⼤学", testStudent.getSchool());}public void testGetName(){assertEquals("hdy", testStudent.getName());}}当然,如果同时需要⼀起测试以上这两个测试类,可以通过TestSuite类实现,它相当于是⼀个套件,可以把所有测试类添进来⼀起运⾏测试;代码如下:package com.phicomme.test;import com.phicomme.hu.StudentTest02;import junit.framework.Test;import junit.framework.TestSuite;public class AllTest{//static PersonTest p = new PersonTest();//static PersonTest p1 = new PersonTest();public static Test suite(){TestSuite suite = new TestSuite("Test for com.phicomme.test");//suite.addTest(p);//suite.addTest(p1);suite.addTestSuite(StudentTest.class);suite.addTestSuite(StudentTest01.class);return suite;}}最后,分别测试以上三个类(选中需要测试的类---->⿏标右键---->Run As---->Junit Test):StudentTest类的测试结果图:StudentTest01类的测试结果图:AllTest类的测试结果图:有关java的测试就讲到这⾥,希望对⼤家有帮助,有时间也会接着讲讲有关android的单元测试,和在⼿机上实现编写⼀个UI 界⾯替代eclipse如上图中的测试界⾯;希望本⽂所述对⼤家Java程序设计有所帮助。
软件测试实验JUnit单元测试
![软件测试实验JUnit单元测试](https://img.taocdn.com/s3/m/611d7f605ef7ba0d4b733b18.png)
第三章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单元测试步骤](https://img.taocdn.com/s3/m/153858777f21af45b307e87101f69e314332face.png)
junit单元测试步骤:1、导入包junit测试包:JUnit测试版本,3.81版,4.0版,导入对应的jar包; 2、写一个类扩展(继承) TestCase; 3、在需要测试的方法名前加test生成新的测试方法;4、运行测试,用断言(assert***)的方法测试成功(显示绿色)或失败(显示红色),或者自己判断结果正确与否。
junit单元测试:
1、单元测试(unittesting),是在计算机编程中,针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作。
2、单元测试(模块测试)是开发者编写的一小段代码,用于检验被测代码的一个很小的、很明确的功能是否正确。
3、单元测试会为我们的承诺做保证。
编写单元测试就是用来验证这段代码的行为是否与我们期望的一致。
在实践工作中,进行了完整计划的单元测试和编写实际的代码所花费的精力大致上是相同的。
一旦完成了这些单元测试工作,很多Bug将被纠正,在确信他们手头拥有稳定可靠的部件的情况下,开发人员能够进行更高效的系统集成工作。
Java单元测试:JUnit和Mockito的使用指南
![Java单元测试:JUnit和Mockito的使用指南](https://img.taocdn.com/s3/m/33012cfbc67da26925c52cc58bd63186bdeb925a.png)
Java单元测试:JUnit和Mockito的使用指南引言:在软件开发过程中,单元测试是一个至关重要的环节。
通过对代码的逐个单元进行测试,可以确保代码的质量和稳定性。
在Java开发中,JUnit和Mockito是两个常用的工具,它们可以帮助开发者更轻松地进行单元测试。
本文将为您介绍JUnit和Mockito的使用指南,帮助您更好地掌握这两个工具的功能和用法。
一、JUnit简介JUnit是一个Java语言的单元测试框架,它提供了一系列的注解和断言方法,方便开发者编写和执行单元测试。
JUnit的核心思想是“测试驱动开发”(Test-Driven Development,TDD),即在编写代码之前先编写测试用例,通过不断迭代的方式来开发和完善代码。
1.1 JUnit的安装和配置要使用JUnit,首先需要将JUnit的相关库文件导入到项目中。
可以通过Maven或Gradle等构建工具来管理依赖,也可以手动下载并导入JUnit的jar包。
导入完成后,就可以在代码中使用JUnit的注解和断言方法。
1.2 编写测试用例在JUnit中,每个测试用例都是一个独立的方法。
可以使用@Test注解来标记测试方法,JUnit会自动执行被标记的方法,并判断测试结果是否符合预期。
例如:```@Testpublic void testAddition() {int result = Calculator.add(2, 3);assertEquals(5, result);}```上述代码中,我们使用@Test注解标记了一个测试方法,该方法调用了被测试的Calculator类的add方法,并使用断言方法assertEquals来判断结果是否等于预期值。
如果测试通过,JUnit会输出“OK”;如果测试失败,JUnit会输出错误信息。
1.3 JUnit的高级特性除了基本的注解和断言方法外,JUnit还提供了一些高级特性,如参数化测试、测试套件和测试运行器等。
基于JUnit的单元测试报告
![基于JUnit的单元测试报告](https://img.taocdn.com/s3/m/c3a6966edd36a32d7375816d.png)
实验3 基于JUnit的单元测试一、实验目的与要求1、通过动手实际操作,巩固所学的单元测试相关知识2、初步了解JUnit工具的使用方法,加深对单元测试的认识3、熟悉eclipse工具的基本操作,掌握基于Eclipse工具的Java编程4、学会使用EclEmma对测试覆盖率进行分析5、通过实际代码案例,掌握单元测试的操作步骤二、实验设备1、电脑PC2、Eclipse3、Junit工具4、EclEmma工具三、实验过程步骤一:确定单元测试方案本实验选择StringUtils.java类中的四个方法作为Java单元测试的对象,选用Eclipse作为Java开发工具,下载并安装JUnit和EclEmma工具,使用JUnit进行单元测试,使用EclEmma进行覆盖率分析来辅助进行单元测试。
步骤二:JUnit的下载安装JUnit是一个开源的Java测试框架,是单元测试框架体系xUnit的一个实例,目前已经成为Java单元测试的标准。
JUnit软件包可以从网站http: 中下载,本次实验中使用的是JUnit4.10版本。
无须解压JUnit压缩包,选中eclipse中的工程,在Eclipse菜单Project的子项Properties中选择Java Build Path,单击Libraries标签,单击Add External JARs 按钮,选择junit4.10.jar后单击“打开”按钮,完成JUnit安装,安装完成后重启Eclipse,如图3-1所示。
图3-1在Eclipse中安装JUnit步骤三:EclEmma的下载与安装EclEmma是一个开源的覆盖率工具,可以帮助大家在单元测试的时候分析代码覆盖情况,可从网站/download.html中下载Jacoco 的Eclipse插件EclEmma最新版,本实验中使用的是Eclemma3.1.2版本解压eclemma-3.1.3.zip到Eclipse安装路径下的dropins目录中,并且保留如图3-2中的文件和文件夹。
在Eclipse中使用JUnit4进行单元测试(初级篇)
![在Eclipse中使用JUnit4进行单元测试(初级篇)](https://img.taocdn.com/s3/m/b90044ceb7360b4c2f3f64c2.png)
我们在编写大型程序的时候,需要写成千上万个方法或函数,这些函数的功能可能很强大,但我们在程序中只用到该函数的一小部分功能,并且经过调试可以确定,这一小部分功能是正确的。
但是,我们同时应该确保每一个函数都完全正确,因为如果我们今后如果对程序进行扩展,用到了某个函数的其他功能,而这个功能有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软件包就被包含进我们这个项目了。
Eclipse的Junit配置
![Eclipse的Junit配置](https://img.taocdn.com/s3/m/2d988d2a192e45361066f5cd.png)
1Eclipse中Junit的配置Eclipse IDE中集成了JUnit组件,无须另行下载和安装,但是为了更好的使用Junit(更多细节请参考),我们还要在Eclipse中进行一些设置。
其中主要是就是类路径变量的设置。
1.1创建变量JUNIT和JUNIT_SRC在project的classpath中添加junit.jar。
因此,建立一个新的classpath变量JUNIT。
选择Window->Preferences菜单栏打开Preferences对话框,如图1.1所示。
展开Java结点,选择Build Path->Classpath Variables项,如图1.2所示。
图1.1Preferences对话框图1.2Classpath Variables窗口然后点击New按钮打开New Variable Entry菜单,如图1.3所示。
输入新的变量名:JUNIT,配置路径为junit.jar。
在Eclipse3.0.2中,能够在/eclipse/plugins/org.junit_3.8.1/junit.jar下找到junit.jar。
然后点击OK,如图1.4所示。
图1.3New Variable Entry对话框图1.4创建JUNIT变量为了debug的需要,也要添加JUnit包的源代码。
您将在/eclipse/plugins/org.eclipse.jdt.source_3.0.2/src目录中发现许多包的源代码的JAR 文档。
为JUnit源代码创建一个新的变量,按照上面创建JUNTIT的步骤,但是此变量名为JUNIT_SRC(通常在源代码变量前面添加前缀_SRC)并且将他连接到/eclipse/plugins/org.eclipse.jdt.source_3.0.2/src/org.junit_3.8.1/junitsrc.zip,如图1.5所示。
图1.5创建JUNIT_SRC变量单击OK命令按钮,这样两个环境变量就创建完成,我们可以看见JUNIT和JUNIT_SRC两个变量,如图1.6所示。
使用JUnit Jupiter进行Java单元测试的新特性和实现方式
![使用JUnit Jupiter进行Java单元测试的新特性和实现方式](https://img.taocdn.com/s3/m/3c43db77f6ec4afe04a1b0717fd5360cba1a8d92.png)
使用JUnit Jupiter进行Java单元测试的新特性和实现方式在软件开发过程中,单元测试是不可或缺的一环。
它可以帮助开发人员在代码编写过程中及时发现和修复潜在的问题,提高代码质量和可靠性。
而JUnit Jupiter 作为Java中最常用的单元测试框架之一,为开发人员提供了一系列新的特性和实现方式,使得单元测试更加简洁、灵活和易于维护。
一、JUnit Jupiter的新特性1. 注解模型JUnit Jupiter引入了一种新的注解模型,使得编写测试用例更加灵活。
与传统的@Test注解不同,JUnit Jupiter提供了一系列的注解,如@DisplayName、@Nested、@RepeatedTest等,可以根据需要对测试用例进行更加精细的控制和组织。
@DisplayName注解可以为测试用例指定一个更加友好和描述性的名称,方便开发人员理解和识别。
@Nested注解可以将测试用例进行分组,使得测试用例的结构更加清晰和易于管理。
@RepeatedTest注解可以指定一个测试用例被重复执行的次数,方便进行性能和稳定性测试。
2. 断言模型JUnit Jupiter提供了一套更加强大和丰富的断言模型,使得编写断言更加简洁和可读。
传统的断言方式通常使用JUnit的assertEquals、assertTrue等方法,而JUnit Jupiter引入了一系列新的断言方法,如assertAll、assertThrows、assertTimeout等。
assertAll方法可以同时执行多个断言,如果其中一个断言失败,会将所有失败的断言结果一起报告,方便开发人员查看。
assertThrows方法可以验证代码是否抛出了指定的异常,方便进行异常处理的单元测试。
assertTimeout方法可以限制代码执行的时间,方便进行性能和并发测试。
3. 扩展模型JUnit Jupiter引入了扩展模型,使得开发人员可以自定义扩展来满足特定的测试需求。
junit用法
![junit用法](https://img.taocdn.com/s3/m/e4767ce777eeaeaad1f34693daef5ef7ba0d12ee.png)
junit用法Junit是一个Java语言的单元测试框架,它可以帮助开发人员进行单元测试。
下面详细介绍Junit的用法。
一、安装Junit1. 下载Junit jar包;2. 将jar包添加到项目中;3. 导入Junit相关类。
二、编写测试用例1. 创建一个Java类,命名为TestXXX,XXX为被测试的类名;2. 在TestXXX类中编写测试方法,方法名必须以“test”开头;3. 使用Assert断言来判断测试结果是否正确。
三、运行测试用例1. 在Eclipse中右键点击TestXXX类,选择“Run As”->“JUnit Test”即可运行所有的测试方法;2. 在命令行中进入项目根目录,执行命令“javaorg.junit.runner.JUnitCore TestXXX”,即可运行所有的测试方法。
四、常用注解1. @Test:标记一个方法为测试方法;2. @Before:在每个@Test方法之前执行;3. @After:在每个@Test方法之后执行;4. @BeforeClass:在所有@Test方法之前执行,只会执行一次;5. @AfterClass:在所有@Test方法之后执行,只会执行一次。
五、常用断言1. assertEquals(expected, actual):判断两个值是否相等;2. assertArrayEquals(expected, actual):判断两个数组是否相等;3. assertTrue(condition):判断条件是否为真;4. assertFalse(condition):判断条件是否为假;5. assertNull(object):判断对象是否为null;6. assertNotNull(object):判断对象是否不为null。
六、运行顺序1. 每个测试方法都会在一个新的实例中运行;2. 测试方法的执行顺序是不确定的,应该保证每个测试方法都是独立的。
eclipse单元测试生成报告
![eclipse单元测试生成报告](https://img.taocdn.com/s3/m/8662a6805ebfc77da26925c52cc58bd631869385.png)
eclipse单元测试生成报告Eclipse 提供了一个名为 JUnit 的框架,可以用于编写和运行单元测试。
在Eclipse 中编写单元测试后,可以通过以下步骤生成测试报告:1. 打开 Eclipse,并打开需要生成测试报告的项目。
2. 在项目上右键单击,选择“New” -> “Other”,在弹出的对话框中选择“JUnit” -> “JUnit Test Case”。
3. 在“JUnit Test Case”对话框中,输入测试类名和测试方法名,选择需要运行的测试方法,然后点击“Finish”按钮。
4. 运行测试。
在 Eclipse 的下方选择“JUnit”选项卡,然后点击“Run”按钮,运行测试。
测试完成后,可以在“JUnit”选项卡中查看测试结果。
5. 生成测试报告。
在 Eclipse 的上方选择“Window”选项卡,然后点击“Show View”按钮,选择“Other”。
在弹出的对话框中输入“Test Results”,然后点击“Go”按钮。
在“Test Results”视图中,可以看到所有的测试结果。
右键单击某个测试结果,选择“New” -> “Other”,在弹出的对话框中选择“General” -> “Report”。
在“Report”对话框中,输入报告名称和描述,选择需要包含的测试结果,然后点击“Finish”按钮。
6. 查看测试报告。
在 Eclipse 的下方选择“General”选项卡,然后点击“Open”按钮,打开生成的测试报告。
在测试报告中,可以看到每个测试方法的运行结果和覆盖率信息。
以上是在 Eclipse 中生成单元测试报告的步骤。
单元测试工具调研报告
![单元测试工具调研报告](https://img.taocdn.com/s3/m/480fdb10182e453610661ed9ad51f01dc281570b.png)
单元测试工具调研报告一、单元测试目的单元测试(unit testing),是在软件开发过程中要进行的最低级别的测试活动。
单元测试测试用于验证软件最小的可执行单元的正确性,即类或方法的正确性,其目的在于发现各模块内部可能存在的各种差错,验证代码是与设计相符合的,发现设计和需求中存在的错误,发现在编码过程中引入的错误。
主要是基于白盒测试。
二、单元测试的好处1、编写单元测试的时间节约了未来的修改、维护低质量代码的时间。
2、单元测试也是设计的一部分,会促使程序员以使用者的角度重新审视自己的代码,使写出的代码易于使用。
3、当程序被修改时,通过快速的单元测试能够找到修改后存在的漏洞。
三、如何进行单元测试1、写一点,测一点1.每写完一个程序单元就开始编写单元测试代码2.将程序划分为尽可能小的单元,这样更有利于单元测试的编写。
2、单元测试的内容1.通用的业务组件,或工具类2.内外部接口3.包含重要逻辑的Service4.程序员自己觉得没有把握的代码3、单元测试的策略5.尽早进行单元测试6.对于新增加的功能和修改的功能要进行完善单元测试7.对于新发现的bug,通常也应增加相应的单元测试四、常用单元测试工具1.Arquillian (开源Arquillian是JVM 一个高度创新性和可扩展的测试平台,支持Java开发人员轻松创建自动化集合的,功能性的和验收的测试。
Arquillian允许在运行时间执行测试。
Arquillian可以用来管理单个或多个容器的生命周期,捆扎测试用例,从属类和资源。
它还能够部署归档到容器中,在容器中执行测试、捕获结果,并创建报告。
Arquillian集成了常见的测试框架,如JUnit 4、TestNG 5,并允许使用现有的IDE发布测试,并且由于其模块化的设计使得能够运行Ant和Maven 测试插件。
2.JTest (商用JTest也被称为“Parasoft JTes建一款通过Parasoft制作的自动化的Java软件测试和静态分析软件。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在Eclipse中使用JUnit4进行单元测试首先新建一个项目叫JUnit_Test,我们编写一个Calculator类,这是一个能够简单实现加减乘除、平方、开方的计算器类,然后对这些功能进行单元测试。
这个类并不是很完美,我们故意保留了一些Bug用于演示,这些Bug在注释中都有说明。
该类代码如下:第二步,将JUnit4单元测试包引入这个项目:在该项目上点右键,点“属性”,如图:在弹出的属性窗口中,首先在左边选择“Java Build Path”,然后到右上选择“Libraries”标签,之后在最右边点击“Add Library…”按钮,如下图所示:然后在新弹出的对话框中选择JUnit4并点击确定,如上图所示,JUnit4软件包就被包含进我们这个项目了。
第三步,生成JUnit测试框架:在Eclipse的Package Explorer中用右键点击该类弹出菜单,选择“New à JUnit Test Case”。
如下图所示:在弹出的对话框中,进行相应的选择,如下图所示:点击“下一步”后,系统会自动列出你这个类中包含的方法,选择你要进行测试的方法。
此例中,我们仅对“加、减、乘、除”四个方法进行测试。
如下图所示:之后系统会自动生成一个新类CalculatorTest,里面包含一些空的测试用例。
你只需要将这些测试用例稍作修改即可使用。
完整的CalculatorTest代码如下:第四步,运行测试代码:按照上述代码修改完毕后,我们在CalculatorTest类上点右键,选择“Run As à JUnit Test”来运行我们的测试,如下图所示:运行结果如下:进度条是红颜色表示发现错误,具体的测试结果在进度条上面有表示“共进行了4个测试,其中1个测试被忽略,一个测试失败”至此,我们已经完整体验了在Eclipse中使用JUnit的方法。
在测试类中用到了JUnit4框架,自然要把相应地Package包含进来。
最主要地一个Package就是org.junit.*。
把它包含进来之后,绝大部分功能就有了。
还有一句话也非常地重要“import static org.junit.Assert.*;”,我们在测试的时候使用的一系列assertEquals方法就来自这个包。
大家注意一下,这是一个静态包含(static),是JDK5中新增添的一个功能。
也就是说,assertEquals 是Assert类中的一系列的静态方法,一般的使用方式是Assert. assertEquals(),但是使用了静态包含后,前面的类名就可以省略了,使用起来更加的方便。
二、测试类的声明大家注意到,我们的测试类是一个独立的类,没有任何父类。
测试类的名字也可以任意命名,没有任何局限性。
所以我们不能通过类的声明来判断它是不是一个测试类,它与普通类的区别在于它内部的方法的声明,我们接着会讲到。
三、创建一个待测试的对象。
你要测试哪个类,那么你首先就要创建一个该类的对象。
正如上一篇文章中的代码:private static Calculator calculator = new Calculator();为了测试Calculator类,我们必须创建一个calculator对象。
四、测试方法的声明在测试类中,并不是每一个方法都是用于测试的,你必须使用“标注”来明确表明哪些是测试方法。
“标注”也是JDK5的一个新特性,用在此处非常恰当。
我们可以看到,在某些方法的前有@Before、@Test、@Ignore等字样,这些就是标注,以一个“@”作为开头。
这些标注都是JUnit4自定义的,熟练掌握这些标注的含义非常重要。
五、编写一个简单的测试方法。
首先,你要在方法的前面使用@Test标注,以表明这是一个测试方法。
对于方法的声明也有如下要求:名字可以随便取,没有任何限制,但是返回值必须为void,而且不能有任何参数。
如果违反这些规定,会在运行时抛出一个异常。
至于方法内该写些什么,那就要看你需要测试些什么了。
比如:我们想测试一下“加法”功能时候正确,就在测试方法中调用几次add函数,初始值为0,先加2,再加3,我们期待的结果应该是5。
如果最终实际结果也是5,则说明add方法是正确的,反之说明它是错的。
assertEquals(5,calculator.getResult());就是来判断期待结果和实际结果是否相等,第一个参数填写期待结果,第二个参数填写实际结果,也就是通过计算得到的结果。
这样写好之后,JUnit会自动进行测试并把测试结果反馈给用户。
六、忽略测试某些尚未完成的方法。
如果你在写程序前做了很好的规划,那么哪些方法是什么功能都应该实现定下来。
因此,即使该方法尚未完成,他的具体功能也是确定的,这也就意味着你可以为他编写测试用例。
但是,如果你已经把该方法的测试用例写完,但该方法尚未完成,那么测试的时候一定是“失败”。
这种失败和真正的失败是有区别的,因此JUnit提供了一种方法来区别他们,那就是在这种测试函数的前面加上@Ignore标注,这个标注的含义就是“某些方法尚未完成,暂不参与此次测试”。
这样的话测试结果就会提示你有几个测试被忽略,而不是失败。
一旦你完成了相应函数,只需要把@Ignore标注删去,就可以进行正常的测试。
七、 Fixture(暂且翻译为“固定代码段”)Fixture的含义就是“在某些阶段必然被调用的代码”。
比如我们上面的测试,由于只声明了一个Calculator对象,他的初始值是0,但是测试完加法操作后,他的值就不是0了;接下来测试减法操作,就必然要考虑上次加法操作的结果。
这绝对是一个很糟糕的设计!我们非常希望每一个测试都是独立的,相互之间没有任何耦合度。
因此,我们就很有必要在执行每一个测试之前,对Calculator 对象进行一个“复原”操作,以消除其他测试造成的影响。
因此,“在任何一个测试执行之前必须执行的代码”就是一个Fixture,我们用@Before来标注它,如前面例子所示:这里不在需要@Test标注,因为这不是一个test,而是一个Fixture。
同理,如果“在任何测试执行之后需要进行的收尾工作”也是一个Fixture,使用@After 来标注。
由于本例比较简单,没有用到此功能。
上一篇文章中我们介绍了两个Fixture标注,分别是@Before和@After,我们来看看他们是否适合完成如下功能:有一个类是负责对大文件(超过500兆)进行读写,他的每一个方法都是对文件进行操作。
换句话说,在调用每一个方法之前,我们都要打开一个大文件并读入文件内容,这绝对是一个非常耗费时间的操作。
如果我们使用@Before和@After,那么每次测试都要读取一次文件,效率及其低下。
这里我们所希望的是在所有测试一开始读一次文件,所有测试结束之后释放文件,而不是每次测试都读文件。
JUnit的作者显然也考虑到了这个问题,它给出了@BeforeClass 和 @AfterClass两个Fixture来帮我们实现这个功能。
从名字上就可以看出,用这两个Fixture标注的函数,只在测试用例初始化时执行@BeforeClass方法,当所有测试执行完毕之后,执行@AfterClass进行收尾工作。
在这里要注意一下,每个测试类只能有一个方法被标注为@BeforeClass 或@AfterClass,并且该方法必须是Public和Static的。
二、限时测试。
还记得我在初级篇中给出的例子吗,那个求平方根的函数有Bug,是个死循环:如果测试的时候遇到死循环,你的脸上绝对不会露出笑容。
因此,对于那些逻辑很复杂,循环嵌套比较深的程序,很有可能出现死循环,因此一定要采取一些预防措施。
限时测试是一个很好的解决方案。
我们给这些测试函数设定一个执行时间,超过了这个时间,他们就会被系统强行终止,并且系统还会向你汇报该函数结束的原因是因为超时,这样你就可以发现这些Bug了。
要实现这一功能,只需要给@Test标注加一个参数即可,代码如下:Timeout参数表明了你要设定的时间,单位为毫秒,因此1000就代表1秒。
三、测试异常JAVA中的异常处理也是一个重点,因此你经常会编写一些需要抛出异常的函数。
那么,如果你觉得一个函数应该抛出异常,但是它没抛出,这算不算Bug 呢?这当然是Bug,并JUnit也考虑到了这一点,来帮助我们找到这种Bug。
例如,我们写的计算器类有除法功能,如果除数是一个0,那么必然要抛出“除0异常”。
因此,我们很有必要对这些进行测试。
代码如下:如上述代码所示,我们需要使用@Test标注的expected属性,将我们要检验的异常传递给他,这样JUnit 框架就能自动帮我们检测是否抛出了我们指定的异常。
四、 Runner (运行器)大家有没有想过这个问题,当你把测试代码提交给JUnit框架后,框架如何来运行你的代码呢?答案就是——Runner。
在JUnit中有很多个Runner,他们负责调用你的测试代码,每一个Runner都有各自的特殊功能,你要根据需要选择不同的Runner来运行你的测试代码。
可能你会觉得奇怪,前面我们写了那么多测试,并没有明确指定一个Runner啊?这是因为JUnit中有一个默认Runner,如果你没有指定,那么系统自动使用默认Runner来运行你的代码。
换句话说,下面两段代码含义是完全一样的:从上述例子可以看出,要想指定一个Runner,需要使用@RunWith标注,并且把你所指定的Runner作为参数传递给它。
另外一个要注意的是,@RunWith是用来修饰类的,而不是用来修饰函数的。
只要对一个类指定了Runner,那么这个类中的所有函数都被这个Runner来调用。
最后,不要忘了包含相应的Package 哦,上面的例子对这一点写的很清楚了。
接下来,我会向你们展示其他Runner 的特有功能。
五、参数化测试。
你可能遇到过这样的函数,它的参数有许多特殊值,或者说他的参数分为很多个区域。
比如,一个对考试分数进行评价的函数,返回值分别为“优秀,良好,一般,及格,不及格”,因此你在编写测试的时候,至少要写5个测试,把这5中情况都包含了,这确实是一件很麻烦的事情。
我们还使用我们先前的例子,测试一下“计算一个数的平方”这个函数,暂且分三类:正数、0、负数。
测试代码如下:为了简化类似的测试,JUnit4提出了“参数化测试”的概念,只写一个测试函数,把这若干种情况作为参数传递进去,一次性的完成测试。
代码如下:下面我们对上述代码进行分析。
首先,你要为这种测试专门生成一个新的类,而不能与其他测试共用同一个类,此例中我们定义了一个SquareTest类。
然后,你要为这个类指定一个Runner,而不能使用默认的Runner了,因为特殊的功能要用特殊的Runner嘛。