How to use onTestFailure method of org.testng.TestListenerAdapter class

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.

Give in. Make it a class, add a private constructor, use introspection in the unit test. Makes the code ten times as big. For a String constant.

This is the correct approach in general. You really do not want to create a "Constants" interface. The private constructor is needed to ensure that users do not inadvertently extend or instantiate an object that should not be instantiated.

How to add test coverage to a private constructor?

Create a list of exceptions. But doing this for each project may lead to long lists and invites people to add exceptions even for important stuff.

Too much work.

Deactivate rules. Now I would prefer not to tamper with the default profiles, because that may mean a lot of work on Sonarqube upgrades.

As you said... bad idea.

Create a profile that inherits from the default and overwrites things. It turns out that when you inherit from a profile you cannot deactivate rules. You can only add additional rules and change the configuration of rules (to lower their severity).

If you set the severity to "info" it will remove it from the Technical Debt calculation. I had to do that with squid:S1213 which is raised when I sort using the default order specified by Eclipse.

Assuming your wrapper version is the same as your installed version. The problem stems from Netbeans not supporting Gradle 6 (see gradle plugin for netbeans).

Best option is simply to switch to Gradle 5 (which is supported). To do so you need to update the wrapper properties from gradle/wrapper/gradle-wrapper.properties. Modify the distributionUrl value, and change the end from gradle-6.x-bin.zip to some other version, like gradle-5.2.1-bin.zip.

Then run a build again so it would download the wrapper and try NetBeans again.

From what I can tell you build.gradle should work in version 5 as well, so no need to modify it.

Faced the same problem. Here is how I resolved it. This seems to be a bug with the new version of the Chrome driver. Using the previous version of the driver (20.0.1133.0) solved this issue for me.

Check the driver download page.

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

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.

In my project when I set reuseForks=true then i have to increase the forkCount to number of test classes. Otherwise, It is throwing illegalargument exception.

From the stack trace, it appears something inside your code is causing the exception to be thrown, but only when forks are reused. This implies that the different tests are somehow not isolated from each other, and therefore running one after the other within the same test process violates some assumptions. For example, perhaps one test initializes some global state like a singleton, and then that global state isn't correct for the next test run within that process.

Also, If I set reuseForks=false then it also work fine.

By setting reuseForks to false, any problems related to mutating global state like this get bypassed. The process gets torn down at the end of the test run, and a new process with fresh state gets started for the next test run.

At this point, the path forward is highly dependent on the specifics of your codebase and how its tests are implemented. I see 2 options:

1. Debug your tests looking for problems of global state like I described. Attaching a breakpoint right before this exception would probably give you a strong hint.
2. If you already know that the codebase relies on some global state, and it isn't feasible to change that code quickly, then just stick with reuseForks set to false. In many cases, the extra process teardown and startup won't cause a noticeable performance impact for your overall test run.

By convention, the test classes must also end with "Test". If they don't, you should add

<includes>
    <include>**/*.java</include>
</includes>

to your surefire config (or whatever includes work for you and your file naming scheme).

If I have class A and a class B extends A and both have one @BeforeMethod method, then will the parent's (A) run before the child's (B) [...]

Yes, they will.

@BeforeMethod methods will run in inheritance order - the highest superclass first, then going down the inheritance chain. @AfterMethod methods run in reverse order (up the inheritance chain).

Note, however, that the ordering of multiple annotated methods within one class is not guaranteed (so it's best to avoid that).

Reading the code, this seems to have been the case in all versions of TestNG, however it was only documented in October 2016:

The annotations above will also be honored (inherited) when placed on a superclass of a TestNG class. This is useful for example to centralize test setup for multiple test classes in a common superclass.

In that case, TestNG guarantees that the "@Before" methods are executed in inheritance order (highest superclass first, then going down the inheritance chain), and the "@After" methods in reverse order (going up the inheritance chain).

See documentation-main.html on GitHub, or the online documentation.

Disclaimer: It was me who wrote and submitted this addition to the docs.