如何在 JUnit4 中按特定顺序运行测试方法？

Question

我想按特定顺序执行由@Test 注释的测试方法。

例如：

public class MyTest {
    @Test public void test1(){}
    @Test public void test2(){}
}

我想确保每次运行MyTest 时在test2() 之前运行test1()，但是我找不到像@Test(order=xx) 这样的注释。

我认为这对 JUnit 来说是相当重要的特性，如果 JUnit 的作者不想要 order 特性，为什么？

Answer 1

我认为这是 JUnit 非常重要的特性，如果 JUnit 的作者不想要订单特性，为什么？

我不确定 JUnit 是否有一种干净的方法可以做到这一点，据我所知，JUnit 假定所有测试都可以按任意顺序执行。来自常见问题解答：

How do I use a test fixture?

(...) 测试方法调用的顺序是不保证，因此 testOneItemCollection() 可能在 testEmptyCollection() 之前执行。 (...)

为什么会这样？好吧，我相信让测试顺序依赖是作者不想推广的一种做法。测试应该是独立的，它们不应该是耦合的，违反这个会使事情更难维护，会破坏单独运行测试的能力（显然），等等。

话虽如此，如果您真的想朝这个方向发展，请考虑使用 TestNG，因为它支持以任意顺序运行测试方法（例如指定方法取决于方法组）。 Cedric Beust 在order of execution of tests in testng 中解释了如何做到这一点。

Answer 2

如果您摆脱现有的 Junit 实例，并在构建路径中下载 JUnit 4.11 或更高版本，以下代码将按名称顺序执行测试方法，升序排序：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {

    @Test
    public void testAcreate() {
        System.out.println("first");
    }
    @Test
    public void testBupdate() {
        System.out.println("second");
    }
    @Test
    public void testCdelete() {
        System.out.println("third");
    }
}

Answer 3

如果订单很重要，您应该自己下订单。

@Test public void test1() { ... }
@Test public void test2() { test1(); ... }

特别是，如有必要，您应该列出一些或所有可能的顺序排列以进行测试。

例如，

void test1(); 
void test2(); 
void test3(); 


@Test
public void testOrder1() { test1(); test3(); }

@Test(expected = Exception.class)
public void testOrder2() { test2(); test3(); test1(); }

@Test(expected = NullPointerException.class)
public void testOrder3() { test3(); test1(); test2(); }

或者，对所有排列的完整测试：

@Test
public void testAllOrders() {
    for (Object[] sample: permute(1, 2, 3)) {
        for (Object index: sample) {
            switch (((Integer) index).intValue()) {
                case 1: test1(); break; 
                case 2: test2(); break; 
                case 3: test3(); break; 
            }
        }
    }
}

这里，permute() 是一个简单的函数，它将所有可能的排列迭代到一个数组集合中。

Answer 4

迁移到 TestNG 似乎是最好的方法，但我认为 jUnit 没有明确的解决方案。这是我为 jUnit 找到的最可读的解决方案/格式：

@FixMethodOrder( MethodSorters.NAME_ASCENDING ) // force name ordering
public class SampleTest {
    @Test
    void stage1_prepareAndTest(){};

    @Test
    void stage2_checkSomething(){};

    @Test
    void stage2_checkSomethingElse(){};

    @Test
    void stage3_thisDependsOnStage2(){};

    @Test
    void callTimeDoesntMatter(){}
}

这样可以确保在 stage1 之后和 stage3 之前调用 stage2 方法。

附：我觉得这种方法比 jUnit 5.5 @Order 注释更好，因为它为读者提供了更好的符号。

Answer 5

JUnit 自 5.5 起允许 @TestMethodOrder(OrderAnnotation.class) 用于类，@Order(1) 用于测试方法。

JUnit 旧版本允许使用类注解对测试方法运行排序：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
@FixMethodOrder(MethodSorters.JVM)
@FixMethodOrder(MethodSorters.DEFAULT)

默认情况下，测试方法按字母顺序运行。因此，要设置特定方法的顺序，您可以将它们命名为：

a_TestWorkUnit_WithCertainState_ShouldDoSomething b_TestWorkUnit_WithCertainState_ShouldDoSomething c_TestWorkUnit_WithCertainState_ShouldDoSomething

或者

_1_TestWorkUnit_WithCertainState_ShouldDoSomething _2_TestWorkUnit_WithCertainState_ShouldDoSomething _3_TestWorkUnit_WithCertainState_ShouldDoSomething

