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

I thought that I would share my answer because it took a little while to figure out and my particular problem is somewhat different than the problems of others who have encountered this particular stack trace.

The solution is to add the following XML element to Surefire's configuration in the pom.xml file.

<configuration>
  <!-- pre-existing config -->
  <properties>
    <property>
      <name>junit</name>
      <value>false</value>
    </property>
  </properties>
</configuration>

This is documented further in the Surefire documentation on running JUnit and TestNG tests together.

My question is, why is @AfterTest method not run after each @Test annotation?

As the Documentation says

@AfterTest: The annotated method will be run after all the test methods belonging to the classes inside the <test> tag have run.

and

@BeforeTest: The annotated method will be run before any test method belonging to the classes inside the <test> tag is run.

After hours of en-devour, I am able to solve the issue. Please remove unnecessary jar files from Classpath and try. It worked for me. Cheers..:)

Regs

Use the reflected method to get the group of the test as below :

@BeforeMethod
public void befMet(Method m){
        Test t = m.getAnnotation(Test.class);
        System.out.println(t.groups()[0]);//or however you want to use it.
}

From testng documentation, this is how @optional is used.

@Parameters("db")
@Test
public void testNonExistentParameter(@Optional("mysql") String db) { ... }

If no parameter named "db" is found in your testng.xml file, your test method will receive the default value specified inside the @Optional annotation: "mysql".

Try by correcting your code accordingly. I think that should resolve the issue. If it still doesn't then declare the parameters at the suite tag level in testng.xml and test it.

I know you've already solved your problem, but for folks who will come here in the future...

Unfortunately it seems that there is no way to disable existing transaction inside test that uses @Transactional annotation.

IMHO Spring approach here is extremely inflexible. But there is a workaround for your problem. It would be enough to encapsulate needed logic inside Spring TransactionTemplate class. This would ensure that code in your test case would be launched inside a new transaction.

Personal advice: the best and the most flexible way from my point of view is to abandon from the very beginning @Transactional tests and setup database into known state before every test. In this way, Spring will manage transactions exactly the same way as in production.
No quirks, no hacks, no manual transaction management.

I know that using @Transactional with a "rollback" policy around unit tests is a tempting idea, but it has too many pitfalls. I recommend reading this article Spring Pitfalls: Transactional tests considered harmful.

Of course I don't complain here about @Transactional itself - because it greatly simplifies transaction management in the production code.

Following should do the trick:

@BeforeClass
public void beforeClass() {
    String className = this.getClass().getName();
}

This file appears because of the known Java bug.

The bug is already fixed for Java 12.

JetBrains developers have backported this fix into JetBrains Runtime and the fix is delivered in IntelliJ IDEA 2019.1 EAP version (to be released in the end of March 2019).

The maven-surefire-plugin, as of today, does not have full support of JUnit 5. There is an open issue about adding this support in SUREFIRE-1206.

As such, you need to use a custom provider. One has already been developed by the JUnit team; from the user guide, you need to add the junit-platform-surefire-provider provider and the TestEngine implementation for the new API:

<build>
  <plugins>        
    <plugin>
      <artifactId>maven-surefire-plugin</artifactId>
      <!-- latest version (2.20.1) does not work well with JUnit5 -->
      <version>2.19.1</version>
      <dependencies>
        <dependency>
          <groupId>org.junit.platform</groupId>
          <artifactId>junit-platform-surefire-provider</artifactId>
          <version>1.0.3</version>
        </dependency>
        <dependency>
          <groupId>org.junit.jupiter</groupId>
          <artifactId>junit-jupiter-engine</artifactId>
          <version>5.0.3</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

Also, be sure to declare the junit-jupiter-api dependency with a scope of test:

<dependencies>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.0.3</version>
    <scope>test</scope>
  </dependency>
</dependencies>