JUnit4使用入门指南
JUnit入门及应用
JUnit入门及应用1、相关概念?JUnit：是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。
它是用于单元测试框架体系xUnit的一个实例（用于java语言）。
主要用于白盒测试，回归测试。
?白盒测试：把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的。
?回归测试：软件或环境的修复或更正后的再测试，自动测试工具对这类测试尤其有用。
?单元测试：最小粒度的测试，以测试某个功能或代码块。
一般由程序员来做，因为它需要知道内部程序设计和编码的细节。
2、单元测试2.1、单元测试的好处?提高开发速度，测试是以自动化方式执行的，提升了测试代码的执行效率。
?提高软件代码质量，它使用小版本发布至集成，便于实现人员除错。
同时引入重构概念，让代码更干净和富有弹性。
?提升系统的可信赖度，它是回归测试的一种。
支持修复或更正后的“再测试”，可确保代码的正确性。
2.2、单元测试的针对对象?面向过程的软件开发针对过程。
?面向对象的软件开发针对对象。
?可以做类测试，功能测试，接口测试（最常用于测试类中的方法）。
2.3、单元测试工具和框架目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。
单元测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人）提供的开放源代码的JUnit。
3、Junit入门简介3.1、JUnit的好处和JUnit测试编写原则使用JUnit的好处：?可以使测试代码与产品代码分开。
?针对某一个类的测试代码通过较少的改动便可以应用于另一个类的测试。
?易于集成到测试人员的构建过程中，JUnit和Ant的结合可以实施增量开发。
java的单元测试JUnit4
java的单元测试JUnit4 java的单元测试1. 概念java单元测试是最⼩的功能单元测试代码, 单元测试就是针对单个java⽅法的测试java程序的最⼩功能单元是⽅法2. 单元测试的优点main⽅法进⾏测试的缺点:只能有⼀个main()⽅法, 不能把测试代码分离出来⽆法打印出测试结果和期望结果.例如: expected: 3628800, but actual: 123456单元测试的优点:确保单个⽅法正常运⾏如果修改了⽅法代码, 只需要保其对应的单元测试通过就可以了测试代码本省就可以作为⽰例代码可以⾃动化运⾏所有测试并获得报告3. Junit单元测试JUnit是⼀个开源的java语⾔的单元测试框架专门针对java语⾔设计, 使⽤最⼴泛, JUnit是标准的单元测试架构3.1 JUnit特点使⽤断⾔(Assertion)测试期望结果可以⽅便的组织和运⾏测试可以⽅便的查看测试结果常⽤的开发⼯具IDEA, Eclipse都集成了JUnit可以⽅便的继承到maven中3.2 maven依赖<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><!-- junit的版本有3.x, 4.x, 5.x 5.x还没有发布, 现在都⽤是4.x --></dependency>3.3 在IDE中使⽤快捷键进⾏单元测试测试类的使⽤⽬录必须是如下, 测试类规定标准是在test⽬录中进⾏测试localhost:javatest lingjing$ tree -d -L 3.├── src│├── main││└── java│└── test│└── javaIDE的快捷键是:ctrl+shift+t --> create new test然后选择对应的⽅法进⾏测试就好了3.4 断⾔3.4.1 断⾔的例⼦断⾔的使⽤, 必须先引⼊必须的包: IDE⾃动创建的会⾃动引⼊import static org.junit.Assert.*;例⼦: 在main包中的编写的⼀个正则表达式的类import java.util.Arrays;/*** @ClassName Calculator* @Description 在main中的主要类* @Author lingxiangxiang* @Date 10:07 AM* @Version 1.0**/public class Calculator {public int calculate(String expression) {String[] ss = expression.split("\\+");System.out.println(expression + " => " + Arrays.toString(ss));int sum = 0;for (String s: ss) {sum += Integer.parseInt(s.trim());}return sum;}}测试类:import org.junit.Test;import static org.junit.Assert.*;public class CalculatorTest {@Testpublic void calculate() {assertEquals(3, new Calculator().calculate("1 + 2"));assertEquals(3, new Calculator().calculate("1 + 2 + 3"));}}测试类执⾏结果如下:1 +2 => [1 , 2]1 +2 +3 => [1 , 2 , 3]ng.AssertionError:Expected :3Actual :6<Click to see difference>at javatest.CalculatorTest.calculate(CalculatorTest.java:12)第⼀个⽅法: 1 + 2 => [1 , 2], 最终的结果3是正确的, 所有没有任何报错, 正常显⽰第⼆个⽅法: 1 + 2 + 3 => [1 , 2 , 3], 最终报错, 并提⽰在代码的位置: CalculatorTest.java:12, 并且罗列出Expected和Actual的值, 清楚的显⽰了结果的对⽐情况, 和代码出现的位置3.4.2 断⾔的常⽤⽅法assertEquals(100, x): 断⾔相等assertArrayEquals({1, 2, 3}, x): 断⾔数组相等assertEquals(3.1416, x, 0.0001): 浮点数组断⾔相等assertNull(x): 断⾔为nullassertTrue(x > 0): 断⾔为trueassertFalse(x < 0): 断⾔为false;assertNotEquals: 断⾔不相等assertNotNull: 断⾔不为null3.5 使⽤@Before和@After在@Before⽅法中初始化测试资源在@After⽅法中释放测试资源@BeforeClass: 初始化⾮常耗时的资源, 例如创建数据库@AfterClass: 清理@BeforeClass创建的资源, 例如创建数据库3.5.1 对于每⼀个@Test⽅法的执⾏顺序注意:** 单个@Test⽅法执⾏前会创建新的XxxTest实例, 实例变量的状态不会传递给下⼀个@Test⽅法, 单个@Test⽅法执⾏前后会执⾏@Before和@After⽅法1. 执⾏类的构造函数2. 执⾏@Before⽅法3. 执⾏@Test⽅法4. 执⾏@After⽅法3.5.2 代码实例:写⼀个整体的测试类如下:package javatest;/*** @ClassName SequenceTest* @Description TODO* @Author lingxiangxiang* @Date 1:54 PM* @Version 1.0**/import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;public class SequenceTest {@BeforeClasspublic static void setUpBeforeClass() throws Exception {System.out.println("BeforeClass()");}@AfterClasspublic static void tearDownAfterClass() throws Exception {System.out.println("AfterClass()");}@Beforepublic void setUp() throws Exception {System.out.println(" Before()");}@Afterpublic void tearDown() throws Exception {System.out.println(" After()");}public SequenceTest() {System.out.println(" new SequenceTest()");}@Testpublic void testA() {System.out.println(" testA()");}@Testpublic void testB() {System.out.println(" testB()");}@Testpublic void testC() {System.out.println(" testC()");}}如果运⾏整个类, 运⾏结果如下:BeforeClass()new SequenceTest()Before()testA()After()new SequenceTest()Before()testB()After()new SequenceTest()Before()testC()After()AfterClass()如果运⾏单个@Test类BeforeClass()new SequenceTest()Before()testA()After()AfterClass()3.6 异常测试异常测试可以通过@Test(expected=Exception.class), 对可能发⽣的每种类型的异常进⾏测试如果抛出了指定类型的异常, 测试成功如果没有抛出指定类型的异常, 或者抛出的异常类型不对, 测试失败例⼦:运⾏如下代码: 正常通过// 运⾏如下代码, 正常运⾏, 确实发⽣了ArithmeticException异常, 代码通过@Test(expected = ArithmeticException.class)public void testException() {int i = 1 / 0;}运⾏如下代码: 有报错信息@Test(expected = ArithmeticException.class)public void testException() {int i = 1 / 1;}执⾏结果如下:ng.AssertionError: Expected exception: ng.ArithmeticException3.7 参数化测试@RunWith: 当类被@RunWith注释修饰, 或者类继承了⼀个被该注解类修饰的类, JUnit将会使⽤这个注解所指明的运⾏器(runner)来运⾏测试, ⽽不是JUni默认的运⾏器要进⾏参数化测试，需要在类上⾯指定如下的运⾏器： @RunWith (Parameterized.class)然后，在提供数据的⽅法上加上⼀个@Parameters注解，这个⽅法必须是静态static的，并且返回⼀个集合Collection。
Junit4之Assert静态方法介绍
Junit4之Assert静态⽅法介绍
Junit中的assert⽅法全部放在Assert类中，总结⼀下junit类中assert⽅法的分类。
1.assertTrue/False([String message,]boolean condition);
⽤来查看变量是是否为false或true，如果assertFalse()查看的变量的值是false则测试成功，如果是true则失败，assertTrue()与之相反；
2.fail([String message,]);
直接⽤来抛出错误。
3.assertEquals([String message,]Object expected,Object actual);
判断是否相等，可以指定输出错误信息。
第⼀个参数是期望值，第⼆个参数是实际的值。
这个⽅法对各个变量有多种实现
4.assertNotNull/Null([String message,]Object obj);
判读⼀个对象是否⾮空(⾮空)。
5.assertSame/NotSame([String message,]Object expected,Object actual);
判断两个对象是否指向同⼀个对象。
看内存地址。
7.failNotSame/failNotEquals(String message, Object expected, Object actual)
当不指向同⼀个内存地址或者不相等的时候，输出错误信息。
注意信息是必须的，⽽且这个输出是格式化过的。
junit4单元测试--web项目中模拟登录会话，做全流程测试
junit4单元测试--web项⽬中模拟登录会话，做全流程测试junit4相对于junit3，基于注解的⽅式写单元测试⽤例，使⽤过程中⽅便很多。
如下缩写均是代码⽚段，摘录其中关键部分，重要是理解其中知识点。
⼀、编写测试⽤例基类@RunWith(SpringJUnit4ClassRunner.class)@WebAppConfiguration@ContextConfiguration({"file:src/main/webapp/WEB-INF/applicationContext.xml", "file:src/main/webapp/WEB-INF/spring-servlet.xml","file:src/main/webapp/WEB-INF/conf/spring-redis.xml", "file:src/main/webapp/WEB-INF/conf/spring-resttemplate.xml"})public abstract class BaseJunit{/*** wac*/@Autowiredprivate WebApplicationContext wac;/*** MockMvc*/private MockMvc mockMvc;protected WebApplicationContext getWac(){return this.wac;}protected MockMvc getMockMvc(){return this.mockMvc;}/*** 初始化mocMvc** @see*/@Beforepublic void setUp(){this.mockMvc = webAppContextSetup(this.wac).build();}......}@RunWith(SpringJUnit4ClassRunner.class) 指定采⽤Spring的运⾏环境@WebAppConfiguration ⽤来声明这是⼀个web测试环境@ContextConfiguration ⽤来指定加载项⽬的配置⽂件⼆、抽出web系统登录⽅法public abstract class BaseLoginJunit extends BaseJunit{/*** MockMvc*/private MockHttpSession session;protected MockHttpSession getSession(){return session;}/*** 测试前，初始化系统登录** @see*/@Beforepublic void setUp(){super.setUp();this.session = (MockHttpSession)getLoginSession();}/*** 完成登录功能，返回当前登录会话** @return HttpSession* @see*/private HttpSession getLoginSession(){String url = "/xxx/login";String params = "{\"userName\":\"xxx\",\"password\":\"xxx\",\"verifyCode\":\"xxx\"}";MvcResult result = null;try{result = getMockMvc().perform(MockMvcRequestBuilders.post(url).accept(MediaType.APPLICATION_JSON).contentType(MediaType.APPLICATION_JSON_UTF8_VALUE).content( params)).andExpect(MockMvcResultMatchers.status().isOk()).andDo(MockMvcResultHandlers.print()).andReturn();}catch (Exception e){e.printStackTrace();}return result.getRequest().getSession();}......}三、编写spring控制器测试⽅法@FixMethodOrder(_ASCENDING) // 指定按字母顺序执⾏测试⽤例public class ResourceControllerTest extends BaseLoginJunit{/*** res id list*/private static List<String> RES_LIST = new ArrayList<>();/*** 测试 getResource** @see*/@Testpublic void testGetResource(){String url = "/xxx/get";MultiValueMap<String, String> map = new LinkedMultiValueMap<>();this.setPage(map);get(url, map);}/*** 测试 add** @see*/@Testpublic void testAddResource(){String url = "/xxx/add";ResourceBean bean = new ResourceBean();ResourceBean anotherBean = new ResourceBean();bean.setResName("test res1");anotherBean.setResName("test res2");MvcResult result = post(url, JSONObject.toJSONString(bean));ReturnVal returnVal = this.getReturnVal(result);RES_LIST.add(returnVal.getData().getId());MvcResult anotherResult = post(url, JSONObject.toJSONString(childBean));ReturnVal anotherReturnVal = this.getReturnVal(anotherResult);RES_LIST.add(anotherReturnVal.getData().getId());}/*** 测试updateResource** @see*/@Testpublic void testBupdateResource(){String url = "/xxx/update";ResourceBean bean = new ResourceBean();bean.setId(RES_LIST.get(0));bean.setResName("test res1");MvcResult result = post(url, JSONObject.toJSONString(bean));assertEquals(AbstractController.STATUS_SUCCESS, getReturnVal(result).getStatus());}/*** 测试delResource** @see*/@Testpublic void testCdelResource(){String url = "/xxx/delete";MultiValueMap<String, String> map = new LinkedMultiValueMap<>();map.add("id", RES_LIST.remove(0));MvcResult result = get(url, map);assertEquals(AbstractController.STATUS_SUCCESS, getReturnVal(result).getStatus());}/*** 测试batchDelResource** @see*/@Testpublic void testDbatchDelResource(){String url = "/xxx/batchDel";MultiValueMap<String, String> map = new LinkedMultiValueMap<>();StringBuilder params = new StringBuilder();for (int i = 0; i < RES_LIST.size(); i++ ){if (i == RES_LIST.size() - 1){params.append(RES_LIST.get(i));}else{params.append(RES_LIST.get(i)).append(",");}}map.add("id", params.toString());MvcResult result = get(url, map);assertEquals(AbstractController.STATUS_SUCCESS, getReturnVal(result).getStatus());}}以上测试⽤例中，@FixMethodOrder很关键，因为增、删、改、查需要指定测试的顺序。
junit4初探1.0
初探 Junit4版本1.0作者:Alifel目录：一、junit4入门实例 (3)1、实例环境 (3)2、实例 (3)A、创建web service Project：项目名称为“Junit4” (3)B、添加Junit4 libraires (3)C、按一下目录结构创建目录（如图四） (4)D、在com.alifel.teach.junit4.demo1.service package下创建service：NameFormat.4E、在com.alifel.teach.junit4.demo1.test Package下创建Junit4 测试类TestNameFormat (5)F、JUnit4测试 (7)G、测试分析 (7)H、BUG修正后，二次测试 (9)二、junit4介绍 (10)1、annotation介绍 (10)A、@Test(timeout,expected) (10)B、@After (11)C、@Before (12)D、@AfterClass (13)E、@BeforeClass (14)2、常用断言介绍 (15)A、assertEquals([String message],Object target,Object result) (15)B、assertTrue/False([String message],Boolean result) (15)C、assertNotNull/Null（[String message],Obejct result (15)D、assertSame/NotSame（Object target,Object result） (15)F、fail([String message]) (16)一、 junit4入门实例1、实例环境环境：MyEclipse6.52、实例A、创建web service Project：项目名称为“Junit4”B、添加Junit4 libraires选择项目Junit4(在Package Explorer中) -> 右击鼠标 -> 选择properties -> 选择Java Build Path (在左边的菜单中) -> 在右边选择标签 Libraries (如图1) -> 单击按钮“Add Library” (如图二) -> 选择JUnit , 单击按钮 “Next>” (如图三) -> 选择JUnit library version 为： JUnit4 -> 单击按钮“Finish” –> 单击按钮 “OK”（图一）(图二)（图三）C、按一下目录结构创建目录（如图四）（图四）D、在com.alifel.teach.junit4.demo1.service package下创建service：NameFormat 源码：E、在com.alifel.teach.junit4.demo1.test Package下创建Junit4 测试类TestNameFormat 源码：注：important A 由于没有像Junit3一样继承TestCase,所以必须导入所有静态断言Important B 被annotation”@BeforeClass”修饰的方法，在测试的最开始被执行一次（从图十的控制台测试信息中可以看出），一般用来初始化整个测试需要的公共资源（比如数据库连接等），与之对应的annotation有“@AfterClass”,详细介绍请参阅第二章Important C annotation”@BeforeClass”只能修饰public static void方法Important D 被annotation”@Test”修饰的方法，JUnit4测试框架会自动运行Important E assertEquals()方法为junit的断言，该方法判断2个参数是否相等，如果不相等，则出发断言F、JUnit4测试选择类TestNameFormat.java(在Package Explorer中) -> 右击选择run as -> 选择JUnit testG、测试分析运行后，打开MyEclipse6.5 JUnit窗体(如图六)分析测试结果：双击JUnit标签即可(图五所示位置)（图五）（图六）（图七）注：：代表抛出异常的方法：代表测试通过的方法：代表测试失败的方法如图七所示，该区域罗列出了TestNameFormat 的所有测试方法，分析发现: nameFormatOneNull()方法在测试过程中抛出异常；nameFormatOneEmpty()方法测试通过；nameFormatOneLowercase()方法测试通过；nameFormatOneMajuscule()方法测试失败。
Junit学习笔记
JUnit4学习笔记（一）笔者使用的是junit4.9b3和hamcrest1.3.0RC2JUnit4使用Java5注解(annotation):@Before：在每一个测试方法执行前执行的方法，用于初始化方法@After：在第一个测试方法执行后执行的方法，用于释放资源@Test：标志该方法为测试方法，在此可以测试期望异常和超时时间@Ignore：标志该方法为忽略的测试方法，当一个测试方法还没有具备测试条件时可以先标志为忽略的测试方法@BeforeClass：在所有测试方法执行前执行，只执行一次，且必须为static void，一般用于初始化一些共享的实例或加载共享的资源@AfterClass：在所有测试方法执行后执行，只执行一次，且必须为static void，一般用于测试的善后工作@Test属性:expected：测试方法是否抛出异常，如果方法抛出异常则测试通过，否则不通过。
timeout：测试方法超时时间，单位毫秒(ms)，如果方法（被测方法）在指定时间内完成的话则测试通过，否则不通过。
例:@Test(expected=ng.ArithmeticException.class, timeout=100)一个JUnit 4 的单元测试用例执行顺序为：@BeforeClass –> @Before –> @Test –> @After –> @AfterClass每一个测试方法的调用顺序为：@Before –> @Test –> @AfterJUnit主要有以下断言：assertEquals（期望值，实际值），检查两个值是否相等。
assertEquals（期望对象，实际对象），检查两个对象是否相等，利用对象的equals()方法进行判断。
assertSame（期望对象，实际对象），检查具有相同内存地址的两个对象是否相等，利用内存地址进行判断，注意和上面assertEquals方法的区别。
浅谈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中⽤例执⾏顺序
@BeforeClass：针对所有测试，只执⾏⼀次，且必须为static void
@Before：初始化⽅法
@Test：测试⽅法，在这⾥可以测试期望异常和超时时间
@After：释放资源
@AfterClass：针对所有测试，只执⾏⼀次，且必须为static void
junit4.x版本我们常⽤的注解：
A、@Before 注解：与junit3.x中的setUp()⽅法功能⼀样，在每个测试⽅法之前执⾏；
B、@After 注解：与junit3.x中的tearDown()⽅法功能⼀样，在每个测试⽅法之后执⾏；
C、@BeforeClass 注解：在所有⽅法执⾏之前执⾏；
D、@AfterClass 注解：在所有⽅法执⾏之后执⾏；
E、@Test(timeout = xxx) 注解：设置当前测试⽅法在⼀定时间内运⾏完，否则返回错误；
F、@Test(expected = Exception.class) 注解：设置被测试的⽅法是否有异常抛出。
抛出异常类型为：Exception.class；
G、@Ignore 注解：注释掉⼀个测试⽅法或⼀个类，被注释的⽅法或类，不会被执⾏。
Junit学习笔记
JUnit4学习笔记（一）笔者使用的是junit4.9b3和hamcrest1.3.0RC2JUnit4使用Java5注解(annotation):@Before：在每一个测试方法执行前执行的方法，用于初始化方法@After：在第一个测试方法执行后执行的方法，用于释放资源@Test：标志该方法为测试方法，在此可以测试期望异常和超时时间@Ignore：标志该方法为忽略的测试方法，当一个测试方法还没有具备测试条件时可以先标志为忽略的测试方法@BeforeClass：在所有测试方法执行前执行，只执行一次，且必须为static void，一般用于初始化一些共享的实例或加载共享的资源@AfterClass：在所有测试方法执行后执行，只执行一次，且必须为static void，一般用于测试的善后工作@Test属性:expected：测试方法是否抛出异常，如果方法抛出异常则测试通过，否则不通过。
timeout：测试方法超时时间，单位毫秒(ms)，如果方法（被测方法）在指定时间内完成的话则测试通过，否则不通过。
例:@Test(expected=ng.ArithmeticException.class, timeout=100)一个JUnit 4 的单元测试用例执行顺序为：@BeforeClass –> @Before –> @Test –> @After –> @AfterClass每一个测试方法的调用顺序为：@Before –> @Test –> @AfterJUnit主要有以下断言：assertEquals（期望值，实际值），检查两个值是否相等。
assertEquals（期望对象，实际对象），检查两个对象是否相等，利用对象的equals()方法进行判断。
assertSame（期望对象，实际对象），检查具有相同内存地址的两个对象是否相等，利用内存地址进行判断，注意和上面assertEquals方法的区别。
Java单元测试：JUnit和Mockito的使用指南
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还提供了一些高级特性，如参数化测试、测试套件和测试运行器等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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：测试方法，表明这是一个测试方法。
对于方法的声明也有如下要求：名字可以随便取，没有任何限制，但是返回值必须为void，而且不能有任何参数。
如果违反这些规定，会在运行时抛出一个异常。
至于方法内该写些什么，那就要看你需要测试些什么了;在这里可以测试期望异常和超时时间，如@Test(timeout=100)，我们给测试函数设定一个执行时间，超过了这个时间(100毫秒)，它们就会被系统强行终止，并且系统还会向你汇报该函数结束的原因是因为超时，这样你就可以发现这些Bug了。
d). @Ignore：忽略的测试方法，标注的含义就是“某些方法尚未完成，暂不参与此次测试”;这样的话测试结果就会提示你有几个测试被忽略，而不是失败。
一旦你完成了相应函数，只需要把@Ignore标注删去，就可以进行正常的测试。
e). @BeforeClass：针对所有测试，只执行一次，且必须为static void;f). @AfterClass：针对所有测试，只执行一次，且必须为static void;g). @RunWith@Suite.SuiteClasses这两个注解一般合在一起用，作为TestSuite类的注解，例如：@RunWith(Suite.class)@Suite.SuiteClasses({MyTestCase.class,MyTestCase2.class})public class MyTestsSuite {}创建一个空类作为测试套件的入口。
使用注解org.junit.runner.RunWith 和org.junit.runners.Suite.SuiteClasses 修饰这个空类。
将org.junit.runners.Suite 作为参数传入注解RunWith，以提示JUnit 为此类使用套件运行器执行。
将需要放入此测试套件的测试类组成数组作为注解SuiteClasses 的参数，保证这个空类使用public 修饰，而且存在公开的不带有任何参数的构造函数。
一个Junit 4 的单元测试用例执行顺序为：@BeforeClass –> @Before –>@Test–> @After –> @AfterClass;每一个测试方法的调用顺序为：@Before –>@Test–> @After。
下面我们简单创建一个基于Eclipse的JUnit4的测试用例，不用紧张，很简单的，比自己写public static void main(String[] args)还要轻松。
1. 创建一个JavaProject工程，你自己写了一个计算类，计算类的内容如下：1.package com.horse;2.3.import com.horse.exp.CalculatorException;4.5.public class MyCalculator {6.7./**8. * 两个整数相加，如果相加的值超过了整型的范围，抛出自定义的CalculatorException9. * @param x 加数110. * @param y 加数211. * @return 相加结果12. */13.public static int add(int x,int y){14.if(x+y != (long)x + (long)y){15.throw new CalculatorException("计算结果超出Int值的范围");16. }17.return x+y;18. }19.20./**21. * 两个整数相减，如果相减的值超过了整型的范围，抛出自定义的CalculatorException22. * @param x 被减数23. * @param y 减数24. * @return 相减结果25. */26.public static int subtract(int x,int y){27.return x-y;28. }29.30./**31. * 两个整数相乘，如果相乘的值超过了整型的范围，抛出自定义的CalculatorException32. * @param x 被乘数33. * @param y 乘数34. * @return 相乘结果35. */36.public static int multiply(int x,int y){37.return x*y;38. }39.40./**41. * 两个整数相除，如果除数等于0，抛出自定义的CalculatorException42. * @param x 被除数43. * @param y 除数44. * @return 相除结果45. */46.public static int divide(int x,int y){47.return x/y;48. }49.50./**51. * 两个整数相除取模，如果除数等于0，抛出自定义的CalculatorException52. * @param x 被除数53. * @param y 除数54. * @return 相除取模结果55. */56.public static int mode(int x,int y){57.return x%y;58. }59.60./**61. * 计算表达式。
<b>*未实现</b>62. * @param String expression 数学公式表达式，例如：3*{40/[50-5*(9-1)+10]+4}-263. * @return int 结果64. */65.public static int calcExpression(String expression){66.return0;67. }68.69./**70. * 计算阶乘。
<i>故意写错代码，写成了死循环</i>71. * @param num 正整数72. * @return 阶乘结果73. */74.public static int factorial(int num){75.for(int i=0;i<num;){76.77. }78.return0;79. }80.}2. 这时我们需要写一些测试方法来验证计算方法是否设计正确，然后在Java Build Path中把JUnit4添加到Libraries，如图3. 新建一个测试类：MyTestCase，这只是一个普通的类，不需要继承任何类，也不需要写main方法，例如：1.package com.horse;2.3.import org.junit.*;4.5.import com.horse.exp.CalculatorException;6.7.import junit.framework.Assert;8.9./**10. * 定义一个JUnit4的测试用例，初步了解JUnit4的使用特性。
11. * <p>下面的例子中全部使用了注解的方式，具体每个注解的含义和使用方式请见下面的用例</p>12. * @author 马涛 2011-6-1313. */14.public class MyTestCase{15.private static int i = 1;16.static{17. System.out.println("MyTestCase被载入内存");18. }19.20.public MyTestCase(){21. System.out.println("MyTestCase实例化," + this.hashCode());22. }23.24./**25. * @BeforeClass的意思是该被注解的方法将在类被系统载入的时候执行，先于测试用例类构造方法和@Before方法。
<br/>26. * 仅被执行一次，方法名不做限制。
该注解在一个类中只可以出现一次，必须声明为public static27. *28. */29.@BeforeClass30.public static void setUpBeforeClass(){31. System.out.println("初始化测试类");32. }33.34.35./**36. * @AfterClass的意思是所有的测试方法被执行之后再执行，后于@After方法执行。
<br/>37. * 仅被执行一次，方法名不做限制。