junit基础 关于annotation的使用说明

JUnit 4 使用 Java 5 中的注解（annotation），以下是JUnit 4 常用的几个 annotation 介绍
@Before：初始化方法
@After：释放资源
@Test：测试方法，在这里可以测试期望异常和超时时间
@Ignore：忽略的测试方法
@BeforeClass：针对所有测试，只执行一次，且必须为static void
@AfterClass：针对所有测试，只执行一次，且必须为static void
一个JUnit 4 的单元测试用例执行顺序为：
@BeforeClass –> @Before –> @Test –> @After –> @AfterClass
每一个测试方法的调用顺序为：
@Before –> @Test –> @After

 

@BeforeClass and @AfterClass	@Before and @After
在一个类中只可以出现一次	在一个类中可以出现多次，即可以在多个方法的声明前加上这两个Annotaion标签，执行顺序不确定
方法名不做限制	方法名不做限制
在类中只运行一次	在每个测试方法之前或者之后都会运行一次
@BeforeClass父类中标识了该Annotation的方法将会先于当前类中标识了该Annotation的方法执行。 @AfterClass 父类中标识了该Annotation的方法将会在当前类中标识了该Annotation的方法之后执行	@Before父类中标识了该Annotation的方法将会先于当前类中标识了该Annotation的方法执行。  @After父类中标识了该Annotation的方法将会在当前类中标识了该Annotation的方法之后执行
必须声明为public static	必须声明为public 并且非static
所有标识为@AfterClass的方法都一定会被执行，即使在标识为@BeforeClass的方法抛出异常的的情况下也一样会。	所有标识为@After 的方法都一定会被执行，即使在标识为 @Before 或者 @Test 的方法抛出异常的的情况下也一样会。

@BeforeClass 和 @AfterClass 对于那些比较“昂贵”的资源的分配或者释放来说是很有效的，因为他们只会在类中被执行一次。相比之下对于那些需要在每次运行之前都要初始化或者在运行之后都需要被清理的资源来说使用@Before和@After同样是一个比较明智的选择。

 

Junit Assert超类所提供的8个核心方法

import static  org.junit.Assert.*;

　　1．assertEquals ([String message],expected,actual)：

           用来查看对象中存的值是否是期待的值，与字符串比较中使用的equals()方法类似；

   　2．assertFalse ([String messag],boolean condition)

            assertTrue ([String messag],boolean condition)：

           用来查看变量是是否为false或true，如果assertFalse()查看的变量的值是false则

           测试成功，如果是true则失败，assertTrue()与之相反；

      3．assertSame ([String message],expected,actual)

            assertNotSame ([Spring message],expected,actual)：

           用来比较两个对象的引用是否相等和不相等，类似于通过“==”和“!=”比较两个对象；

          （与equal有区别）

　　4．assertNull ([String message]，java.lang.Object object)

            assertNotNull ([String message]，java.lang.Object object)：

           用来查看对象是否为空和不为空;

　　5．fail ([String message])：

           意为失败，用来抛出错误。fail()一旦被执行，会立即中止测试，java虚拟机不再执行任

          何别的代码，并且会抛出  junit.framework.AssertionFailedError错误!我个人认为有

          两个用途：首先是在测试驱动开发中，由于测试用例都是在被测试的类之前编写的，而写成

          时又不清楚其正确与否，此时就可以使用fail方法抛出错误进行模拟；其次是抛出意外的错

         误，比如要测试的内容是从数据库中读取的数据是否正确，而导致错误的原因却是数据库连

         接失败，这样便可以直接找出错误的根源。

          在入参上标有"[ ]"的是可以选的，加上这些会让测试代码出错时报出你设置的错误信息。

 

 

7个JUnit核心类之间的关系及生命周期

 

 

 

 

 

 

写个例子测试一下，测试一下

 

Java代码  

1. package junit.text;  
2.   
3.   
4. import org.junit.After;  
5. import org.junit.AfterClass;  
6. import org.junit.Assert;  
7. import org.junit.Before;  
8. import org.junit.BeforeClass;  
9. import org.junit.Ignore;  
10. import org.junit.Test;  
11. public class Testago {  
12.     @Before  
13.     public void before() {  
14.       System.out.println("@Before");  
15.     }  
16.     @Test  
17.     public void test() {  
18.       System.out.println("@Test1");  
19. Assert.assertEquals(5 + 5, 10);  
20.     }  
21.   
22.     @Ignore  
23.     @Test  
24.     public void testIgnore() {  
25.       System.out.println("@Ignore");  
26.     }  
27.   
28.     @Test(timeout = 50)  
29.     public void testTimeout() {  
30.       System.out.println("@Test(timeout = 50)");//单位毫秒  
31.       Assert.assertEquals(5 + 5, 10);  
32.     }  
33.   
34.     @Test(expected = ArithmeticException.class)  
35.     public void testExpected() {  
36.       System.out.println("@Test(expected = Exception.class)");  
37.       throw new ArithmeticException();  
38.     }  
39.   
40.     @After  
41.     public void after() {  
42.        System.out.println("@After");  
43.       }  
44.         
45.       @BeforeClass  
46.       public static void beforeClass() {  
47.        System.out.println("@BeforeClass");  
48.       };  
49.         
50.       @AfterClass  
51.       public static void afterClass() {  
52.        System.out.println("@AfterClass");  
53.       }  
54.     }  

 

 

 

输出结果

@BeforeClass

@Before

@Test(timeout = 50)

@After

@Before

@Test(expected = Exception.class)

@After

@Before

@Test1

@After

@AfterClass

http://niatwangcong.iteye.com/blog/292820