Driver Information

/**
 * WebDriverInfo implementation that provides metadata about ChromeDriver.
 * Used by WebDriver managers for automatic driver selection and capability matching.
 */
public class ChromeDriverInfo implements WebDriverInfo {
    
    /**
     * Returns the display name for Chrome browser.
     * @return "Chrome" as the human-readable browser name
     */
    public String getDisplayName();
    
    /**
     * Returns the canonical capabilities that identify Chrome browser.
     * @return ImmutableCapabilities with browser name set to "chrome"
     */
    public Capabilities getCanonicalCapabilities();
    
    /**
     * Checks if the given capabilities are supported by ChromeDriver.
     * @param capabilities The capabilities to check for support
     * @return True if ChromeDriver can handle these capabilities, false otherwise
     */
    public boolean isSupporting(Capabilities capabilities);
    
    /**
     * Checks if ChromeDriver is available on the current system.
     * @return True if ChromeDriver executable can be found and started, false otherwise
     */
    public boolean isAvailable();
    
    /**
     * Returns the maximum number of simultaneous sessions this driver can handle.
     * Based on available processor cores plus one.
     * @return Maximum concurrent Chrome sessions supported
     */
    public int getMaximumSimultaneousSessions();
    
    /**
     * Creates a ChromeDriver instance with the given capabilities if supported.
     * @param capabilities The capabilities for the new driver session
     * @return Optional containing ChromeDriver if creation successful, empty otherwise
     * @throws SessionNotCreatedException If session creation fails
     */
    public Optional<WebDriver> createDriver(Capabilities capabilities) throws SessionNotCreatedException;
}

/**
 * Returns the display name for Chrome browser.
 * Used in test reports, logs, and user interfaces.
 * @return "Chrome" as the human-readable browser name
 */
public String getDisplayName();

ChromeDriverInfo info = new ChromeDriverInfo();
System.out.println("Browser: " + info.getDisplayName()); // Output: Browser: Chrome

/**
 * Returns the canonical capabilities that identify Chrome browser.
 * Contains the minimal capability set for Chrome identification.
 * @return ImmutableCapabilities with browser name set to "chrome"
 */
public Capabilities getCanonicalCapabilities();

ChromeDriverInfo info = new ChromeDriverInfo();
Capabilities canonical = info.getCanonicalCapabilities();
System.out.println("Browser name: " + canonical.getBrowserName()); // Output: chrome

/**
 * Checks if the given capabilities are supported by ChromeDriver.
 * Looks for Chrome-specific capability markers:
 * - browserName equals "chrome"
 * - presence of "chromeOptions" capability
 * - presence of "goog:chromeOptions" capability
 * @param capabilities The capabilities to check for support
 * @return True if ChromeDriver can handle these capabilities, false otherwise
 */
public boolean isSupporting(Capabilities capabilities);

ChromeDriverInfo info = new ChromeDriverInfo();

// Test Chrome capabilities
DesiredCapabilities chromeCapabilities = new DesiredCapabilities();
chromeCapabilities.setBrowserName("chrome");
boolean supports = info.isSupporting(chromeCapabilities);
System.out.println("Supports Chrome: " + supports); // Output: true

// Test with ChromeOptions
ChromeOptions options = new ChromeOptions();
options.setHeadless(true);
boolean supportsOptions = info.isSupporting(options);
System.out.println("Supports ChromeOptions: " + supportsOptions); // Output: true

// Test Firefox capabilities  
DesiredCapabilities firefoxCapabilities = new DesiredCapabilities();
firefoxCapabilities.setBrowserName("firefox");
boolean supportsFirefox = info.isSupporting(firefoxCapabilities);
System.out.println("Supports Firefox: " + supportsFirefox); // Output: false

/**
 * Checks if ChromeDriver is available on the current system.
 * Attempts to create a default ChromeDriverService to verify availability.
 * @return True if ChromeDriver executable can be found and started, false otherwise
 */
public boolean isAvailable();

ChromeDriverInfo info = new ChromeDriverInfo();

if (info.isAvailable()) {
    System.out.println("ChromeDriver is available");
    // Proceed with Chrome testing
} else {
    System.out.println("ChromeDriver not found - install ChromeDriver or set webdriver.chrome.driver property");
    // Fall back to other browsers or skip Chrome tests
}

/**
 * Returns the maximum number of simultaneous sessions this driver can handle.
 * Calculated as the number of available processor cores plus one.
 * @return Maximum concurrent Chrome sessions supported
 */
public int getMaximumSimultaneousSessions();

ChromeDriverInfo info = new ChromeDriverInfo();
int maxSessions = info.getMaximumSimultaneousSessions();
System.out.println("Max Chrome sessions: " + maxSessions);

// Use for parallel test execution planning
if (maxSessions >= 4) {
    // Run tests in parallel
    System.out.println("Running tests with " + maxSessions + " parallel Chrome instances"); 
} else {
    // Run tests sequentially
    System.out.println("Limited to sequential Chrome testing");
}

