How to use Interface ITestRunnerFactory class of org.testng package

According to User Property of suiteXmlFiles You can use:

mvn test -Dsurefire.suiteXmlFiles=test1.xml,test2.xml

Probably in your catch{UnhandledAlertException e) block handle it by providing:

 Alert alert = driver.switchTo().alert();

 alert.accept();

You want to use an ITestListener (or more practically, a TestListener).

The official overview is: http://testng.org/doc/documentation-main.html#testng-listeners and the Javadoc is http://testng.org/javadocs/org/testng/ITestListener.html

To save you some time, you can extend a TestListenerAdapter, which will @Override all of the methods for you (so you only have to use the @Overrides you need).

Unlike JUnit, TestNG test listeners will be executed after your @Test method, and before your @AfterMethod. Also unlike JUnit, the Test Listener will have an ITestResult object passed in as a parameter, allowing you to access all of the fields and methods of your test class via Java reflection.

JUnit Jupiter (Vanilla)

You can combine multiple sources within e.g. a @MethodSource. Based on your TestNG example:

class ExampleTest {

    @ParameterizedTest
    @MethodSource("args")
    void test(String classParameter, String testParameter) {
        System.out.println(classParameter + " " + testParameter);
    }

    static Stream<Arguments> args() {
        return classParameters().flatMap(
                classParameter -> testParameters().map(
                        testParameter -> Arguments.of(classParameter, testParameter)));
    }

    static Stream<String> classParameters() {
        return Stream.of("classParam1", "classParam2");
    }

    static Stream<String> testParameters() {
        return Stream.of("testParam1", "testParam2");
    }

}

This produces:

classParam1 testParam1
classParam1 testParam2
classParam2 testParam1
classParam2 testParam2

As requested by the OP, here is "an example with at least two test methods with different set of parameters":

class ExampleTest {

    static Stream<String> classParams() {
        return Stream.of("classParam1", "classParam2", "classParam3");
    }

    static Stream<Arguments> withClassParams(List<?> methodParams) {
        return classParams().flatMap(
                classParam -> methodParams.stream().map(
                        methodParam -> Arguments.of(classParam, methodParam)));
    }

    @ParameterizedTest
    @MethodSource
    void booleanParams(String classParam, boolean booleanParam) {
        System.out.println(classParam + " " + booleanParam);
    }

    static Stream<Arguments> booleanParams() {
        return withClassParams(List.of(false, true));
    }

    @ParameterizedTest
    @MethodSource
    void integerParams(String classParam, int integerParam) {
        System.out.println(classParam + " " + integerParam);
    }

    static Stream<Arguments> integerParams() {
        return withClassParams(List.of(1, 2, 3, 4, 5, 6));
    }

    @ParameterizedTest
    @MethodSource
    void objectParams(String classParam, Object objectParam) {
        System.out.println(classParam + " " + objectParam);
    }

    static Stream<Arguments> objectParams() {
        return withClassParams(List.of(new Object()));
    }

}

3 class parameters plus 3 different method parameters with different types and sizes, producing the following output:

classParam1 java.lang.Object@35cabb2a
classParam2 java.lang.Object@35cabb2a
classParam3 java.lang.Object@35cabb2a
classParam1 1
classParam1 2
classParam1 3
classParam1 4
classParam1 5
classParam1 6
classParam2 1
classParam2 2
classParam2 3
classParam2 4
classParam2 5
classParam2 6
classParam3 1
classParam3 2
classParam3 3
classParam3 4
classParam3 5
classParam3 6
classParam1 false
classParam1 true
classParam2 false
classParam2 true
classParam3 false
classParam3 true

JUnit Pioneer

There is the JUnit Pioneer extension pack for JUnit Jupiter. It comes with @CartesianProductTest. Using the extended the example from above:

class CartProdTest {

    @CartesianProductTest(factory = "classWithObjectParams")
    void testClassWithObject(String classParam, Object objectParam) {
        System.out.println(classParam + " " + objectParam);
    }

    static CartesianProductTest.Sets classWithObjectParams() {
        return new CartesianProductTest.Sets()
                .addAll(classParams())
                .add(new Object());
    }

    @CartesianProductTest(factory = "classWithIntegerParams")
    void testClassWithInteger(String classParam, int integerParam) {
        System.out.println(classParam + " " + integerParam);
    }

    static CartesianProductTest.Sets classWithIntegerParams() {
        return new CartesianProductTest.Sets()
                .addAll(classParams())
                .add(1, 2, 3, 4, 5, 6);
    }

    @CartesianProductTest(factory = "classWithBooleanParams")
    void testClassWithBoolean(String classParam, boolean booleanParam) {
        System.out.println(classParam + " " + booleanParam);
    }

    static CartesianProductTest.Sets classWithBooleanParams() {
        return new CartesianProductTest.Sets()
                .addAll(classParams())
                .add(false, true);
    }

