How to use XMLUtils class of org.testng.reporters package

Try the following code:

//...
By mySelector = By.xpath("/html/body/div[1]/div/section/div/div[2]/form[1]/div/ul/li");
List<WebElement> myElements = driver.findElements(mySelector);
for(WebElement e : myElements) {
  System.out.println(e.getText());
}

It will returns with the whole content of the <li> tags, like:

<a class="extra">Vše</a> (950)</li>

But you can easily get the number now from it, for example by using split() and/or substring().

To quote TestNG's documentation:

Any @AfterMethod method can declare a parameter of type ITestResult, which will reflect the result of the test method that was just run.

You can use this parameter to check if the test succeeded or not:

@AfterMethod(groups = { "Regression" })
public void afterMethod(ITestResult result) {
   if (result.getStatus() == ITestResult.SUCCESS) {
        // Setting driver used to false as this test case is pass
        driverUsed.put("supportDriver", false);
        System.out.println("Test case is pass");
   }
}

Don't provide priority and depends on together, you can group the tests. You can do it like For example,

@Test(priority = 10, groups = { "10" })
public void test10() {
    System.out.println("10");
}

@Test(dependsOnMethods = "test10", groups = { "10" })
public void test20() {
    System.out.println("20, depends on 10");
}

@Test(dependsOnGroups = { "10" })
public void test30() {
    System.out.println("30, depends on 20");
}

@Test(dependsOnMethods = "test30")
public void test40() {
    System.out.println("40, depends on 10");
}

Second thing for must run (succeed or skip the rest)

You will always be run after the methods you depend on, even if some of them have failed. This is useful when you just want to make sure that your test methods are run in a certain order but their success doesn't really depend on the success of others. A soft dependency is obtained by adding "alwaysRun=true" in your @Test annotation.

If a method depended upon fails and you have a hard dependency on it (alwaysRun=false, which is the default), the methods that depend on it are not marked as FAIL but as SKIP. Skipped methods will be reported as such in the final report (in a color that is neither red nor green in HTML), which is important since skipped methods are not necessarily failures.

We used dependency injection and Guice with Guice-berry to solve this problem. The page objects were injected to the test methods and WebDriver was injected to the page objects.

As a tradeoff we had not used all this nice little chaining between page objects.

But static state and singletons are pain in the ass when it comes to parallel test execution so they should be avoided.

Once way I found is:

@Test(invocationCount = 100)

You can ignore test method using the annotation @Test(enabled = false)

The usual maven plugin for testing, the maven-surefire-plugin, handles testng as well as junit.

I didn't test with TestNG 5.12.1 but I can say that running a single test using the test parameter and tests from groups using the groups parameter works with TestNG 5.14.2 (and surefire 2.6) (groups doesn't work in TestNG 5.14)

Here is the pom.xml I'm using:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.stackoverflow</groupId>
  <artifactId>Q4159948</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>Q4159948</name>
  <url>http://maven.apache.org</url>
  <properties>
    <maven.compiler.source>1.6</maven.compiler.source>
    <maven.compiler.target>1.6</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>5.14.2</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.6</version>
        <configuration/>
      </plugin>
    </plugins>
  </build>
</project>

With a simple AppTest as follow:

import org.testng.annotations.*;

public class AppTest {

 @BeforeClass
 public void setUp() {
   // code that will be invoked when this test is instantiated
 }

 @Test(groups = { "fast" })
 public void aFastTest() {
   System.out.println("Fast test");
 }

 @Test(groups = { "slow" })
 public void aSlowTest() {
    System.out.println("Slow test");
 }

}

Both

$ mvn test -Dtest=AppTest

and

$ mvn test -Dgroups=slow

produce the expected result.

Okay, I was able to figure it out. And of course it was incredibly dumb and makes you question all of your years being a software engineer.

The problem was this line:

String className = type.toString();

The value type was of class java.lang.reflect.Type.

Can you see the issue? Don't feel bad if you can't because I couldn't either.

If you run this code:

System.out.println(type.toString());
System.out.println(type.getTypeName());

You end up with the following output:

class java.lang.String
java.lang.String

The issue is quite obvious seeing that, I should be using getTypeName() not toString(). Of course it will throw ClassNotFoundException because class<SPACE> precedes the actual class name.

Yet when I looked at the stacktrace, I overlooked it had class<SPACE> before the name of the class.

Sigh. Good times were had learning about class loaders though.