@ Before Class 和继承-执行顺序

小开

最佳答案

Don't put the @BeforeClass on the abstract class. Call it from each subclass.

abstract class A {
void doInitialization() {}
}


class B extends A {
@BeforeClass
void doSpecificInitialization() {
super.doInitialization();
}


@Test
void doTests() {}
}

Seems like TestNG has @BeforeClass(dependsOnMethods={"doInitialization"}) - give it a try.

小开

edit: Answer below is for JUnit, but I will leave it here anyway, because it could be helpful.

According to the JUnit api: "The @BeforeClass methods of superclasses will be run before those the current class."

I tested this, and it seems to work for me.

However, as @Odys mentions below, for JUnit you need to have the two methods named differently though as doing otherwise will result in only the subclass method being run because the parent will be shadowed.

小开

I just tried your example with 5.11 and I get the @BeforeClass of the base class invoked first.

Can you post your testng.xml file? Maybe you are specifying both A and B there, while only B is necessary.

Feel free to follow up on the testng-users mailing-list and we can take a closer look at your problem.

-- Cedric

小开

How about having your @BeforeClass method call an empty specificBeforeClass() method that may or may not be overwritten by sub classes like so:

public class AbstractTestClass {
@BeforeClass
public void generalBeforeClass() {
// do stuff
specificBeforeClass();
}


protected void specificBeforeClass() {}
}


public class SpecificTest {
@Override
protected void specificBeforeClass() {
// Do specific stuff
}


// Tests
}

小开

I added public to the abstract class and TestNG (6.0.1) executed the doInitialization() before doTests. TestNG does not execute doInitialization() if I remove public from class A.

public abstract class A {
@BeforeClass
doInitialization() {...}
}


class B extends A {
@Test
doTests() {...}
}

小开

When I run from: JUnitCore.runClasses(TestClass.class); It will execute the parent properly, before the child (You do not need super.SetUpBeforeClass();) If you run it from Eclipse: For some reason it fails to run the base class. The work around: Call the base class explicitely: (BaseTest.setUpBeforeClass();) You may want to have a flag in the base class in case you run it from an application, to determine if it is already setup or not. So it only runs once if you run it via both possible methods (such as from eclipse for personal testing, and through ANT for a build release).

This appears to be a bug with Eclipse, or at least unexpected results..

小开

In my case (JUnit) I have the same methods called setup() in the base class and the derived class. In this case only the derived class's method is called, and I have it call the base class method.

小开

Why don't you try to create an abstract method doSpecialInit() in your super class, called from your BeforeClass annotated method in superclass.

So developpers inheriting your class is forced to implement this method.

小开

I've just gone through this and found one more way to achieve this. Just use alwaysRun on @BeforeClass or @BeforeMethod in the abstract class, works as you would expect.

public class AbstractTestClass {
@BeforeClass(alwaysRun = true)
public void generalBeforeClass() {
// do stuff
specificBeforeClass();
}
}

小开

dependsOnMethod can be used.

e.g. in case of Spring (AbstractTestNGSpringContextTests)

@BeforeClass(alwaysRun = true, dependsOnMethods = "springTestContextPrepareTestInstance")

小开

A better and cleaner way to achieve this using inheritance may be as following -

abstract class A {


@BeforeClass
void doInitialization() {}
}


class B extends A {


@Override
@BeforeClass
void doInitialization() {
super.doInitialization();
}


@Test
void doTests() {}
}

小开

For JUnit: As @fortega has mentioned: According to the JUnit api: "The @BeforeClass methods of superclasses will be run before those the current class."

But be careful not to name both methods with the same name. Since in this case the parent method will be hidden by child parent. Source.

小开

There is another easy solution here.

My particular situation is that I need to inject mock services from "BeforeClass" in the subclass before "BeforeClass" in the superclass is executed.

To do this - simply use a @ClassRule in the subclass.

For example:

@ClassRule
public static ExternalResource mocksInjector = new ExternalResource() {
@Override
protected void before() {
// inject my mock services here
// Note: this is executed before the parent class @BeforeClass
}
};

I hope this helps. This can effectively execute static setup in "reverse" order.

小开

Check your import statement. It should be

import org.testng.annotations.BeforeClass;

not

import org.junit.BeforeClass;

小开

I've faced a similar issue today, the only difference was a Base class was not abstract

Here's my case

public class A {
@BeforeClass
private void doInitialization() {...}
}


public class B extends A {
@BeforeClass
private void doSpecificInitialization() {...}


@Test
public void doTests() {...}
}

It occurred that a @BeforeClass method from class A was never executed.

A.doInitialization() -> THIS WAS NEVER EXECUTED silently
B.doSpecificInitialization()
B.doTests()

Playing with privacy modifiers I found that TestNG will not execute a @BeforeClass annotated method from inherited class if a method is not visible from a class-inheritor

So this will work:

public class A {
@BeforeClass
private void doInitialization() {...}
}


public class B extends A {
@BeforeClass
//Here a privacy modifier matters -> please make sure your method is public or protected so it will be visible for ancestors
protected void doSpecificInitialization() {...}


@Test
public void doTests() {...}
}

As a result following happens:

A.doInitialization()
B.doSpecificInitialization()
B.doTests()

小开

This works for me --

abstract class A {
@BeforeClass
doInitialization() {...}
}


class B extends A {
@Override
@BeforeClass
doInitialization() {


//do class specific init


}


@Test
doTests() {...}
}