JUnit4使用入门指南.docx

资源描述

JUnit4使用入门指南.docx

《JUnit4使用入门指南.docx》由会员分享，可在线阅读，更多相关《JUnit4使用入门指南.docx（15页珍藏版）》请在冰豆网上搜索。

JUnit4使用入门指南.docx

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;

3.import com.horse.exp.CalculatorException;

5.public class MyCalculator {

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;

3.import org.junit.*;

5.import com.horse.exp.CalculatorException;

7.import junit.framework.Assert;

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;

3.import org.junit.runner.*;

4.import org.junit.runners.Suite;

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中，然后一把运行，如果出现了绿色进度条，恭喜你，你的代码和功能测试通过；如果出现了红色进度条，那你就只能乖乖的根据测试结果修改你的代码，直至测试出现绿色进度条。

展开阅读全文