JUnit注解解释

最新推荐文章于 2022-03-02 00:20:45 发布
最新推荐文章于 2022-03-02 00:20:45 发布
阅读量109 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/qiangzigege/blog/830118
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

JUnit里面有很多注解，下面解释下每个注解的意义

org.junit.BeforeClass

必须为静态方法，只会执行1次，

  [1] mytest.CalculatorTest.beforeClass (CalculatorTest.java:18)
  [2] sun.reflect.NativeMethodAccessorImpl.invoke0 (native method)
  [3] sun.reflect.NativeMethodAccessorImpl.invoke (NativeMethodAccessorImpl.java:62)
  [4] sun.reflect.DelegatingMethodAccessorImpl.invoke (DelegatingMethodAccessorImpl.java:43)
  [5] java.lang.reflect.Method.invoke (Method.java:498)
  [6] org.junit.runners.model.FrameworkMethod$1.runReflectiveCall (FrameworkMethod.java:50)
  [7] org.junit.internal.runners.model.ReflectiveCallable.run (ReflectiveCallable.java:12)
  [8] org.junit.runners.model.FrameworkMethod.invokeExplosively (FrameworkMethod.java:52)
  [9] org.junit.internal.runners.statements.RunBefores.evaluate (RunBefores.java:24)
  [10] org.junit.runners.ParentRunner.run (ParentRunner.java:369)
  [11] org.junit.runners.Suite.runChild (Suite.java:128)
  [12] org.junit.runners.Suite.runChild (Suite.java:1)
  [13] org.junit.runners.ParentRunner$3.run (ParentRunner.java:296)
  [14] org.junit.runners.ParentRunner$1.schedule (ParentRunner.java:70)
  [15] org.junit.runners.ParentRunner.runChildren (ParentRunner.java:294)
  [16] org.junit.runners.ParentRunner.access$0 (ParentRunner.java:288)
  [17] org.junit.runners.ParentRunner$2.evaluate (ParentRunner.java:271)
  [18] org.junit.runners.ParentRunner.run (ParentRunner.java:369)
  [19] org.junit.runner.JUnitCore.run (JUnitCore.java:163)
  [20] org.junit.runner.JUnitCore.run (JUnitCore.java:133)
  [21] org.junit.runner.JUnitCore.runMain (JUnitCore.java:88)
  [22] org.junit.runner.JUnitCore.main (JUnitCore.java:38)

org.junit.Before

在每个Test方法之前执行，如果有多个，有排序()

如果类指定了排序类

 Comparator<Method> comparator = getSorter(clazz.getAnnotation(FixMethodOrder.class));

否则使用默认排序方法，系统有2个

/**
     * DEFAULT sort order
     */
    public static final Comparator<Method> DEFAULT = new Comparator<Method>() {
        public int compare(Method m1, Method m2) {
            int i1 = m1.getName().hashCode();
            int i2 = m2.getName().hashCode();
            if (i1 != i2) {
                return i1 < i2 ? -1 : 1;
            }
            return NAME_ASCENDING.compare(m1, m2);
        }
    };

    /**
     * Method name ascending lexicographic sort order, with {@link Method#toString()} as a tiebreaker
     */
    public static final Comparator<Method> NAME_ASCENDING = new Comparator<Method>() {
        public int compare(Method m1, Method m2) {
            final int comparison = m1.getName().compareTo(m2.getName());
            if (comparison != 0) {
                return comparison;
            }
            return m1.toString().compareTo(m2.toString());
        }
    };

具体哪个，未确认，读者自己debug下。

 

org.junit.Test

标记需要监控的方法

 

 

org.junit.After

Test方法之后执行

 

org.junit.BeforeClass

必须为静态方法，只会执行1次

 

 

org.junit.Ignore

标记的方法不会被执行,只针对@Test方法有效

 

最后，奉上测试源码

package mytest;

import static org.junit.Assert.assertEquals;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

public class CalculatorTest {
	public CalculatorTest() {
		System.out.println("CalculatorTest generated...--->" + this);
	}

	@BeforeClass
	public static void beforeClass() {
		//new Exception().printStackTrace();
		System.out.println("@BeforeClass of  invoked");
	}

	@Before
	public void before() {
		System.out.println("before of " + this + " invoked");
	}

	@Test
	public void evaluatesExpression() {
		Calculator calculator = new Calculator();
		int sum = calculator.evaluate("1+2+3");
		assertEquals(6, sum);
		System.out.println("sum is ---> " + sum);
		System.out.println("evaluatesExpression of " + this + " invoked");
	}

	@Test
	public void evaluatesExpression1() {
		Calculator calculator = new Calculator();
		int sum = calculator.evaluate("1+2+3");
		assertEquals(6, sum);
		System.out.println("sum is ---> " + sum);
		System.out.println("evaluatesExpression1 of " + this + " invoked");
	}

	@Test
	@Ignore
	public void evaluatesExpressionIgnored() {
		Calculator calculator = new Calculator();
		int sum = calculator.evaluate("1+2+3");
		assertEquals(6, sum);
		System.out.println("sum is ---> " + sum);
		System.out.println("evaluatesExpression1 of " + this + " invoked");
	}

