How to use getIndices method of org.testng.Interface IDataProviderMethod class

The suite tag can have the time-out attribute. This time-out will be used as default for all test methods.

This default time-out can than be overridden on a per test method basis.

The reason for the error is pretty straight forward:

Your @BeforeTest annotated method is accepting two String parameters, but you aren't injecting those parameters via the @Parameters annotation (I am seeing that in the code that you shared, you have commented it out).

TestNG is basically complaining that it doesn't know what to provide as values for those two String parameters, and TestNG can ONLY natively inject either a

• ITestContext object for which your @BeforeTest annotated method signature would look like public void setBrowser(ITestContext context){ (or)
• XmlTest object for which your @BeforeTest annotated method signature would look like public void setBrowser(XmlTest xmlTest){

So you would need to either uncomment your @Parameters annotation on top of the setBrowser() method, or change its signature to one of the above two variants.

I can think of several options:

• Finding out how much memory your method requires via a microbenchmark (i.e. jmh).
• Building allocation strategies based on heuristic estimation. There are several open source solutions implementing class size estimation i.e. ClassSize. A much easier way could be utilizing a cache which frees rarely used objects (i.e. Guava's Cache). As mentioned by @EnnoShioji, Guava's cache has memory-based eviction policies.

You can also write your own benchmark test which counts memory. The idea is to

1. Have a single thread running.
2. Create a new array to store your objects to allocate. So these objects won't be collected during GC run.
3. System.gc(), memoryBefore = runtime.totalMemory() - runtime.freeMemory()
4. Allocate your objects. Put them into the array.
5. System.gc(), memoryAfter = runtime.totalMemory() - runtime.freeMemory()

This is a technique I used in my lightweight micro-benchmark tool which is capable of measuring memory allocation with byte-precision.

I'm super confused why they would work under one scenario and not another.

So was I when I first discovered that TestNG makes (good) use of multithreading.

Try changing @BeforeTest and @AfterTest annotations to @BeforeMethod and @AfterMethod. This would be the simplest solution.

Besides persisting the WebDriver in static ThreadLocal may be key to success.

Consider this:

public class TestBase {

    protected static ThreadLocal<WebDriver> webDriver = new ThreadLocal<WebDriver>();
    protected String abc;

    @BeforeMethod
    public void setUp(){
        System.out.println("I am in setUp method.");

        //WebDriver instantiation etc.
        System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");

        ChromeOptions options = new ChromeOptions();
        options.addArguments("--start-maximized", "--disable-cache");
        webDriver.set(new ChromeDriver(options));
        webDriver.get().manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
    }

    @AfterMethod
    public void tearDown(){
        System.out.println("I am in tearDown method.");
        //You can clean up after tests.
        //webDriver.get().quit();
        webDriver.get().quit();
    }
}

In two separate files:

public class Test1 extends TestBase {

    @Test
    public void goToGoogle() {
        System.out.println("Google");
        String googleURL = "http://google.com/";
        webDriver.get().get(googleURL);
        assertTrue(webDriver.get().getCurrentUrl().contains("google"), "We are on Google!");
    }
}

and

public class Test2 extends TestBase {

    @Test
    public void goToStackOverflow() {
        System.out.println("SO!");
        String stackOverflowAddress = "http://stackoverflow.com/";
        webDriver.get().get(stackOverflowAddress);
        assertTrue(webDriver.get().getCurrentUrl().contains("stack"), "We are on SO!");
    }
}

MockitoAnnotations.initMocks(this) should be executed before test method, in JUnit

  @Before public void initMocks() {
       MockitoAnnotations.initMocks(this);
   }

Or in TestNG use @BeforeMethod

MockitoAnnotations.initMocks(this) method has to called to initialize annotated fields.

In above example, initMocks() is called in @Before (JUnit4) method of test's base class.

Just put in in your src/main/resources/ and copy to your results directory via maven resources plugin on mvn test or mvn site:

<plugin>
    <artifactId>maven-resources-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-allure-environment</id>
            <phase>pre-site</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <outputDirectory>${basedir}/target/allure-results</outputDirectory>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                        <includes>
                            <include>environment.xml</include>
                        </includes>
                    </resource>
                </resources>
            </configuration>
        </execution>
    </executions>
</plugin>

Well, uh, it was more simple than I thought, and as is often the case I find the solution only once I've asked the question...

Anyway, the solution is to create an abstract base class which initializes the toolkit for you and it is as "easy" as this:

@Test
public abstract class JavafxViewTest
{
    @BeforeClass
    public static void initToolkit()
        throws InterruptedException
    {
        final CountDownLatch latch = new CountDownLatch(1);
        SwingUtilities.invokeLater(() -> {
            new JFXPanel(); // initializes JavaFX environment
            latch.countDown();
        });

        // That's a pretty reasonable delay... Right?
        if (!latch.await(5L, TimeUnit.SECONDS))
            throw new ExceptionInInitializerError();
    }
}

TestNG was written to overcome some perceived limitations of JUnit 3. Check out Cedric's blog post or other articles on the TestNG site to see his thinking.

Note that some of the limitations of JUnit 3 were by design and TestNG deliberately allows you to do things that the designers of JUnit expressly prevented.

The biggest advantage TestNG had over JUnit 3 was that it allowed you to use annotations to define your tests, rather than forcing you to extend the JUnit base classes. JUnit 4 can also use annotations in the same way now, narrowing the gap.

The biggest remaining difference between TestNG and JUnit is that TestNG allows your tests to be dependent on one another, and allows you to express those dependencies through the test annotations. JUnit instead forces all your tests to be independent of one another.

There are other differences too, of course – TestNG defaults to assertEquals(actual, expected, message) whereas JUnit is assertEquals(message, expected, actual) – but this is the biggest.

I'd say: pick one, and try it out. Write some tests. Both work fine with Selenium. Both work fine with ant. Both work fine with CruiseControl or Hudson. Learning to write good unit tests is far more important than learning a particular set of commands (they are pretty similar anyway).

TestNG has more power and fewer restrictions, IMO, but that gives you more opportunities to get things wrong too, of course.

You've mentioned that your breakpoints are not being respected by IntelliJ and I can see from your code that there are references to a server. This might be happening if you are trying to do remote debugging:

To debug your code on a server you have to attach your debugger to its debug port. This means starting the server in debug mode, and creating a Remote debugging run configuration in IntelliJ attached to the correct port (which should be reported in your server initialisation logging).

For more information read the the original answer here.

If you are not remote debugging you can try do to the following:

• Clear your cache with File -> Invalidate Caches/Restart.
• Delete your whole project folder and import it again.
• Reinstall your IDE and delete all configurations.

I was assuming you are working in IntelliJ for some reason but all of these points should work for other programs as well.