An example of 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,这个请随意。

java的单元测试JUnit4

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。

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中的参数化测试文章分类: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单元测试案例

junit4单元测试案例
Junit4是Java编程语言中用于编写单元测试的一个重要框架。

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

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

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

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

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

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

总的来说,编写Junit4单元测试案例需要您导入Junit4库、编写测试类和测试方法、准备测试数据、使用断言验证测试结果,并最后运行测试以检查代码的正确性。

希望这些信息能够帮助您更好地理解Junit4单元测试案例的编写过程。

JUnit4测试报告

JUnit4测试报告

JIANGSU UNIVERSITY OF TECHNOLOGY 软件测试用例设计基于JUint4的单元测试用例设计与实现学院名称:计算机工程学院专业:软件工程班级:12软件1学号:12144133姓名:王慧二〇一五年五月目录基于JUint4的单元测试用例设计与实现 1一、需求分析 1二、测试工具介绍 2三、软件测试实现 3 附录1:相关代码9基于JUint4的单元测试用例设计与实现一、需求分析(一)软件测试软件测试(Software Testing),描述一种用来促进鉴定软件的正确性、完整性、安全性和质量的过程。

换句话说,软件测试是一种实际输出与预期输出间的审核或者比较过程。

软件测试的经典定义是:在规定的条件下对程序进行操作,以发现程序错误,衡量软件质量,并对其是否能满足设计要求进行评估的过程。

软件测试模型有V、W、H、X等模型,其中V模型测试过程按4个步骤进行,即单元测试、集成测试、确认测试和系统测试及发布测试。

这其中单元测试与其他测试不同,单元测试可看作是编码工作的一部分,应该由程序员完成,也就是说,经过了单元测试的代码才是已完成的代码,提交产品代码时也要同时提交测试代码。

软件测试的测试目标是:1.发现一些可以通过测试避免的开发风险;2.实施测试来降低所发现的风险;3.确定测试何时可以结束;4.在开发项目的过程中将测试看作是一个标准项目。

(二)单元测试单元测试(模块测试)是开发者编写的一小段代码,用于检验被测代码的一个很小的、很明确的功能是否正确。

通常而言,一个单元测试是用于判断某个特定条件(或者场景)下某个特定函数的行为。

经验表明一个尽责的单元测试方法将会在软件开发的某个阶段发现很多的Bug,并且修改它们的成本也很低。

它的优点如下:1.它是一种验证行为编写单元测试就是用来验证代码的行为是否与我们期望的一致。

有了单元测试,我们可以自信的交付自己的代码,而没有任何的后顾之忧。

2.它是一种设计行为编写单元测试将使我们从调用者观察、思考。

在Eclipse中使用JUnit4进行单元测试

在Eclipse中使用JUnit4进行单元测试

在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包含进来。

junit4单元测试--web项目中模拟登录会话,做全流程测试

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功能介绍

JUnit4功能介绍

近期写单元测试计划,公司准备把junit3.8升级到junit4以上的版本,所以研究了一下,写下学习过程和心得体会,为了巩固学习成果,所以把学习心得写下来加深印象,也供需要的朋友查阅,少走弯路。

好了,废话不多说,直接开始:假设我们要写一个整数除法和乘法的类,并且给他写测试用例:1) 建立Math类工具是eclipse3.3Java代码/*** @author bulargy.j.bai* @创建时间:Mar 10, 2008* @描述:一个整数除法和乘法的工具类*/public class Math {public static int divide(intx,int y) {return x/y;}public static int multiple(intx,int y) {return x*y;}}2) 建立测试用例选中需要建立测试用例的包,选择new->other->JUnit Test Case。

有5个方法可以选择:setUp()方法在测试方法前调用,一般用来做测试准备工作。

tearDown()方法在测试方法后调用,一般作测试的清理工作。

setUpBeforeClass()方法在整个类初始化之后调用,一般用来做测试准备工作。

tearDownAfterClass()方法在整个类结束之前调用,一般作测试的清理工作。

constructor()为是否包含构造方法。

自动生成的代码如下:Java代码/*** @author bulargy.j.bai* @创建时间:Mar 11, 2008* @描述:*/public class MathTest {@BeforeClasspublic static void setUpBeforeClass() throws Exception {}@AfterClasspublic static void tearDownAfterClass() throws Exception {}@Testpublic void testDivide() {fail("Not yet implemented");}@Testpublic void testMultiple() {fail("Not yet implemented");}}说明:@BeforeClass标签注释的方法用于在整个类测试过程的初始化后调用一次,@AfterClass标签注释的方法则是整个测试类结束之前调用一次。

浅谈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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。

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:测试方法,表明这是一个测试方法。

采用JUnit4进行单元测试

采用JUnit4进行单元测试

采用JUnit4进行单元测试1、再产生一个测试项目 JUnit4TestProject2、在本测试项目中引用应用项目3、在测试项目中添加JUnit4的系统包文件4、对Calculator类添加对应的测试用例类 TestCalculatorJUnit4将产生出下面的模板程序package com.px1987.junit4;import static org.junit.Assert.*;import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;public class TestCalculatorJUnit4 {@BeforeClasspublic static void setUpBeforeClass() throws Exception {}@AfterClasspublic static void tearDownAfterClass() throws Exception {}@Beforepublic void setUp() throws Exception {}@Afterpublic void tearDown() throws Exception {}@Testpublic void testAdd() {fail("Not yet implemented");}}5、对上面的代码进行说明(1)与JUnit4框架有关的系统包注意在测试类中所用到的与JUnit4框架有关的系统包,最主要的是是org.junit.*。

