How to use Interface Coordinates class of org.openqa.selenium.interactions package

elementToBeClickable is used for checking an element is visible and enabled such that you can click it.

ExpectedConditions.elementToBeClickable returns WebElement if expected condition is true otherwise it will throw TimeoutException, It never returns null.

So if your using ExpectedConditions.elementToBeClickable to find an element which will always gives you the clickable element, so no need to check for null condition, you should try as below :-

WebDriverWait wait = new WebDriverWait(Scenario1Test.driver, 10); 
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.xpath("(//div[@id='brandSlider']/div[1]/div/div/div/img)[50]")));
element.click();

As you are saying element.click() passes both on link and label that's doesn't mean element is not clickable, it means returned element clicked but may be there is no event performs on element by click action.

Note:- I'm suggesting you always try first to find elements by id, name, className and other locator. if you faced some difficulty to find then use cssSelector and always give last priority to xpath locator because it is slower than other locator to locate an element.

Hope it helps you..:)

    String base = driver.getWindowHandle();

    Set <String> set = driver.getWindowHandles();

    set.remove(base);
    assert set.size()==1;

    driver.switchTo().window(set.toArray(new String[0]));

    driver.close();
    driver.switchTo().window(base);

This works for me...

It's not possible directly via the API, so you'll have to use a script injection.

The best way to determine if an element is visible in the viewport is to get the element at the supposed location with document.elementFromPoint. It returns null if it's not within the viewport and your element or a descendant if it is.

public static Boolean isVisibleInViewport(WebElement element) {
  WebDriver driver = ((RemoteWebElement)element).getWrappedDriver();

  return (Boolean)((JavascriptExecutor)driver).executeScript(
      "var elem = arguments[0],                 " +
      "  box = elem.getBoundingClientRect(),    " +
      "  cx = box.left + box.width / 2,         " +
      "  cy = box.top + box.height / 2,         " +
      "  e = document.elementFromPoint(cx, cy); " +
      "for (; e; e = e.parentElement) {         " +
      "  if (e === elem)                        " +
      "    return true;                         " +
      "}                                        " +
      "return false;                            "
      , element);
}

There are several places where you can get the source from.You can try

String pageSource=driver.findElement(By.tagName("body")).getText();

and see what comes up.

Generally you do not need to wait for the page to load.Selenium does that automatically,unless you have separate sections of Javascript/Ajax.

You might want to add what are the differences that you are seeing, so that we can understand what you really mean.

Webdriver does not render the page on its own,it just renders it as the browser sees it.

For RemoteWebDriver you have to set file detector driver.setFileDetector(new LocalFileDetector());. Your code:

public static void uploadSampleImage(StaticSeleniumDriver driver)
{
    driver.setFileDetector(new LocalFileDetector());
    File file = new File(System.getProperty("user.dir") + "/resources/images/" + SAMPLE_DOCUMENT_FILE_NAME);
    Utils.Log("file exists: " + file.exists());

    String imagePath = file.getAbsolutePath();
    WebElement input = driver.findElement(By.name("file"));
    input.sendKeys(imagePath);
}

You can do this by finding the x and y coordinates of the checkbox in reCAPTCHA and click the element.

WebElement captcha = driver.findElement(By.xpath("html/body/div[1]/div[3]/div[2]/form/div[5]/div"));
        builder.moveToElement(captcha, 50, 30).click().build().perform();

It depends.

When using a static field, there is only a single instance of that field in the JVM. It refers to one specific address in memory. Unlike the field of an object which refers to a field of a specific object and for each object there is a unique address in memory for that field.

When using a ThreadLocal each thread has its own instance of the variable.

So by using static WebDriver driver you have exactly one webdriver for all tests and all threads. By using static ThreadLocal<WebDriver> driver you have exactly one webdriver for each thread, effectively sharing the webdriver between scenarios that are executed on that thread.

When executing tests in parallel there are multiple threads executing scenarios so a single webdriver would be a problem. Scenarios running in parallel would make the webdriver do different things at the same time or they'd have to wait for the webdriver to be available, making them effectively run serially again.

So if a webdriver is to be shared between scenarios and if those scenarios run in parallel you have to use a ThreadLocal.

However it appears that are unfamiliar with programming concurrent systems. So you may want to consider a different approach. Rather then sharing the webdriver between scenarios, consider starting a new webdriver in each scenario instead. This is much safer and from a test perspective much cleaner because each scenario starts without any state from the previous scenario.

This means you now have the problem of sharing information between steps. You were using a static field to share to share the webdriver. But you can't use use static fields because there are now multiple threads running.

To solve this problem Cucumber supports dependency injection. The easiest to use is probably cucumber-pico. When using dependency injection cucumber will instantiate each step definition class for each scenario with a isolated set of dependencies.

    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-picocontainer</artifactId>
        <version>${cucumber.version}</version>
        <scope>test</scope>
    </dependency>

So for example when your step definitions depend on a WebDriverFactory, cucumber will instantiate a WebDriverFactory for you and instantiate both StepDefinition and OtherStepDefinition with the same factory.

public class StepDefinition {

    private final WebDriverFactory webdriverFactory;

    public StepDefinitions(WebDriverFactory webdriverFactory) {
        this.webdriverFactory = webdriverFactory;
    }

    @Given("I do a thing with a webdriver")
    public void useTheWebDriver() {
        // get the webdriver from the factory and use it
    }

}

public class OtherStepDefinition {

    private final WebDriverFactory webdriverFactory; // Same instance as in StepDefinition

    public OtherStepDefinition(WebDriverFactory webdriverFactory) {
        this.webdriverFactory = webdriverFactory; 
    }

    @Given("I do another thing with a webdriver")
    public void useTheWebDriver() {
        // get the webdriver from the factory and use it
    }

}

Then in the web driver factory you keep a reference to the webdriver for use in both step definitions.

public class WebDriverFactory implements Startable {

    private WebDriver driver;

    public setDriver(String browser) {
        // create the web driver here 
    }

    public static synchronized WebDriver getDriver(){
        return driver;
    }

    public void start() { 
      // do nothing
    } 
    
    public void stop() { 
       // stop web driver if it was created
    } 
}

I got it to work with Firefox webdriver by the following:

profile.SetPreference("network.automatic-ntlm-auth.trusted-uris", "google.com");
driver = new FirefoxDriver(profile);

driver.Navigate().GoToUrl("http://user:pwd@google.com");

You need to call ignoring with an exception to ignore while the WebDriver will wait.

FluentWait<WebDriver> fluentWait = new FluentWait<>(driver)
        .withTimeout(30, TimeUnit.SECONDS)
        .pollingEvery(200, TimeUnit.MILLISECONDS)
        .ignoring(NoSuchElementException.class);

See the documentation of FluentWait for more information. But beware that this condition is already implemented in ExpectedConditions, so you should use:

WebElement element = (new WebDriverWait(driver, 10))
   .until(ExpectedConditions.elementToBeClickable(By.id("someid")));

*Fewer versions of Selenium:

withTimeout(long, TimeUnit) has become withTimeout(Duration)
pollingEvery(long, TimeUnit) has become pollingEvery(Duration)

So the code will look as such:

FluentWait<WebDriver> fluentWait = new FluentWait<>(driver)
        .withTimeout(Duration.ofSeconds(30)
        .pollingEvery(Duration.ofMillis(200)
        .ignoring(NoSuchElementException.class);

A basic tutorial for waiting can be found here.