How to use getModel method of org.testng.reporters.jq.BasePanel class

The main difference between JUnit and TestNG is the test class instantiation. JUnit always creates a new instance of the test class for each test method run. TestNG only creates one test class instance and then runs all test methods of this instance.

The JUnit approach guarantees the independency of all test methods. It just does not matter, in which order they run. Additionally, all instance fields are always setup the same for each test method. Initializing data, that is common for all test methods, must take place at the class level, thus it must be static. This is the reason, why the @BeforeClass method must be static.

The TestNG approch does not guarante the independency. In fact, you cannot use an instance field in the same manner as in JUnit tests. If you change such a field in one test method, the changed value is still observabl in another test method. However, this behavior has also an advantage: Sometimes there are dependencies between some test methods. With TestNG, a tester can express them.

Because of the one-instance-approach of TestNG, the @BeforeClass setup can also be a non-static method, but it is still run only once. It was a design decision, but testers using TestNG must be aware of that.

You could also check imports for imported Test annotation, should be:

import org.testng.annotations.Test;
@Test
public myTest(){ ... }

and not for example:

import org.junit.Test;

You can't use regex in the class name attribute with TestNG xml. Regex can be used in include, exclude tags and package tags. So to make this work you can do one of these:

<classes>
 <class name="test.YOUR_PACKAGE.testclass>
  <methods>
    <include name=".*testcase01"/>
  </methods>
  </class>
</classes>

Here the * will include every method in your class that ends with testcase01.

Or:

<suite name="Suite One">
  <test name="Test One" >
     <packages>
        <package name="test.*" />
     </packages>
  </test>
</suite>

* here will include all classes under test package.

That is because the groups flag only indicates if a method belongs to a group. When that group is enabled, it is executed always, i.e. before all tests methods irrespective of the group the test methods belong to. By default all groups are enabled.

If you want to have the method only executed for the tests of certain groups, you would need to specify onlyForGroups.

public class BeforeTest {

    private static final Logger LOG = Logger.getLogger(BeforeTest.class);

    @BeforeMethod(onlyForGroups = { "g1" })
    public void setUpG1() {
        sleep();
        LOG.info("BeforeMethod G1");
    }

    @Test(groups = { "g1" })
    public void g1Test() {
        sleep();
        LOG.info("g1Test()");
    }

    @BeforeMethod(onlyForGroups = { "g2" }, alwaysRun = false)
    public void setUpG2() {
        sleep();
        LOG.info("BeforeMethod G2");
    }

    @Test(groups = { "g2" })
    public void g2Test() {
        sleep();
        LOG.info("g2Test()");
    }

    private void sleep() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

The output is

BeforeMethod G1
g1Test()
BeforeMethod G2
g2Test()

You can use the dependsOnMethods or dependsOnGroups annotation parameter in your other test methods:

@Test(dependsOnMethods = {"stopTestingIfThisFailed"})
public void testAnotherTestMehtod()  {

}

JavaDoc of the dependsOnMethods parameter:

The list of methods this method depends on. There is no guarantee on the order on which the methods depended upon will be run, but you are guaranteed that all these methods will be run before the test method that contains this annotation is run. Furthermore, if any of these methods was not a SUCCESS, this test method will not be run and will be flagged as a SKIP. If some of these methods have been overloaded, all the overloaded versions will be run.

See https://testng.org/doc/documentation-main.html#dependent-methods

Try setting an implicit wait of maybe 10 seconds.

gmail.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

Or set an explicit wait. An explicit waits is code you define to wait for a certain condition to occur before proceeding further in the code. In your case, it is the visibility of the password input field. (Thanks to ainlolcat's comment)

WebDriver gmail= new ChromeDriver();
gmail.get("https://www.gmail.co.in"); 
gmail.findElement(By.id("Email")).sendKeys("abcd");
gmail.findElement(By.id("next")).click();
WebDriverWait wait = new WebDriverWait(gmail, 10);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("Passwd")));
gmail.findElement(By.id("Passwd")).sendKeys("xyz");

Explanation: The reason selenium can't find the element is because the id of the password input field is initially Passwd-hidden. After you click on the "Next" button, Google first verifies the email address entered and then shows the password input field (by changing the id from Passwd-hidden to Passwd). So, when the password field is still hidden (i.e. Google is still verifying the email id), your webdriver starts searching for the password input field with id Passwd which is still hidden. And hence, an exception is thrown.

It's the number of tests that are run at the same time. It takes up more slots in the grid because is uses one grid slot per test run. It's like saying how many cars in a fleet that you want on the highway at the same time. If you say you want them to take up three lanes, then they will take up no more than three lanes, but it will take longer to get all cars through. If you say five lanes, then they will take up no more than five lanes, but it will take less time to get all cars through.

JUnit 4.8 supports grouping:

public interface SlowTests {}
public interface IntegrationTests extends SlowTests {}
public interface PerformanceTests extends SlowTests {}

And then...

public class AccountTest {

    @Test
    @Category(IntegrationTests.class)
    public void thisTestWillTakeSomeTime() {
        ...
    }

    @Test
    @Category(IntegrationTests.class)
    public void thisTestWillTakeEvenLonger() {
        ...
    }

    @Test
    public void thisOneIsRealFast() {
        ...
    }
}

And lastly,

@RunWith(Categories.class)
@ExcludeCategory(SlowTests.class)
@SuiteClasses( { AccountTest.class, ClientTest.class })
public class UnitTestSuite {}

Taken from here: https://community.oracle.com/blogs/johnsmart/2010/04/25/grouping-tests-using-junit-categories-0

Also, Arquillian itself supports grouping: https://github.com/weld/core/blob/master/tests-arquillian/src/test/java/org/jboss/weld/tests/Categories.java

The problem is you have the same method name between A and B.

When TestNG is looking for configuration methods, it won't find the annotation on the setUp() method of B. In every case, you'll have to annotate your method in B because TestNG is not able to find configuration methods without annotation.

You can keep the work around you use, or you can rename one configuration method. setUp is no more mandatory.

But we can suppose it is an issue which can be solved by TestNG too. So, you should open a ticket on the project: http://github.com/cbeust/testng