/**
 * Creates a ChromeDriver instance with the given capabilities if supported.
 * Validates capabilities and system availability before attempting creation.
 * @param capabilities The capabilities for the new driver session
 * @return Optional containing ChromeDriver if creation successful, empty otherwise
 * @throws SessionNotCreatedException If session creation fails
 */
public Optional<WebDriver> createDriver(Capabilities capabilities) throws SessionNotCreatedException;

import java.util.Optional;

ChromeDriverInfo info = new ChromeDriverInfo();

// Create driver with basic capabilities
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setBrowserName("chrome");

Optional<WebDriver> driverOpt = info.createDriver(capabilities);
if (driverOpt.isPresent()) {
    WebDriver driver = driverOpt.get();
    driver.get("https://example.com");
    System.out.println("Page title: " + driver.getTitle());
    driver.quit();
} else {
    System.out.println("Failed to create Chrome driver");
}

// Create driver with ChromeOptions
ChromeOptions options = new ChromeOptions();
options.setHeadless(true);
options.addArguments("--no-sandbox");

try {
    Optional<WebDriver> chromeDriver = info.createDriver(options);
    if (chromeDriver.isPresent()) {
        // Driver created successfully
        WebDriver driver = chromeDriver.get();
        // Use driver...
        driver.quit();
    }
} catch (SessionNotCreatedException e) {
    System.err.println("Failed to create Chrome session: " + e.getMessage());
}

import org.openqa.selenium.WebDriverInfo;
import java.util.ServiceLoader;
import java.util.List;
import java.util.stream.Collectors;

public class DriverSelector {
    public static WebDriver selectBestDriver(Capabilities desiredCapabilities) {
        // Load all available WebDriverInfo implementations
        ServiceLoader<WebDriverInfo> loader = ServiceLoader.load(WebDriverInfo.class);
        
        List<WebDriverInfo> availableDrivers = loader.stream()
            .map(ServiceLoader.Provider::get)
            .filter(info -> info.isAvailable() && info.isSupporting(desiredCapabilities))
            .collect(Collectors.toList());
            
        // Find ChromeDriverInfo specifically
        Optional<WebDriverInfo> chromeInfo = availableDrivers.stream()
            .filter(info -> "Chrome".equals(info.getDisplayName()))
            .findFirst();
            
        if (chromeInfo.isPresent()) {
            Optional<WebDriver> driver = chromeInfo.get().createDriver(desiredCapabilities);
            if (driver.isPresent()) {
                return driver.get();
            }
        }
        
        throw new RuntimeException("No suitable Chrome driver found");
    }
}

// Usage
DesiredCapabilities caps = new DesiredCapabilities();
caps.setBrowserName("chrome");
WebDriver driver = DriverSelector.selectBestDriver(caps);

import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;

public class CrossBrowserTest {
    private WebDriver driver;
    private ChromeDriverInfo chromeInfo = new ChromeDriverInfo();
    
    @BeforeMethod
    public void setupDriver() {
        if (chromeInfo.isAvailable()) {
            ChromeOptions options = new ChromeOptions();
            if (isHeadlessEnvironment()) {
                options.setHeadless(true);
            }
            
            Optional<WebDriver> chromeDriver = chromeInfo.createDriver(options);
            if (chromeDriver.isPresent()) {
                driver = chromeDriver.get();
            } else {
                throw new RuntimeException("Failed to create Chrome driver");
            }
        } else {
            throw new RuntimeException("Chrome driver not available");
        }
    }
    
    @AfterMethod
    public void teardownDriver() {
        if (driver != null) {
            driver.quit();
        }
    }
    
    private boolean isHeadlessEnvironment() {
        return System.getenv("CI") != null || System.getProperty("headless") != null;
    }
}

// WebDriver information interface
interface WebDriverInfo {
    String getDisplayName();
    Capabilities getCanonicalCapabilities();
    boolean isSupporting(Capabilities capabilities);
    boolean isAvailable();
    int getMaximumSimultaneousSessions();
    Optional<WebDriver> createDriver(Capabilities capabilities) throws SessionNotCreatedException;
}

// Capability types
interface Capabilities {
    String getBrowserName();
    Object getCapability(String capabilityName);
    // ... other capability methods
}

class ImmutableCapabilities implements Capabilities {
    public ImmutableCapabilities(String key, Object value);
    // ... implementation methods
}

class DesiredCapabilities implements Capabilities {
    public void setBrowserName(String browserName);
    public void setCapability(String key, Object value);
    // ... other methods
}

// Optional wrapper for driver creation
class Optional<T> {
    public static <T> Optional<T> empty();
    public static <T> Optional<T> of(T value);
    public boolean isPresent();
    public T get();
}

// Exception types
class SessionNotCreatedException extends WebDriverException {
    public SessionNotCreatedException(String message);
    public SessionNotCreatedException(String message, Throwable cause);
}