JUnit4使用入门指南.docx
- 文档编号:8873018
- 上传时间:2023-02-02
- 格式:DOCX
- 页数:15
- 大小:170.23KB
JUnit4使用入门指南.docx
《JUnit4使用入门指南.docx》由会员分享,可在线阅读,更多相关《JUnit4使用入门指南.docx(15页珍藏版)》请在冰豆网上搜索。
JUnit4使用入门指南
JUnit4使用入门指南
*以下的内容以Eclipse上的JUnit为准
现在的Eclipse中一般都自带了JUnit组件,包含两个版本:
JUnit3和JUnit4,由于Junit4引入了java5.0的注释技术,所以写起测试用例更方便,有些注解方法非常人性化。
简单介绍一下JUnit4的特性:
1. JUnit4引入了类范围的setUp()和tearDown()方法。
任何用@BeforeClass注释的方法都将在该类中的测试方法运行之前刚好运行一次,而任何用@AfterClass注释的方法都将在该类中的所有测试都运行之后刚好运行一次。
2. 异常测试:
异常测试是Junit4中的最大改进。
Junit3的异常测试是在抛出异常的代码中放入try块,然后在try块的末尾加入一个fail()语句。
例如除法方法测试一个被零除抛出一个ArithmeticException:
该方法不仅难看,而且试图挑战代码覆盖工具,因为不管测试是否通过还是失败,总有一些代码不被执行。
在JUni4中,可以编写抛出异常的代码,并使用注释来声明该异常是预期的:
如果没有异常抛出或者抛出一个不同的异常,那么测试就将失败。
3. JUnit4添加了两个比较数组的assert()方法:
publicstaticvoidassertEquals(Object[]expected,Object[]actual)
publicstaticvoidassertEquals(Stringmessage,Object[]expected,Object[]actual)
这两个方法以最直接的方式比较数组:
如果数组长度相同,且每个对应的元素相同,则两个数组相等,否则不相等。
数组为空的情况也作了考虑。
4. JUnit4引入了注解技术,下面列出常用的几个annotation介绍
a). @Before:
初始化方法,在任何一个测试执行之前必须执行的代码;
b). @After:
释放资源,在任何测试执行之后需要进行的收尾工作;
c). @Test:
测试方法,表明这是一个测试方法。
对于方法的声明也有如下要求:
名字可以随便取,没有任何限制,但是返回值必须为void,而且不能有任何参数。
如果违反这些规定,会在运行时抛出一个异常。
至于方法内该写些什么,那就要看你需要测试些什么了;在这里可以测试期望异常和超时时间,如@Test(timeout=100),我们给测试函数设定一个执行时间,超过了这个时间(100毫秒),它们就会被系统强行终止,并且系统还会向你汇报该函数结束的原因是因为超时,这样你就可以发现这些Bug了。
d). @Ignore:
忽略的测试方法,标注的含义就是“某些方法尚未完成,暂不参与此次测试”;这样的话测试结果就会提示你有几个测试被忽略,而不是失败。
一旦你完成了相应函数,只需要把@Ignore标注删去,就可以进行正常的测试。
e). @BeforeClass:
针对所有测试,只执行一次,且必须为staticvoid;
f). @AfterClass:
针对所有测试,只执行一次,且必须为staticvoid;
g). @RunWith
@Suite.SuiteClasses
这两个注解一般合在一起用,作为TestSuite类的注解,例如:
@RunWith(Suite.class)
@Suite.SuiteClasses({MyTestCase.class,MyTestCase2.class})
publicclassMyTestsSuite{}
创建一个空类作为测试套件的入口。
使用注解org.junit.runner.RunWith和org.junit.runners.Suite.SuiteClasses修饰这个空类。
将org.junit.runners.Suite作为参数传入注解RunWith,以提示JUnit为此类使用套件运行器执行。
将需要放入此测试套件的测试类组成数组作为注解SuiteClasses的参数,保证这个空类使用public修饰,而且存在公开的不带有任何参数的构造函数。
一个Junit4的单元测试用例执行顺序为:
@BeforeClass–>@Before–>@Test–>@After–>@AfterClass;每一个测试方法的调用顺序为:
@Before–>@Test–>@After。
下面我们简单创建一个基于Eclipse的JUnit4的测试用例,不用紧张,很简单的,比自己写publicstaticvoidmain(String[]args)还要轻松。
1. 创建一个JavaProject工程,你自己写了一个计算类,计算类的内容如下:
1.package com.horse;
2.
3.import com.horse.exp.CalculatorException;
4.
5.public class MyCalculator {
6.
7. /**
8. * 两个整数相加,如果相加的值超过了整型的范围,抛出自定义的CalculatorException
9. * @param x 加数1
10. * @param y 加数2
11. * @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. * 两个整数相减,如果相减的值超过了整型的范围,抛出自定义的CalculatorException
22. * @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. * 两个整数相乘,如果相乘的值超过了整型的范围,抛出自定义的CalculatorException
32. * @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,抛出自定义的CalculatorException
42. * @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,抛出自定义的CalculatorException
52. * @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. * 计算表达式。
*未实现
62. * @param String expression 数学公式表达式,例如:
3*{40/[50-5*(9-1)+10]+4}-2
63. * @return int 结果
64. */
65. public static int calcExpression(String expression){
66. return 0;
67. }
68.
69. /**
70. * 计算阶乘。
故意写错代码,写成了死循环
71. * @param num 正整数
72. * @return 阶乘结果
73. */
74. public static int factorial(int num){
75. for(int i=0;i 76. 77. } 78. return 0; 79. } 80.} 2. 这时我们需要写一些测试方法来验证计算方法是否设计正确,然后在JavaBuildPath中把JUnit4添加到Libraries,如图 3. 新建一个测试类: MyTestCase,这只是一个普通的类,不需要继承任何类,也不需要写main方法,例如: viewplain 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. * 下面的例子中全部使用了注解的方式,具体每个注解的含义和使用方式请见下面的用例
12. * @author 马涛 2011-6-13
13. */
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方法。
26. * 仅被执行一次,方法名不做限制。
该注解在一个类中只可以出现一次,必须声明为public static
27. *
28. */
29. @BeforeClass
30. public static void setUpBeforeClass(){
31. System.out.println("初始化测试类");
32. }
33.
34.
35. /**
36. * @AfterClass的意思是所有的测试方法被执行之后再执行,后于@After方法执行。
37. * 仅被执行一次,方法名不做限制。
该注解在一个类中只可以出现一次,必须声明为public static
38. *
39. */
40. @AfterClass
41. public static void setUpAfterClass(){
42. System.out.println("销毁测试类");
43. }
44.
45. /**
46. * @Before的意思是测试用例类构造方法之后执行,在每个测试方法之前执行
47. * 方法名不做限制,在一个类中可以出现多次,执行顺序不确定,必须声明为public 并且非static
48. *
49. */
50. @Before
51. public void setUp(){
52. System.out.println("测试开始" + i + "," + this.hashCode());
53. }
54.
55. /**
56. * @After的意思是测试用例类构造方法之后执行,在每个测试方法之前执行
57. * 方法名不做限制,在一个类中可以出现多次,执行顺序不确定,必须声明为public 并且非static。
58. * 如果测试方法被忽略,即@Ignore,或者测试方法运行过程中被强行关闭,如@Test(timeout = xxxx),此时该方法不会被执行,其他情况下该方法都会被执行
59. *
60. */
61. @After
62. public void tearDown(){
63. System.out.println("测试结束" + (i++));
64. }
65.
66. /**
67. * 测试是否抛出指定的异常
68. * @Test的意思是该方法是测试方法,启动测试后,系统会自动查找到该方法执行。
69. * 如果测试方法中正确的逻辑是:
运行过程中会抛出一个异常(明确知道的异常),这时我们可以使用注解表达式,请见示例。
70. */
71. @Test(expected = CalculatorException.class)
72. public void testAdd1(){
73. MyCalculator.add(Integer.MAX_VALUE, 1);
74. }
75.
76. /**
77. * 测试是否抛出指定的异常
78. */
79. @Test(expected = CalculatorException.class)
80. public void testAdd2(){
81. MyCalculator.add(Integer.MIN_VALUE, -1);
82. }
83.
84. /**
85. * 测试计算结果是否准确
86. */
87. @Test
88. public void testAdd3(){
89. Assert.assertEquals(MyCalculator.add(1, 2),3);
90. }
91.
92. /**
93. * @Ignore:
忽略的测试方法,标注的含义就是“某些方法尚未完成,暂不参与此次测试”;
94. * 这样的话测试结果就会提示你有几个测试被忽略,而不是失败。
95. * 一旦你完成了相应函数,只需要把@Ignore标注删去,就可以进行正常的测试。
96. *
97. */
98. @Ignore("方法未实现")
99. @Test
100. public void testCalc4(){
101. Assert.assertEquals(MyCalculator.calcExpression("3*(4+5)"),27);
102. }
103.
104. /**
105. * @Test(timeout=1000),我们给测试函数设定一个执行时间,
106. * 超过了这个时间(1000毫秒),它们就会被系统强行终止,
107. * 并且系统还会向你汇报该函数结束的原因是因为超时,这样你就可以发现这些Bug了。
108. *
109. */
110. @Test(timeout = 1000)
111. public void testFactorial(){
112. Assert.assertEquals(MyCalculator.factorial(3),6);
113. }
114.}
4. 现在我们可以直接运行了,
测试结果,也会立马能展示出来:
如果测试全部通过,进度条的颜色是绿色,如果有Error或Failure,进度条的颜色是红色,你可以通过标识看每个Error或Failure的具体的异常或错误信息。
5. 如果我们写了很多像上面的测试类,如果我们一个个点击运行来进行测试,这样肯定会影响工作效率,这时我们需要利用JUnit的另一个概念:
Suite,它是JUnit和Suite的容器。
新建一个Suite类:
MyTestsSuite,这只是一个普通的类,不需要继承任何类,也不需要写main方法,也不需要新建任何方法,例如:
1.package com.horse;
2.
3.import org.junit.runner.*;
4.import org.junit.runners.Suite;
5.
6./**
7. *
8. * @author 马涛 2011-6-13
9. *
10. */
11.@RunWith(Suite.class)
12.@Suite.SuiteClasses({MyTestCase.class,MyTestCase2.class})
13.public class MyTestsSuite {
14.
15.}
同上面运行一样,也会出现你想要的结果,非常直观。
到时候我们可以把所有的Suite和TestCase集合到一个Suite中,然后一把运行,如果出现了绿色进度条,恭喜你,你的代码和功能测试通过;如果出现了红色进度条,那你就只能乖乖的根据测试结果修改你的代码,直至测试出现绿色进度条。
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- JUnit4 使用 入门 指南