把它包含进来之后,绝大部分功能就有了。

还有一句话也非常地重要“import static org.junit.Assert.*;”,我们在测试的时候所使用的一系列assertEquals方法就来自这个包。

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单元测试

1.单元测试规范单元测试使用Junit4进行测试,Eclipse内置了Junit4的支持。

1)测试类命名在项目的DAO与service层的实现类都必须编写测试用例,action由于struts2.0支持测试,所以也应该测试:1.测试用例命名规则为:类名+ Test。

(junit4支持非这样的命名方式,但是为了统一管理,还是采用这样的方式命名)2.建立一个和src平行的test包,所有测试用例都放在相应的包内,便于统一管理,合成测试套件。

3.同一个包的测试用例,合成一个测试套件。

4.整个工程的测试套件,合成一个统一的测试套件。

2)测试用例的编写1.测试方式都是test开头的方法(testXXXX),JUnit按照在测试用例中的顺序执行。

测试方法可以和被测试的方法一一对应,测试方法也可以包含多个被测试的方法。

2.测试方法中,使用断言(assertXXX和fail,详细资料请查阅JUnit文档)来进行测试结果判断,也可以辅以文字打印说明,如果测试程序抛出异常,则显示为错误,如果断言失败,则显示故障。

3.测试用例必须覆盖被测试类、方法的所有功能,包括正常情况、异常情况和发生错误的情况都必须覆盖,才能保证测试的完整性。

3)测试数据的准备为了防止数据库的更改对测试结果的影响,测试数据由统一的sql脚本来创建,测试前执行一下脚本创建数据。

也可以使用数据回滚的方式进行与数据相关的测试。

4)实体层的测试由于本次项目的Entity model由之前的贫血模型改为到充血模型,所以对于Entity 的测试不能够再忽略,对于Entity自身的除set/get以为的方法都应该进行单元测试。

5)DAO层的测试每一个DAO类都必须编写测试用例,对DAO的每一个公开方法进行测试,测试用例必须使用有代表性的测试代码,覆盖的所有可能的输入和输出情况,包括创建,更改,删除对象以及输入错误数据等测试。

6)Service层的测试Service层的测试必须测试Service对象是否满足功能要求,事务完整性等功能。

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 仅会在测试类中所有测试方法执行之前执行初始化,并在全部测试方法测试完毕之后执行注销方法。

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的变量和方法导入到这个类中,调用的时候和调用自己的方法没有任何区别。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Junit4实例图解
1.软件环境
Eclipse
JUnit4
2.为项目添加JUnit4库
A.添加Eclipse自带的Junit4
打开项目属性页->选择Java Build Path->点击Add Library->在弹出的对话框中选择JUnit->选择JUnit版本后点击Finish.(图2.1)
图2.1
B添加Junit其他方法
打开项目属性页->选择Java Build Path->点击Add External JARS->选择JUnit地址后点击确定.(图2.2)
图2.2
3. 修改代码目录
分别为单元测试代码与被测试代码创建单独的目录,单元测试代码和被测试代码使用一样的包,不同的目录。

选择项目属性->选择Java Build Path->在根目录下添加一个新目录,并把它加入到项目源代
码目录中.(图3.1)
图3.1
4.JUnit元数据
@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(“该方法还没有实现”),在执行的时候,仅会报告该方法没有实现,而不会运行测试方法。

6.运行Junit
测试方法必须使用注解org.junit.Test 修饰。

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

在测试类上点击右键,在弹出菜单中选择Run As JUnit Test。

运行结果如下图所示:
运行界面提示我们有两个测试情况未通过测试
——当首字母大写时得到的处理结果与预期的有偏差,造成测试失败(failure);——而当测试对null 的处理结果时,则直接抛出了异常测试错误(error)JUnit 将测试失败的情况分为两种:failure 和error。

Failure 一般由单元测试使
用的断言方法判断失败引起,它表示在测试点发现了问题;而error 则是由代码异常引起,这是测试目的之外的发现,它可能产生于测试代码本身的错误(测试代码也是代码,同样无法保证完全没有缺陷),也可能是被测试代码中的一个隐藏的bug。

7. 测试套件
创建一个空类作为测试套件的入口。

使用注解org.junit.runner.RunWith 和org.junit.runners.Suite.SuiteClasses 修饰这个空类。

将org.junit.runners.Suite 作为参数传入注解RunWith,以提示JUnit 为此类使用套件运行器执行。

将需要放入此测试套件的测试类组成数组作为注解SuiteClasses 的参数。

保证这个空类使用public 修饰,而且存在公开的不带有任何参数的构造函数。

package com.ai92.cooljunit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
……
/**
* 批量测试工具包中测试类
* @author Ai92
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({xx1.class, xx2.class})
public class RunAllUtilTestsSuite {
}。

相关文档
最新文档