你可以找到examples here。

Answer 6

这是我在使用 Junit 时遇到的主要问题之一，我想出了以下对我来说很好的解决方案：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

public class OrderedRunner extends BlockJUnit4ClassRunner {

    public OrderedRunner(Class<?> clazz) throws InitializationError {
        super(clazz);
    }

    @Override
    protected List<FrameworkMethod> computeTestMethods() {
        List<FrameworkMethod> list = super.computeTestMethods();
        List<FrameworkMethod> copy = new ArrayList<FrameworkMethod>(list);
        Collections.sort(copy, new Comparator<FrameworkMethod>() {

            @Override
            public int compare(FrameworkMethod f1, FrameworkMethod f2) {
                Order o1 = f1.getAnnotation(Order.class);
                Order o2 = f2.getAnnotation(Order.class);

                if (o1 == null || o2 == null) {
                    return -1;
                }

                return o1.order() - o2.order();
            }
        });
        return copy;
    }
}

还可以创建如下界面：

 @Retention(RetentionPolicy.RUNTIME)


@Target({ ElementType.METHOD})

public @interface Order {
public int order();
}

现在假设你有一个 A 类，你已经编写了几个测试用例，如下所示：

(@runWith=OrderRunner.class)
Class A{
@Test
@Order(order = 1)

void method(){

//do something

}

}

所以执行将从名为“method()”的方法开始。 谢谢！

Answer 7

JUnit 5 更新（以及我的看法）

我认为这对 JUnit 来说是相当重要的功能，如果 JUnit 的作者不想要订单功能，为什么？

默认情况下，单元测试库不会尝试按照源文件中出现的顺序执行测试。

JUnit 5 作为 JUnit 4 以这种方式工作。为什么？因为如果顺序很重要，则意味着它们之间会耦合一些测试，这不适合单元测试。
所以 JUnit 5 引入的@Nested 特性遵循相同的默认方法。

但对于集成测试，测试方法的顺序可能很重要，因为测试方法可能会以另一种测试方法所期望的方式更改应用程序的状态。
例如，当您为电子商店结账处理编写集成测试时，要执行的第一个测试方法是注册客户，第二个是在购物篮中添加商品，最后一个是进行结账。如果测试运行者不遵守该顺序，则测试场景有缺陷并且会失败。
因此，在 JUnit 5（从 5.4 版本开始）中，您可以通过使用 @TestMethodOrder(OrderAnnotation.class) 注释测试类并使用 @Order(numericOrderValue) 为顺序重要的方法指定顺序来设置执行顺序。

例如：

@TestMethodOrder(OrderAnnotation.class) 
class FooTest {

    @Order(3)
    @Test
    void checkoutOrder() {
        System.out.println("checkoutOrder");
    }

    @Order(2)
    @Test
    void addItemsInBasket() {
        System.out.println("addItemsInBasket");
    }

    @Order(1)
    @Test
    void createUserAndLogin() {
        System.out.println("createUserAndLogin");
    }
}

输出：

createUserAndLogin

addItemsInBasket

结帐订单

顺便说一句，似乎不需要指定@TestMethodOrder(OrderAnnotation.class)（至少在我测试的 5.4.0 版本中）。

旁注
关于问题：JUnit 5 是编写集成测试的最佳选择吗？我不认为它应该是第一个考虑的工具（Cucumber 和 co 可能经常为集成测试带来更具体的价值和特性）但是在一些集成测试用例中，JUnit 框架就足够了。因此，该功能存在是个好消息。

Answer 8

（尚未发布的）更改https://github.com/junit-team/junit/pull/386 引入了@SortMethodsWith。 https://github.com/junit-team/junit/pull/293 至少在没有它的情况下使顺序可预测（在 Java 7 中它可能是非常随机的）。

Answer 9

查看 JUnit 报告。 JUnit 已经按包组织。每个包都有（或可以有）TestSuite 类，每个类依次运行多个 TestCases。每个TestCase 可以有多个public void test*() 形式的测试方法，每个测试方法实际上都将成为它们所属的TestCase 类的一个实例。每个测试方法（TestCase 实例）都有一个名称和一个通过/失败标准。

我的管理层需要的是单个 TestStep 项目的概念，每个项目都报告自己的通过/失败标准。任何测试步骤的失败都不能阻止后续测试步骤的执行。

