How to use Interface IDataProviderMethod class of org.testng package

You can use @Parameters annotation, but you have to specify values in testng,xml it means you have to have separate testng.xml for each set of parameters.

Here is example:

AppTest.java

public class AppTest {
    @Parameters({"par1", "par2"})
    @BeforeMethod()
    public void setUp(String a, String b) {
        System.out.println("a = [" + a + "], b = [" + b + "]");
    }

    @Test
    public void testApp() {
    }
}

testng.xml

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="Suite1" verbose="1" >

    <test name="Run1" >
        <parameter name="par1"  value="val"/>
        <parameter name="par2"  value="anotherval"/>
        <packages>
            <package name="dummy.java" />
        </packages>
    </test>

    <test name="Run2" >
        <parameter name="par1"  value="newValue"/>
        <parameter name="par2"  value="yetAnotherVal"/>
        <packages>
            <package name="dummy.java" />
        </packages>
    </test>
</suite>

Instead of

import org.apache.log4j.Logger;

use

import org.apache.logging.log4j.Logger;

and define the instance of LOGGER

private static final Logger LOGGER = LogManager.getLogger("HelloWorld");

See this sample http://logging.apache.org/log4j/2.x/manual/api.html

this has nothing todo with Gradle

When you create TestSuite, you can pass desiredTestCaseName as constructor argument:

public class AllTestSuite extends TestSuite{

  public static Test suite() {
      TestSuite suite= new TestSuite();
      Test testCase1 = new MyTest("TestCaseOne");
      Test testCase2 = new MyTest("TestCaseTwo");
      suite.addTest(testCase1);
      suite.addTest(testCase2);
      return suite;
  }
}

When you run the suite, it will refer the names supplied in constructor i.e. TestCaseOne and TestCaseTwo while test class is MyTest.

EDIT:

Please make sure you have defined the constructor in MyTest class as:

public MyTest(String name) {
    super(name);
}

If additional parameters support is desired, you can add an constructor in Test case to accept the parameters and assign them to test case class variables(initially defaulted with default test scenario values), which can be used during test execution:

public MyTest(String name, String param1, Integer param2...) {
    super(name);
    this.param1 = param1;
    this.param2 = param2;
}

Once you run your test suite, JUnit Console looks like screen below:

Easiest solution would be, add the below lines in surefire plugin.

<suiteXmlFiles>
    <!-- pass testng.xml files as argument from command line -->
    <suiteXmlFile>${suiteXmlFile}</suiteXmlFile>
</suiteXmlFiles>

And run your xml file as below,

mvn clean test -Dsurefire.suiteXmlFiles=/path/to/testng.xml

Surefire lets you invoke TestNG with any command line parameters you like, and TestNG does support a "verbose" command line, so it's probably only a matter of doing something like

<configuration>
  <verbose>true</verbose>
</configuration>

This XPath

//SPAN[not(*)]

will select all SPAN elements that have no children elements, so it'll select

<SPAN>Some Text 1</SPAN>
<SPAN>Some Text 2</SPAN>

but not the SPAN that contains the Text 2 SPAN, as requested.

If you want to restrict the SPAN element selected to only those leaf 'SPAN' elements that are somewhere under TH elements:

//TH//SPAN[not(*)]

I am currently trying to do the same. I found the following maybe that helps you:

http://testng.org/doc/documentation-main.html#methodinterceptors

If I get some sort of solution for my problem I could add some of my code here if you want.

EDIT

I am checking for 2 Kinds of TestClasses that should be executed in the order 1 2 1 2 1 2 not 1 1 1 2 2 2 as done by TestNG

public class ExampleInterceptor implements IMethodInterceptor {

@Override
public List<IMethodInstance> intercept(List<IMethodInstance> paramList, ITestContext paramITestContext) {

     //You have to watch out to get the right test if you have other tests in oyur suite        
    if (!paramITestContext.getName().equals("UnwantedTest")) {
        for (IMethodInstance iMethodInstance : paramList) {
            Object[] obj = iMethodInstance.getInstances();
            if (obj[0] instanceof Class1) {
                //DO your stuff like putting it in a list/array
            } else {
                //DO your stuff like putting it in a list/array with the other Testclasses
            }
        }
    }
    List<IMethodInstance> result = new ArrayList<IMethodInstance>();

            //Put the results in the results

    }
    return result;
}

}

Hope that helps. If you got questions ask.

The simplest way is by using ITestResult.

    @Override
    public void afterInvocation(IInvokedMethod arg, ITestResult arg1) { 
      System.out.println(arg.getTestMethod().getMethodName());
      System.out.println(arg1.getMethod().getDescription());
    }

The second sysout will return a (String) description of the invoked test method.

Actually I think that the bad feeling in your gut against has more to do with Annotations like this mixing configuration with code.

Personally I feel the same way as you do, I would prefer to leave configuration (such as transaction definitions, path elements, URLs that a controller should be mapped to, etc.) outside of the code base itself and in external Spring XML context files.

I think though that the correct approach here comes down to opinion and which method you prefer - I would predict that half the community would agree with the annotations approach and the other half would agree with the external configuration approach.