How to use getUploadThroughput method of org.openqa.selenium.chromium.ChromiumNetworkConditions class

You are using drive.quit() instead of driver.close(). quit closes the driver and window. This is why you get the child error because the driver is no longer available. close(), will close the window but keep the driver alive. I would only use quit at the very end of your program (like a cleanup routine). I ran your code (modified below) on my machine and did not have any errors. Also, you should put this around a try/catch so that you can see what is going on. I found with selenium that the try/catch sometimes shows errors that your console does not show. I had something similar with an earlier project and the try catch assisted with debugging.

package com.kurt.stackoverflow.selenium;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
public class Gecko_Driver
{
    public static void main(String[] args) throws InterruptedException{

    try
    {
       System.setProperty("webdriver.gecko.driver","C:\\tmp\\geckodriver-v0.11.1-win64\\geckodriver.exe");
       WebDriver driver = new FirefoxDriver();
       driver.get("http://www.toolsqa.com");
       Thread.sleep(5000);
       driver.close();
    }
    catch (Exception e)
    {
       System.out.println("Caught message " + e.getMessage());
       driver.close();
    }
}

}

To work with Selenium 3.x, Mozila Firefox 52.x you need to download the latest gecko driver from here and provide the absolute path of gecko driver as follows:

//Mozila Firefox
System.setProperty("webdriver.gecko.driver", "C:\\your_directory\\geckodriver.exe");
WebDriver driver =  new FirefoxDriver();
driver.manage().window().maximize();
driver.get("http:\\gmail.com");
driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
driver.findElement(By.id("Email")).sendKeys("your_id");

You can switch between windows as below:

// Store the current window handle
String winHandleBefore = driver.getWindowHandle();

// Perform the click operation that opens new window

// Switch to new window opened
for(String winHandle : driver.getWindowHandles()){
    driver.switchTo().window(winHandle);
}

// Perform the actions on new window

// Close the new window, if that window no more required
driver.close();

// Switch back to original browser (first window)
driver.switchTo().window(winHandleBefore);

// Continue with original browser (first window)

To build on the answer of stevecross, note that the suggested expression is pretty lenient. For example, it will match this:

String xyz =" ID: VERSION: "

You can be more strict in your matching if needed. Say, if you need to ensure non-blank words, use + instead of * like this:

assertThat(xyz).matches("[A-Za-z]+ +ID: [0-9]+ +VERSION: [0-9]+");

And if you need to have exactly three spaces between the key-value pairs, then add {3} to a class of characters including only space ([ ]), like this:

assertThat(xyz).matches("[A-Za-z]*[ ]{3}ID: [0-9]*[ ]{3}VERSION: [0-9]*");

I find online regex evaluators helpful. See for example this one: https://regex101.com/

You can use WebDriverWait. From docs example:

 (new WebDriverWait(driver, 10)).until(new ExpectedCondition<Boolean>() {
            public Boolean apply(WebDriver d) {
                return d.findElement(...).getText().length() != 0;
            }
        });

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
    } 
}

Use the last modified to sort the directories and get the latest one

    File dir = new File("path");
    File[] files = dir.listFiles();
    File lastModified = Arrays.stream(files).filter(File::isDirectory).max(Comparator.comparing(File::lastModified)).orElse(null);
    System.out.println(lastModified);

using for loop

    File dir = new File("/path");
    File max = null;
    for (File file : dir.listFiles()) {
        if (file.isDirectory() && (max == null || max.lastModified() < file.lastModified())) {
            max = file;
        }
    }

Try this

System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
System.setProperty("selenide.browser", "Chrome");
open("http://google.com");

You can find some documentation here.

Yes, it's possible

driver.manage().deleteAllCookies();

Call it right after you are creating the new WebDriver instance.

WebDriver driver = new ChromeDriver();
driver.manage().deleteAllCookies();

You can also delete the cookies one by one

Set<Cookie> allCookies = driver.manage().getCookies();
for (Cookie cookie : allCookies) {
    driver.manage().deleteCookieNamed(cookie.getName());
}