过去，像我这样的测试开发人员将 TestCase 类组织到与被测产品的各个部分相对应的包中，为每个测试创建一个 TestCase 类，并使每个测试方法成为一个单独的“步骤”测试，在 JUnit 输出中有自己的通过/失败标准。每个 TestCase 都是一个独立的“测试”，但 TestCase 中的各个方法或测试“步骤”必须以特定的顺序出现。

TestCase 方法是 TestCase 的步骤，测试设计人员在每个测试步骤中获得了单独的通过/失败标准。现在测试步骤很混乱，测试（当然）失败了。

例如：

Class testStateChanges extends TestCase

public void testCreateObjectPlacesTheObjectInStateA()
public void testTransitionToStateBAndValidateStateB()
public void testTransitionToStateCAndValidateStateC()
public void testTryToDeleteObjectinStateCAndValidateObjectStillExists()
public void testTransitionToStateAAndValidateStateA()
public void testDeleteObjectInStateAAndObjectDoesNotExist()
public void cleanupIfAnythingWentWrong()

每种测试方法都断言并报告其自己单独的通过/失败标准。 为了排序而将其折叠成“一个大测试方法”会丢失 JUnit 摘要报告中每个“步骤”的通过/失败标准粒度。 ...这让我的经理们感到不安。他们目前正在要求另一种选择。

谁能解释一下带有乱序测试方法排序的 JUnit 如何支持每个连续测试步骤的单独通过/失败标准，如上例所示并由我的管理层要求？

不管文档如何，我都认为这是 JUnit 框架的严重退化，这让许多测试开发人员的生活变得困难。

Answer 10

不确定我是否同意，如果我想测试“文件上传”，然后测试“文件上传插入的数据”，为什么我不希望它们彼此独立？我认为能够单独运行它们而不是在 Goliath 测试用例中同时运行它们是完全合理的。

Answer 11

当测试用例作为一个套件运行时，你想要的是完全合理的。

很遗憾现在没有时间给出完整的解决方案，但是看看类：

org.junit.runners.Suite

这允许您以特定顺序调用测试用例（从任何测试类）。

这些可用于创建功能、集成或系统测试。

这会使您的单元测试保持原样，没有特定的顺序（如推荐的那样），无论您是否像那样运行它们，然后重新使用测试作为更大图景的一部分。

我们为单元、集成和系统测试重复使用/继承相同的代码，有时是数据驱动的，有时是提交驱动的，有时作为一个套件运行。

Answer 12

在此处查看我的解决方案： “Junit 和 Java 7。”

在本文中，我将描述如何按顺序运行 junit 测试 - “就像在您的源代码中一样”。 测试将按照您的测试方法出现在类文件中的顺序运行。

http://intellijava.blogspot.com/2012/05/junit-and-java-7.html

但正如 Pascal Thivent 所说，这不是一个好习惯。

Answer 13

使用 JUnit 5.4，您可以指定顺序：

