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

@FixMethodOrder(MethodSorters.JVM)

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

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

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

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

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

@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()是一个简单的函数，它将所有可能的排列迭代到数组的Collection中。

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

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

如何使用测试夹具? (…)不能保证测试方法调用的顺序，因此testOneItemCollection()可能会在testEmptyCollection()之前执行。(…)

为什么会这样?好吧，我相信让测试依赖于顺序是作者不想提倡的做法。测试应该是独立的，它们不应该是耦合的，违反这一点会让事情更难维护，会破坏单独运行测试的能力(显然)等等。

话虽如此，如果您真的想朝着这个方向发展，可以考虑使用TestNG，因为它支持以任意顺序本机运行测试方法(以及诸如指定方法依赖于方法组之类的事情)。Cedric Beust解释了如何按照测试中执行测试的顺序来做这件事。