How to use initializeSuitesAndJarFile method of org.testng.TestNG class

IAnnotationTransformer is not good choice here. There is no easy way to get original instance that called method, based only on Method interface. We can only get base class in which method was declared.

Other solution works with IMethodInterceptor, which allows filtering out methods before test suite starts and provides access to test class instance.

public class TestMethodsDisabler implements IMethodInterceptor {

    @Override
    public List<IMethodInstance> intercept(List<IMethodInstance> methods, ITestContext context) {
        List<IMethodInstance> testsToRun = new ArrayList<>();

        for (IMethodInstance method : methods) {
            Test testClass = method.getInstance()
                .getClass()
                .getAnnotation(Test.class);

            if (testClass == null || testClass.enabled()) {
                testsToRun.add(method);
            }
        }

        return testsToRun;
    }
}

That way, both standard and inherited methods are disabled when we set @Test(enabled = false) annotation on class.

It's needed to create test suite in testng.xml with this interceptor:

<suite name="ListenersSuite" parallel="false">
    <listeners>
        <listener class-name="your.package.support.TestMethodsDisabler"/>
    </listeners>

    <test name="all-test" preserve-order="true" verbose="2">
        <packages>
            <package name="your.package.tests.*"/>
        </packages>
    </test>
</suite>

Reference

• TestNG documentation - method interceptors

Just in case someone like me will end up on this question with "NoClassesFoundToAnalyze Exception" in Java 9+ era:

Firebugs is no longer supported and therefore it doesn't work with Java 9+ - use Spotbugs instead.

There's no problem with TestNG per se here.

The dataproviderthreadcount attribute that you have set in your pom file is going to be applicable and relevant only when you are running your test via mvn clean test.

If you are trying to run this test class from within the IDE (IntelliJ or Eclipse for that matter) its not going take affect.

Here's a test class that I created which is powered by a data provider ( For the sake of simplicity I have intentionally kept cucumber out of the equation )

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class AppTest {

  @Test(dataProvider = "dp")
  public void shouldAnswerWithTrue(int i) {
    System.err.println("Running on [" + Thread.currentThread().getId() + "]");

  }

  @DataProvider(name = "dp", parallel = true)
  public Object[][] testData() {
    return new Object[][]{
        {1},
        {2},
        {3},
        {4},
        {5},
        {6}
    };
  }
}

Here's the command line output when I run mvn clean test

[INFO] --- maven-surefire-plugin:3.0.0-M5:test (default-test) @ testng_playground ---
[INFO] 
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.rationaleemotions.AppTest
Running on [15]
Running on [14]
Running on [15]
Running on [14]
Running on [14]
Running on [15]
[INFO] Tests run: 6, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.62 s - in com.rationaleemotions.AppTest
[INFO] 
[INFO] Results:
[INFO] 
[INFO] Tests run: 6, Failures: 0, Errors: 0, Skipped: 0

Within your running TestNG tagged test, Thread.activeCount() gives you the number of threads just in your current TestNG group. If your threadPoolSize is set to 1, this number will be 1. If your threadPoolSize is greater than 1, this number will be threadPoolSize + 1, because there is also a TestNG manager thread in addition to the pool size. For threads that you create on the fly, you need to construct them passing in your TestNG ThreadGroup. Example:

    Thread aNewWorkerThread = new Thread( Thread.currentThread().getThreadGroup(), yourRunnableThingHere ); 

Those threads, when active, should then be reflected in your Thread.activeCount() return value.

Declare a parameter of type ITestResult in your @AfterMethod and TestNG will inject it:

@AfterMethod
public void afterMethod(ITestResult result) {
  System.out.println("method name:" + result.getMethod().getMethodName());
}

I fixed it by adding a resolver, my-maven, with https root and add it to the chain. It should also work if I change the root of the central resolver.

<ivysettings>
    <settings defaultResolver="default"/>
    <resolvers>
        <ibiblio name="local-m2" m2compatible="true"
                 root="file://${user.home}/.m2/repository"
                 changingPattern=".*SNAPSHOT"/>
        <ibiblio name="my-maven" m2compatible="true" root="https://repo1.maven.org/maven2/"/>
        <!--<ibiblio name="staging" m2compatible="true" root="https://oss.sonatype.org/content/repositories/orgagileclick-1008"/>-->
        <ibiblio name="central" m2compatible="true"/>

        <filesystem name="local-m2-publish" m2compatible="true">
            <artifact
                    pattern="${user.home}/.m2/repository/[organisation]/[module]/[revision]/[artifact]-[revision](-[classifier]).[ext]"/>
        </filesystem>

        <filesystem name="local-m2-publish-snapshot" m2compatible="true">
            <artifact
                    pattern="${user.home}/.m2/repository/[organisation]/[module]/[revision]-SNAPSHOT/[artifact]-[revision]-SNAPSHOT.[ext]"/>
        </filesystem>

        <chain name="default">
            <resolver ref="central"/>
            <resolver ref="my-maven"/>
            <!--<resolver ref="local-m2"/>-->
        </chain>
    </resolvers>
</ivysettings>

Mocking ==> https://stackoverflow.com/questions/37359/what-c-mocking-framework-to-use

Continuous Integration ==> CruiseControl.NET

JSON Serialization ==> DataContractJsonSerializer

GUI == > WPF (different than Swing but nice)

Web Server hooks ==> Mod_Mono

it is simple you can set the attribute in your test class and then call this attribute in you listener class

For example

testClass.java

@BeforeClass
public void setDriver(ITestContext context){
  Webdriver driver = new FirefoxDriver();
  context.setAttribute("WebDriver", driver);
}
@Test
public void t1(){
   // your code
}

Listener.java

WebDriver driver = null;
@Override
public void onTestFailure(ITestResult result) {
    ITestContext context = result.getTestContext();
    driver = (WebDriver) context.getAttribute("WebDriver");
    // your code
}

Here you need to make a note that in your test class you need to set the driver attribute and then call this attribute in that listener once. your driver in test class and listener class will be the same

Mockito is not a testing framework. It's a mocking API. Use JUnit or TestNG. These are testing frameworks. Both simply require some annotations to be placed on test methods.

And of course, your JUnit or TestNG tests will use the Mockito API internally, to mock dependencies.