@Test
@Order(2)
public void sendEmailTestGmail() throws MessagingException {

你只需要注释你的类

@TestMethodOrder(OrderAnnotation.class)

https://junit.org/junit5/docs/current/user-guide/#writing-tests-test-execution-order

我在我的项目中使用它，效果很好！

Answer 14

您可以使用以下代码之一： @FixMethodOrder(MethodSorters.JVM) 或 @FixMethodOrder(MethodSorters.DEFAULT) 或 @FixMethodOrder(MethodSorters.NAME_ASCENDING)

在你的测试课之前是这样的：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class BookTest {...}

Answer 15

正如其他人所说，理想情况下，测试应该独立于执行顺序。这使得测试不那么脆弱，并允许它们独立运行（许多 IDE 允许您选择一种测试方法并独立于其他测试执行它）。

话虽如此，对于集成测试，有些人更喜欢依赖方法排序。

从 JUnit 4.13 开始，您可以定义自己的类来通过扩展 Ordering 来重新排序测试。有关详细信息，请参阅the JUnit wiki。下面是一个使用内置 Alphanumeric 类使用测试方法名称按字母数字顺序排列测试的示例：

import org.junit.Test;
import org.junit.runner.OrderWith;
import org.junit.runner.manipulation.Alphanumeric;

@OrderWith(Alphanumeric.class)
public class TestMethodOrder {

    @Test
    public void testA() {
        System.out.println("first");
    }
    @Test
    public void testB() {
        System.out.println("second");
    }
    @Test
    public void testC() {
        System.out.println("third");
    }
}

Answer 16

是时候迁移到 Junit5了。 以下是我们可以获得的示例：

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class OrderedTests {

     @Test
     @Order(1)
     void nullValues() {}

     @Test
     @Order(2)
     void emptyValues() {}

     @Test
     @Order(3)
     void validValues() {}
 }

对于 Junit4，将您在多个测试中的逻辑复制到一个测试方法中。

Answer 17

对于 JUnit 4，将这个注解放在测试类上解决了这个问题。

@FixMethodOrder(MethodSorters.JVM)

Answer 18

JUnit 4 更新

从 JUnit 4.13 @OrderWith 开始，可以重现 JUnit 5 @Order 注释。与 @RunWith 自定义 BlockJUnit4ClassRunner 实现相比，此解决方案与 JUnit 4 更好地集成。

以下是我如何将方法名称排序 (@FixMethodOrder(MethodSorters.NAME_ASCENDING)) 替换为注解排序。

@OrderWith(OrderAnnotation.class)
public class MyTest {
    @Test
    @Order(-1)
    public void runBeforeNotAnnotatedTests() {}

    @Test
    public void notAnnotatedTestHasPriority0() {}

    @Test
    @Order(1)
    public void thisTestHasPriority1() {}

    @Test
    @Order(2)
    public void thisTestHasPriority2() {}
}

/**
 * JUnit 4 equivalent of JUnit 5's {@code org.junit.jupiter.api.Order}
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface Order {
    /**
     * Default order value for elements not explicitly annotated with {@code @Order}.
     *
     * @see Order#value
     */
    int DEFAULT = 0;

    /**
     * The order value for the annotated element.
     * <p>Elements are ordered based on priority where a lower value has greater
     * priority than a higher value. For example, {@link Integer#MAX_VALUE} has
     * the lowest priority.
     *
     * @see #DEFAULT
     */
    int value();
}

import org.junit.runner.Description;
import org.junit.runner.manipulation.Ordering;
import org.junit.runner.manipulation.Sorter;

/**
 * Order test methods by their {@link Order} annotation. The lower value has the highest priority.
 * The tests that are not annotated get the default value {@link Order#DEFAULT}.
 */
public class OrderAnnotation extends Sorter implements Ordering.Factory {
    public OrderAnnotation() {
        super(COMPARATOR);
    }

    @Override
    public Ordering create(Context context) {
        return this;
    }

    private static final Comparator<Description> COMPARATOR = Comparator.comparingInt(
            description -> Optional.ofNullable(description.getAnnotation(Order.class))
                                   .map(Order::value)
                                   .orElse(Order.DEFAULT));
}

未注释的测试的默认优先级为 0。具有相同优先级的测试的顺序未确定。

要点：https://gist.github.com/jcarsique/df98e0bad9e88e8258c4ab34dad3c863

灵感来源：

• Aman Goel's answer
• Test execution order Wiki by JUnit team
• JUnit 5 source code

Answer 19

我已经阅读了一些答案并同意它不是最佳实践，而是排序测试的最简单方法 - JUnit 默认运行测试的方式是按字母名称升序。

因此，只需按您想要的字母顺序命名您的测试。还要注意测试名称必须以 用词测试。请注意数字

test12 将在 test2 之前运行

所以：

testA_MyFirstTest testC_ThirdTest testB_ATestThatRunsSecond

Answer 20

请查看这个：https://github.com/TransparentMarket/junit。它按照指定的顺序运行测试（在编译的类文件中定义）。它还具有一个 AllTests 套件，可以首先运行由子包定义的测试。使用 AllTests 实现，可以扩展解决方案以过滤属性（我们曾经使用 @Fast 注释，但尚未发布）。

Answer 21

这里是 JUnit 的一个扩展，可以产生所需的行为：https://github.com/aafuks/aaf-junit

我知道这与 JUnit 哲学的作者背道而驰，但是当在非严格单元测试的环境中使用 JUnit 时（如在 Java 中实践的那样），这可能会非常有帮助。

Answer 22

我最终认为我的测试没有按顺序运行，但事实是我的异步工作中出现了混乱。处理并发时，您还需要在测试之间执行并发检查。 在我的例子中，作业和测试共享一个信号量，所以下一个测试会挂起，直到正在运行的作业释放锁。

我知道这与这个问题并不完全相关，但也许可以帮助解决正确的问题

Answer 23

如果您想在 JUnit 5 中按特定顺序运行测试方法，可以使用以下代码。

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class MyClassTest { 

    @Test
    @Order(1)
    public void test1() {}

    @Test
    @Order(2)
    public void test2() {}

}