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

JUnit 4 @BeforeClass & @AfterClass when using Suites

提问by Andreas Mattisson

When using this approach below, by setting up the jUnit with Suites. We got the problem when all @BeforeClass in every Testclass will be executed before any tests starts to execute. (For each n TestClass file the @BeforeClass runs, then after they have execute, it started to execute the first MyTest.class files @Test)

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

This will cause that we allocate up much resources and memory. My thoughts was that it must be wrong, shouldn't each @BeforeClass run only before the actual testclass is executed, not when the Suite is started?

这将导致我们分配很多资源和内存。我的想法是它一定是错误的，每个 @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
        ...

采纳答案by nayakam

Write a @BeforeClass method in AllTests class which will be executed when the suite is started.

在 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");
    }

}

OUTPUT

输出

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

hth

第

回答by nfechner

I think, @BeforeClassexecutes at instanciation.

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

回答by Grundlefleck

I'm not too familiar with @RunWithin JUnit, so I may have done something wrong, but I can't seem to replicate the behaviour you describe. With the class:

我对@RunWithJUnit不太熟悉，所以我可能做错了什么，但我似乎无法复制你描述的行为。随着班级：

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

And FirstTest.java looking like this:

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());
    }
}

... with SecondTest.java and ThirdTest.java pretty much the same. I get the test output:

...与 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

This is with JUnit 4.5.0 (default JUnit in Eclipse 3.5.1) on Sun's JDK 1.6.0_12. Can you spot any difference in my example from yours? Perhaps a different JDK/JVM? I don't know enough about the internals of JUnit to know if these can be a factor.

这是 Sun JDK 1.6.0_12 上的 JUnit 4.5.0（Eclipse 3.5.1 中的默认 JUnit）。你能发现我的例子和你的例子有什么不同吗？也许不同的JDK/JVM？我对 JUnit 的内部结构知之甚少，无法知道这些是否可能是一个因素。