@BeforeClass and inheritance - order of execution

Question

I have an abstract basis class, which I use as a basis for my unit tests (TestNG 5.10). In this class I initialize the whole environment for my tests, setting up database mappings, etc. That abstract class has a method with a @BeforeClass annotation which does the initialization. Next thing, I extend that class with specific classes in which I have @Test methods and also @BeforeClass methods. These methods do class-specific initialization of the environment, e.g. put some records into the database.

My question is how I can enforce a specific order of the @BeforeClass annotated methods. I need the ones from the abstract base class to be executed before the ones of the extending class.

Example:

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

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

 @Test
 doTests() {...}
}

Expected order:

A.doInitialization
B.doSpecificInitialization
B.doTests

Actual order:

B.doSpecificInitialization // <- crashes, as the basic init is missing
(A.doInitialization        // <---not executed
 B.doTests)                // <-/

Answer 1

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.

Answer 2

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

Answer 3

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

Answer 4

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
}