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

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

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

Or

_1_TestWorkUnit_WithCertainState_ShouldDoSomething _2_TestWorkUnit_WithCertainState_ShouldDoSomething _3_TestWorkUnit_WithCertainState_ShouldDoSomething

你可以在这里找到例子。

请看这个:https://github.com/TransparentMarket/junit。它按照指定的顺序(在已编译的类文件中定义)运行测试。此外，它还提供了一个AllTests套件，可以首先运行由子包定义的测试。使用AllTests实现还可以扩展过滤属性的解决方案(我们过去使用@Fast注释，但这些注释还没有发布)。

是时候转向Junit5了。 以下是我们可以得到的一个例子:

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

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

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

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

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

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

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

从JUnit 4.13开始，您可以通过扩展ordered定义自己的类来重新排序测试。请参阅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");
    }
}

这是我在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()”的方法开始。 谢谢!