    static Stream<String> classParams() {
        return Stream.of("classParam1", "classParam2", "classParam3");
    }

}

This produces the same output.

Yes, you can include the link to your screenshot in testng report.

You need to call org.testng.Reporter.log method to write the hyperlink to the testng report either by annotating your test class or parent of all testclasses with @Listeners({yourListener.class}) or by adding the listener to your testng.xml.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="default">
  <listeners>
    <listener class-name="ScreenshotListener" />
  </listeners>
  <test name="Test">
    <packages>
      <package name="someTests.*"/>
    </packages>
  </test>
</suite>

You need to first create a Listener class and add it to testng. You can get details for that from testng.org. Search for listener.

Once you create that class, you should write a method in it which overrides the ontestfailure method. The code inside this method will be executed whenever testng identifies a failure.

You can call your screenshot grabbing method and use Reporter.log to put the hyperlink to that screenshot. Then you can find this link under the failed testcases details.

import java.io.*;
import java.util.*;
import java.text.*;
import org.apache.commons.io.FileUtils;

import org.openqa.selenium.*;

import org.testng.*;

public class ScreenshotListener extends TestListenerAdapter {
    @Override
    public void onTestFailure(ITestResult result) {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat formater = new SimpleDateFormat("dd_MM_yyyy_hh_mm_ss");
        String methodName = result.getName();
        if(!result.isSuccess()){
            File scrFile = ((TakesScreenshot)SomeStaticWebDriver.driver).getScreenshotAs(OutputType.FILE);
            try {
                String reportDirectory = new File(System.getProperty("user.dir")).getAbsolutePath() + "/target/surefire-reports";
                File destFile = new File((String) reportDirectory+"/failure_screenshots/"+methodName+"_"+formater.format(calendar.getTime())+".png");
                FileUtils.copyFile(scrFile, destFile);
                Reporter.log("<a href='"+ destFile.getAbsolutePath() + "'> <img src='"+ destFile.getAbsolutePath() + "' height='100' width='100'/> </a>");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Your DerivedProperty instances are returned from the persistence context (only their ids are used from the result set returned from the query). That's why formulas haven't been evaluated.

Persistence context is not cleared if you don't close the entity manager. Try adding em.clear() after you commit the first transaction to force clearing the persistence context.

1) IMethodInterceptor allows user to modify the list of methods (or Test) to be executed. 2) IInvokedMethodListener allows user to perform certain action before/after a method has been executed. something like clean up or setup. 3) First IMethodInterceptor is called so that if user wishes to modify the list of method to be executed then a user can change it and pass it to TestRunner. Please see below example code:

    package practise;

import org.testng.IInvokedMethod;
import org.testng.IInvokedMethodListener2;
import org.testng.ITestContext;
import org.testng.ITestResult;

public class InvokedMethodListener implements IInvokedMethodListener2
{
    @Override
    public void afterInvocation(IInvokedMethod arg0, ITestResult arg1)
    {
        System.out.println(Thread.currentThread().getStackTrace()[0].getMethodName());
    }

    @Override
    public void beforeInvocation(IInvokedMethod arg0, ITestResult arg1)
    {
        System.out.println(Thread.currentThread().getStackTrace()[0].getMethodName());
    }

    @Override
    public void afterInvocation(IInvokedMethod arg0, ITestResult arg1, ITestContext arg2)
    {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName());
    }

    @Override
    public void beforeInvocation(IInvokedMethod arg0, ITestResult arg1, ITestContext arg2)
    {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName());
    }

}


    package practise;

import java.util.List;

import org.testng.IMethodInstance;
import org.testng.IMethodInterceptor;
import org.testng.ITestContext;

public class MethodInterceptor implements IMethodInterceptor
{

    @Override
    public List<IMethodInstance> intercept(List<IMethodInstance> arg0, ITestContext arg1)
    {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName());
        return arg0;
    }

}

    package practise;

import org.testng.annotations.Listeners;

@Listeners(value={MethodInterceptor.class,InvokedMethodListener.class})
public class Test
{
    @org.testng.annotations.Test
    public void first()
    {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName());
    }

    @org.testng.annotations.Test
    public void second()
    {
        System.out.println(Thread.currentThread().getStackTrace()[1].getMethodName());
    }
}

You need to declare your test method with the data that you are filling in the dataprovider, so in your case, it should be

 public void twoUsersSignUp(WebDriver d, WebDriverWait w).

The only difference is related to programming style.

Commenting source code is commonly recognized as violation. Commented code should be removed from source code.

There is violation Avoid commented-out lines of code in Sonarqube with nice description

Here are the main reasons why commented code is a code smell :

• It always raises more questions than it gives answers
• Everybody will forget very quickly how relevant the commented code is
• This is distraction when going down the code as it stops the flow of eyes
• It is a bad SCM engine : Subversion, CVS and Git are really more trustworthy !
• The simple fact of understanding why code was commented out in the first place can take a lot of time

Example real case: Code cleanup: remove commented out code