	@After
	public void after() {
		System.out.println("after of " + this + " invoked");
	}
	
	@AfterClass
	public static void afterClass() {
		//new Exception().printStackTrace();
		System.out.println("@AfterClass of  invoked");
	}
}

package mytest;

public class Calculator {
	public int evaluate(String expression) {
		int sum = 0;
		for (String summand : expression.split("\\+"))
			sum += Integer.valueOf(summand);
		return sum;
	}
}

测试结果如下：

method--->public void mytest.CalculatorTest.before()
method--->public static void mytest.CalculatorTest.beforeClass()
method--->public void mytest.CalculatorTest.evaluatesExpressionIgnored()
method--->public void mytest.CalculatorTest.after()
method--->public void mytest.CalculatorTest.evaluatesExpression()
method--->public void mytest.CalculatorTest.evaluatesExpression1()
method--->public static void mytest.CalculatorTest.afterClass()
method--->public java.lang.String java.lang.Object.toString()
method--->public boolean java.lang.Object.equals(java.lang.Object)
method--->public final native void java.lang.Object.notify()
method--->protected void java.lang.Object.finalize() throws java.lang.Throwable
method--->public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
method--->public final void java.lang.Object.wait() throws java.lang.InterruptedException
method--->public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
method--->protected native java.lang.Object java.lang.Object.clone() throws java.lang.CloneNotSupportedException
method--->public native int java.lang.Object.hashCode()
method--->private static native void java.lang.Object.registerNatives()
method--->public final native void java.lang.Object.notifyAll()
method--->public final native java.lang.Class java.lang.Object.getClass()
getChildren *** is invoked
filteredChildren --- > [public void mytest.CalculatorTest.evaluatesExpressionIgnored(), public void mytest.CalculatorTest.evaluatesExpression(), public void mytest.CalculatorTest.evaluatesExpression1()]
[public static void mytest.CalculatorTest.beforeClass()]
@BeforeClass of  invoked

*******************************************
runChild invoked...method is --->public void mytest.CalculatorTest.evaluatesExpressionIgnored()

*******************************************
runChild invoked...method is --->public void mytest.CalculatorTest.evaluatesExpression()
methodBlock--->public void mytest.CalculatorTest.evaluatesExpression()
CalculatorTest generated...--->mytest.CalculatorTest@2f92e0f4
[public void mytest.CalculatorTest.before()]
before of mytest.CalculatorTest@2f92e0f4 invoked
sum is ---> 6
evaluatesExpression of mytest.CalculatorTest@2f92e0f4 invoked
after of mytest.CalculatorTest@2f92e0f4 invoked

*******************************************
runChild invoked...method is --->public void mytest.CalculatorTest.evaluatesExpression1()
methodBlock--->public void mytest.CalculatorTest.evaluatesExpression1()
CalculatorTest generated...--->mytest.CalculatorTest@28a418fc
[public void mytest.CalculatorTest.before()]
before of mytest.CalculatorTest@28a418fc invoked
sum is ---> 6
evaluatesExpression1 of mytest.CalculatorTest@28a418fc invoked
after of mytest.CalculatorTest@28a418fc invoked
@AfterClass of  invoked

有兴趣的可以看看网友的https://my.oschina.net/jackieyeah/blog/183277

转载于:https://my.oschina.net/qiangzigege/blog/830118

