@BeforeTest/@BeforeSuite in superclass only invoked on first instance that inherits from it.

[jabbrwcky]

I noticed that a @BeforeTest/@BeforeSuite method defined in as superclass of a test will only be executed once on the first instance of the inheriting classes.
As the documentation on the test annotations is a little sparse sometimes, it is not clear to me if this should be considered as bug or as feature.

If the @BeforeTest/@BeforeSuite method is executed on every inheriting class it might lose some of its semantics and act like a method annotated with @BeforeClass, which might not be the perfect solution in my eyes.

The other way would be to clearly document this not immediately obvious behavior and use the test context (ITestContext) to provide Test-scoped configuration and instance data to running tests.
This could be a possible solution:

public abstract class AbstractTestBase {

    /** Property Foo is set once per Suite */
    protected String foo;

    /** Property Foo is set once per Test */
    protected String bar;

    /**
     * Store foo in context.
     *
     * @param context test context for storing test conf data
     */
    @BeforeSuite
    public void beforeSuite(ITestContext context) {
        out.println("@BeforeSuite called on " + getClass().getName());
        context.setAttribute("foo", "I was set in @BeforeSuite");
    }


    /**
     * Store bar in context.
     *
     * @param context test context for storing test conf data
     */
    @BeforeTest(alwaysRun = true)
    public void beforeTest(ITestContext context) {
        out.println("@BeforeTest called on " + getClass().getName());
        context.setAttribute("bar", "I was set in @BeforeTest");
    }

    /**
     * Fetch foo and bar from context per instance.
     *
     * @param context test context to retrieve conf data from.
     */
    @BeforeClass
    public void beforeClass(ITestContext context) {
        out.println("@BeforeClass called on " + getClass().getName());
        foo = (String) context.getAttribute("foo");
        bar = (String) context.getAttribute("bar");
    }
}

A small project demonstrating the behavior and my current solution is here: https://github.com/jabbrwcky/testng-annotation-demo

/Jens

[ash2k]

I already reported it 10 months (!) ago #184.

[VladRassokhin]

As i can see from code this behavior is by-design:
https://github.com/cbeust/testng/tree/master/src/test/java/test/uniquesuite
So there probably documentation problem.

Also using @BeforeSuite with ITestContext may cause troubles if you have this method in more than one <test>. (Just add <class name="net.hausherr.demo.TestA" /> into your "T1" test in testng.xml)

IMHO: Nice solution for that problem is generating implementation of AbstractTest on-the-fly if needed and instantiate that class. Or print warning message.

[juherr]

@DurgaManickam Please, could you ask it on StackOverflow or the mailing list first?

[krmahadevan]

@juherr - I this we can close this issue. WDYT ?

[juherr]

It works as expected: a before suite method is only called once by suite, even if it is located in a superclass.

[abdulrazak-mumms]

any conclusion fix for this issue ?

 java.lang.IllegalStateException: No TestRunnerAdaptor found, @BeforeSuite has not been called

[juherr]

@abdulrazak-mumms Could you open a new issue and include a sample which reproduces the issue?