使用套件时的 JUnit 4 @BeforeClass 和 @AfterClass答案

【问题标题】：JUnit 4 @BeforeClass & @AfterClass when using Suites使用套件时的 JUnit 4 @BeforeClass 和 @AfterClass
【发布时间】：2010-12-27 15:35:34
【问题描述】：

当使用下面的这种方法时，通过设置带有套件的 jUnit。当每个 Testclass 中的所有 @BeforeClass 都将在任何测试开始执行之前执行时，我们遇到了问题。（对于每个 n 个 TestClass 文件，@BeforeClass 运行，然后在它们执行后，它开始执行第一个 MyTest.class 文件@Test）

这将导致我们分配大量资源和内存。我的想法是它一定是错误的，每个@BeforeClass 不应该只在实际测试类执行之前运行，而不是在套件启动时运行？

@RunWith(Suite.class)
@Suite.SuiteClasses({ MyTests.class, Mytests2.class, n1, n2, n })
public class AllTests {
    // empty
}


public class MyTests {  // no extends here
    @BeforeClass
    public static void setUpOnce() throws InterruptedException {
        ...
    @Test
        ...

public class MyTests2 {  // no extends here
    @BeforeClass
    public static void setUpOnce() throws InterruptedException {
        ...
    @Test
        ...

【问题讨论】：

它们是在每个类的测试之前执行，还是只在第一个测试之前执行（但是第二个在没有再次运行所有 @BeforeClass 的情况下运行）？后者看起来不错，因为 @BeforeClass 在该测试中的 @Test 方法之前运行。我想内存量不会改变，除非你在每个班级的测试之后清理（而且这些也只在整个套件完成后才会发生）。
我现在得到的是每个 @BeforeClass 都首先运行。 @BeforeClass (Mytests) @BeforeClass (Mytests2) @Test (MyTests) @Test (MyTests2) 在我看来，这是不正确的。如果我错了，请纠正我，但一定是设置错误导致此问题。

标签： java junit junit4

【解决方案1】：

在AllTests 类中编写一个@BeforeClass 方法，该方法将在套件启动时执行。

public class MyTests1 { 
    @BeforeClass
    public static void beforeClass() {
        System.out.println("MyTests1.beforeClass");
    }

    @Before
    public void before() {
        System.out.println("MyTests1.before");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("MyTests1.AfterClass");
    }

    @After
    public void after() {
        System.out.println("MyTests1.after");
    }

    @Test
    public void test1() {
        System.out.println("MyTests1.test1");
    }

    @Test
    public void test2() {
        System.out.println("MyTests1.test2");
    }
}



public class MyTests2 { 
    @BeforeClass
    public static void beforeClass() {
        System.out.println("MyTests2.beforeClass");
    }

    @Before
    public void before() {
        System.out.println("MyTests2.before");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("MyTests2.AfterClass");
    }

    @After
    public void after() {
        System.out.println("MyTests2.after");
    }

    @Test
    public void test1() {
        System.out.println("MyTests2.test1");
    }

    @Test
    public void test2() {
        System.out.println("MyTests2.test2");
    }
}




@RunWith(Suite.class)
@Suite.SuiteClasses( { MyTests1.class, MyTests2.class })
public class AllTests {

    @BeforeClass
    public static void beforeClass() {
        System.out.println("AllTests.beforeClass");
    }

    @Before
    public void before() {
        System.out.println("AllTests.before");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("AllTests.AfterClass");
    }

    @After
    public void after() {
        System.out.println("AllTests.after");
    }

    @Test
    public void test1() {
        System.out.println("AllTests.test1");
    }

    @Test
    public void test2() {
        System.out.println("AllTests.test2");
    }
    
}

输出：

AllTests.beforeClass
MyTests1.beforeClass
MyTests1.before
MyTests1.test1
MyTests1.after
MyTests1.before
MyTests1.test2
MyTests1.after
MyTests1.AfterClass
MyTests2.beforeClass
MyTests2.before
MyTests2.test1
MyTests2.after
MyTests2.before
MyTests2.test2
MyTests2.after
MyTests2.AfterClass
AllTests.AfterClass

【讨论】：

AllTests.test1() 和 "AllTests.test2() 永远不会被执行？
@nayakam 这将解决眼前的问题，但我认为个别测试类或子套件不能单独运行？

【解决方案2】：

我对 JUnit 中的 @RunWith 不太熟悉，所以我可能做错了什么，但我似乎无法复制您描述的行为。与班级：

@RunWith(Suite.class)
@Suite.SuiteClasses( { FirstTest.class, SecondTest.class, ThirdTest.class })
public class AllTests {
    // empty
}

FirstTest.java 看起来像这样：

public class FirstTest {
    @BeforeClass
    public static void doBeforeClass() {
         System.out.println("Running @BeforeClass for FirstTest");
    }

    @Test
    public void doTest() {
        System.out.println("Running @Test in " + getClass().getName());
    }
}

... SecondTest.java 和 ThirdTest.java 几乎相同。我得到了测试输出：

Running @BeforeClass for FirstTest
Running @Test in FirstTest
Running @BeforeClass for SecondTest
Running @Test in SecondTest
Running @BeforeClass for ThirdTest
Running @Test in ThirdTest

这适用于 Sun 的 JDK 1.6.0_12 上的 JUnit 4.5.0（Eclipse 3.5.1 中的默认 JUnit）。你能发现我的例子和你的有什么不同吗？也许是不同的 JDK/JVM？我不太了解 JUnit 的内部结构，不知道这些是否是一个因素。

【讨论】：

正如你所描述的，这也是我应该得到的。但是我先得到一堆@BeforeClass，然后我看到第一个@Test，@Test 等等。使用 Sun 的 JDK 1.6.0_17、Eclipse 3.5，但随后我们使用 ant 运行 maven 执行功能测试。其中一些会影响结果吗？如果我在 Eclipse 中设置它并运行它，它似乎在 ant 或 maven 中有点问题。
抱歉，在 ant 或 maven 中运行 JUnit 实在帮不上忙。虽然我为我使用的示例导出了 build.xml，并使用测试目标运行它，并得到了您正在寻找的行为，但我怀疑 JUnit ant 任务有什么问题。 困惑地耸耸肩

【解决方案3】：

我认为，@BeforeClass 在实例化时执行。

【讨论】：

它没有。 “使用 @BeforeClass 注释公共静态 void 无参数方法会导致它在类中的任何测试方法之前运行一次。超类的 @BeforeClass 方法将在当前类之前运行。” （来源：JUnit 文档）
只是为那些有内存问题的人添加一些额外的信息。 JUnit 将在运行时保存所有状态，因此也会保存所有静态变量，直到所有 JUnit 测试执行完毕。这也是一个主要问题，因为我们正在运行 1000-6000 个 JUnit 测试。这是因为它需要它在最后显示结果。