weixin_34199405
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SQLite数据库及junit注解
Han_list的博客
04-14 350
测试 黑盒测试 测试逻辑业务 白盒测试测试逻辑方法 根据测试粒度方法测试：function test 单元测试：unit test 集成测试：integration test 系统测试：system test 根据测试暴力程度冒烟测试：smoke test 压力测试：pressure test 单元测试junit 定义一个类继承AndroidTestCase，在类中定义方法，即可测试该方法 在指定
MyBatis 需要注意的地方junit注解
12-15
1.junit 常用注解 @Before 初始化方法，每次测试方法调用前都执行一次。 @After 释放资源：每次测试方法调用后都执行一次 @Test 测试方法：在这里可以测试期望异常和超时时间 @ignore 忽略的测试方法 @BeforeClass ...
junit常用注解详细说明
weixin_30825199的博客
05-07 690
Java注解（(Annotation）的使用方法是@注解名 ，能通过简单的词语来实现一些功能。在junit中常用的注解有 @Test、@Ignore、@BeforeClass、@AfterClass、@Before、@After、@Runwith、@Parameters 以下是相关的介绍和使用说明： 一.@Test 在junit3中，是通过对测试类和测试方法的命名来确定是...
【转载】JUnit各个注解的含义
tyrantForever的博客
04-08 221
转自：https://blog.csdn.net/weixin_38500014/article/details/84393775
Junit 测试框架各种注解的意思
chenzqaq的博客
03-02 412
在软件开发中为了保证软件质量单元测试是必不可少的一个环节，Java中提供了Junit 测试框架来进行单元测试 一般一个Java项目每一个类都会对应一个test类用来做单元测试，例如有一个Person类，为了测试Person类会定义一个PersonTest类来测试所有代码 JUnit 中定义了一些注解来方便我们编写单元测试 @Test：测试方法，被该注解修饰的方法就是一个测试方法 @Before：在测试方法被执行前会执行该注解修饰的方法 @After：在测试方法被执行后会执行该注解修饰的方法 除了注
JUnit(一)-常见注解含义以及执行顺序
weixin_43321280的博客
11-20 562
@Before：初始化方法 对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次） @After：释放资源 对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次） @Test：测试方法，在这里可以测试期望异常和超时时间 @Test(expected=ArithmeticException.class)检查被测方法是否抛出ArithmeticException异常 @Ignore：忽略的测试方法 @Before
Junit5依赖整合包
11-23
JUnit Jupiter则是Junit5的主要编程模型，包括注解、API以及扩展机制。JUnit Vintage则用于支持Junit3和Junit4的测试用例，确保向后兼容。 在导入这个"Junit5依赖整合包"后，你将可以使用Junit5的一系列新特性，...
Junit5.7.2离线jar
08-10
JUnit Jupiter是JUnit5的核心，负责定义新的API和注解，如@Test、@BeforeEach、@AfterEach等，用于编写测试用例。JUnit Vintage则兼容了JUnit4的API，使得老版本的测试代码可以在JUnit5环境中继续运行。 在Java项目...
Junit5.zip
01-13
2. **注解增强**：JUnit5扩展了注解，如`@Test`、`@BeforeAll`、`@BeforeEach`、`@AfterEach`和`@AfterAll`，使得测试代码更加简洁和可读。此外，还引入了条件注解，如`@Disabled`，用于标记不运行的测试。 3. **...
junit测试.zip
05-21
JUnit提供了一套简单的API，开发者可以创建断言来检验代码的预期结果，设置和清理测试环境，以及使用注解（annotations）来定义测试行为。 以下是JUnit的一些核心概念和功能： 1. **测试类和测试方法**：测试类...
JUnit以及注解基本知识点
菇凉当自强的博客
10-21 627
一，使用JUnit必须注意的几点 1.必须是无参数void返回类型的非静态方法 2.使用JUnit的类必须拥有一个无参的公开构造方法 二，其他注解 @BeforeClass – 在测试时只运行一次。必须加在static方法－不可以单独运行，在运行整个类时有可能会出错。 @AfterClass – 在测试结束时只运行一次。static方法。 @Before– 每个测试方法运行一次。必
常用的Junit的注解
LFSenior
06-18 507
常用的Junit的注解(@Before @After @Test @Ignore @BeforeClass @AfterClass) @Before：初始化方法，在任何一个测试执行之前必须执行的代码; @After：释放资源，在任何测试执行之后需要进行的收尾工作。在每个测试方法执行之后执行一次，该annotation只能修饰public void 方法; @Test：测试方法，表明这...
JUnit常见注解和方法
Tiko的博客
02-21 153
Junit测试常用注解
迷路剑客个人博客
11-22 2055
Junit常用注解 0x01 摘要 本文简要说下junit里面常用注解的含义和使用，还会总结一些常用的Assert判断语句。 0x02 常用Junit注解 2.1 @Test 用在方法上，定义该方法是测试方法。 注意：测试方法必须是public void，但可以抛异常，不过一般不这么做。 例子： @Test (timeout = 30000) public void testRMAppSubm...
JUnit4注解基本介绍
weixin_30832983的博客
08-01 605
@After If you allocate external resources in a Beforemethod you need to release them after the test runs.Annotating a public void method with @After causes that method to be run after the Testm...
JUnit入门（zz）
08-02 2858
　　JUnit是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。它包括以下特性： 　　1、用于测试期望结果的断言（Assertion） 　　2、用于共享共同测试数据的测试工具 　　3、用于方便的组织和运行测试的测试套件 　　4、图形和文本的测试运行器 　　JUnit最初是由Erich Gamma（GoF之一）
JUnit4 中@AfterClass @BeforeClass @after @before的区别对比
限量发行的专栏
07-29 189
  JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation：  @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次） @After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次） @Test：测试方法，在这里可以...
java.lang.object个人理解
qq_18846873的博客
10-21 586
1、 private static native void registerNatives();     static {         registerNatives();     } 注释：native修饰，表示该方法没有在Java中实现，而是在C/C++中实现，编译成类库dll，然后再由Java调用它。作用：方法注册到本地，也就是初始化java方法映射到C/C++的方法。 2、 pub...
JUnit常用注解
Chenyt01的专栏
05-18 1408
@Test:将一个普通的方法修饰成为一个测试方法 @Test(expected=XX.class) @Test(timeout=2000) public void testWhile() { while(true) { System.out.println("run forever..."); } } @Test(timeout=毫秒 ) @Test(timeo
spring junit 注解测试
最新发布
06-12
Spring JUnit 注解测试是一种基于 Spring 框架的单元测试方法，通过使用注解来实现依赖注入、AOP、事务控制等功能，从而方便地进行单元测试。 下面是 Spring JUnit 注解测试常用的注解及其作用： 1. @RunWith...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值