How to use writeFile method of org.testng.reporters.Files class

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();
    }
}

I take it you want to have your tests run not only in maven, but also in some other build system (e.g., Ant) ?

If that is the case then I think what you want is some nice reports that tell you how your tests did. If so, you might want to look at this project: http://reportng.uncommons.org/

you need to create an ant classpath ref 'test-path' that includes your test jars (and the jars for the classes under test)... then you would do something like this

<testng classpathref="test-path" outputdir="${test-results.dir}" haltonfailure="true" useDefaultListeners="false" listeners="org.uncommons.reportng.HTMLReporter,org.uncommons.reportng.JUnitXMLReporter"> <xmlfileset dir="." includes="testng.xml"/> <sysproperty key="org.uncommons.reportng.title" value="My Test Report"/> </testng>

You can use the Maven Surefire Plugin and set reuseForks to "false":

Indicates if forked VMs can be reused. If set to "false", a new VM is forked for each test class to be executed. If set to "true", up to forkCount VMs will be forked and then reused to execute all tests.

e.g.:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.19.1</version>
    <configuration>
        <reuseForks>false</reuseForks>
        <includes>
            <include>**/Test*.java</include>
        </includes>
    </configuration>
</plugin>

See Maven Surefire Plugin – Fork Options and Parallel Test Execution for more details.

If you're using JUnit and you expect a test to throw a specific exception, do this:

@Test(expected = MyException.class)
public throwsExceptionWhenPassedAnIllegalValue() {
   [...]
}

If you're using TestNG, similar syntax:

@Test(expectedExceptions = MyException.class)
public void throwsExceptionWhenPassedAnIllegalValue() {
    [...]
}

If the exception that you're expecting is not thrown, these test methods will fail.

You may want to try mockito. The test works like this:

You use mockito to "implement" EntityManager. Instead of the real code, you use the methods of mockito to say "if the application calls getReference(), then return this object". In the background, mockito will create a proxy instance which intercepts the Java method calls and returns the values which you specify. Calls to other methods will return null.

Mocking things like createQuery() works the same way but you first need to create a mockup of Query and then use the same approach as in getReference() (return the query mockup).

Since you don't use a real EM, you don't need a real persistence.xml.

A much more simple solution would be if you could set some property to change the name of the persistence.xml file but I don't think that this is possible.

Some other links that may help:

• How to configure JPA for testing in Maven
• Suggest a JPA Unit test framework

Testng is calling methods in this specific order: serviceData, beforeMethod and m1.

If you want to pass a mock with a data provider, you have to create it before or into the data provider method.

@DataProvider is one of the ways to pass parameters to a method. You cannot use both for same method.

Looking at your question, you can simply add the brand to the DataProvider method something like,

  @DataProvider(name="dpCGA")
  public Object[][] data() {

    return new Object[][] { 
        {"brand", "email1"}, 
        {"brand", "email2"}
     };
  }

and pass it to the method,

@Test(dataProvider="dpCGA", groups={"CGA"})
public void createAccount(String brand, String email) {
    setBrand(brand);
    createAccount(email);
}

The use case that you are looking for, kind of defeats the purpose of SoftAssert. SoftAssert was basically introduced in TestNG, so that you can gather all the assertions, throughout one @Test method but fail the test method only at the end (when you invoke assertAll()).

A data driven @Test method is basically a @Test method that runs "n" times (each iteration is running with a different set of data). So it doesn't make sense for you to try and leverage SoftAssert and invoke its assertAll() on the last iteration. Because if you do that, it would basically boil down to only the last iteration failing.

So if you are looking at re-running tests by using the testng-failed.xml then it would contain only the index of the last iteration (Which is kind of absurd, because it wasn't the last iteration that actually failed).

So ideally speaking, you should make use of SoftAssert only within the scope of a single iteration. That means you instantiate a SoftAssert object within a @Test method, invoke a bunch of assertXXX() calls, and at the end of the method you invoke assertAll().

All said and done, if you are still looking for a sample that would show you how to do this, here's a sample.

First we define an interface that lets me set the size of the data provider provided data set as an attribute to the test class.

public interface IDataSet {
    void setSize(int size);
}

The test class looks like below

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import org.testng.annotations.TestInstance;
import org.testng.asserts.SoftAssert;

import java.util.concurrent.atomic.AtomicInteger;

public class SoftAssertDemo implements IDataSet {
  private int size;
  private SoftAssert assertion = new SoftAssert();
  private AtomicInteger counter = new AtomicInteger(1);

  @Override
  public void setSize(int size) {
    this.size = size;
  }

  @Test(dataProvider = "dp")
  public void testMethod(int number) {
    if ((number % 2) == 0) {
      assertion.fail("Simulating a failure for " + number);
    }
    if (counter.getAndIncrement() == size) {
      assertion.assertAll();
    }
  }

  @DataProvider(name = "dp")
  public Object[][] getData(@TestInstance Object object) {
    Object[][] data = new Object[][] {{1}, {2}, {3}, {4}, {5}};
    if (object instanceof IDataSet) {
      ((IDataSet) object).setSize(data.length);
    }
    return data;
  }
}

Caveats in this approach:

1. A test class should have only one @DataProvider method in it because the data provider is passing on the size of the data set back to the test class instance. So if you have 2 or more data providers, there's a chance of data race going on, wherein one data provider overwrites the other one.
2. If you want to house 2 or more data providers, then you would need to ensure that those @Test methods that are powered by the data providers, dont run in parallel.

If all your tests extend some base class, I think you can stick @Rule in there which will apply to all the @Test in the child class.

e.g.

import org.junit.rules.Timeout;
public abstract class BaseTestConfiguration {
    @Rule public Timeout testTimeout = new Timeout(60000); // 60k ms = 1 minute
}

public class ThingTests extends BaseTestConfiguration {
    @Test
    public void testThis() {
        /*will fail if not done in 1 minute*/
    }
    @Test
    public void testThat() {
        /*will fail if not done in 1 minute*/
    }
}

We found this to be easiest rather than messing with AspectJ or secret configuration directives. Devs are more likely to figure out the Java parts than all the secret XML this and that. You can put @Before @After and any number of other junit directives in the base class too.