Browser Configuration

/**
 * Capabilities interface for browser configuration and feature detection
 * Provides access to browser name, version, platform, and custom capabilities
 */
interface Capabilities {
    /**
     * Get browser name
     * @return Browser name (e.g., "chrome", "firefox", "safari")
     */
    String getBrowserName();
    
    /**
     * Get browser version
     * @return Browser version string
     */
    String getBrowserVersion();
    
    /**
     * Get platform information
     * @return Platform enum value
     */
    Platform getPlatform();
    
    /**
     * Get platform name as string
     * @return Platform name (e.g., "Windows", "Mac", "Linux")
     */
    String getPlatformName();
    
    /**
     * Get specific capability value
     * @param capabilityName - Name of capability to retrieve
     * @return Capability value or null if not set
     */
    Object getCapability(String capabilityName);
    
    /**
     * Get all capability names
     * @return Set of all capability names
     */
    Set<String> getCapabilityNames();
    
    /**
     * Convert capabilities to Map
     * @return Map representation of all capabilities
     */
    Map<String, Object> asMap();
}

/**
 * MutableCapabilities class providing modifiable browser capabilities
 * Extends Capabilities with methods to set and modify capability values
 */
class MutableCapabilities implements Capabilities {
    /**
     * Create empty MutableCapabilities
     */
    MutableCapabilities();
    
    /**
     * Create MutableCapabilities from existing capabilities
     * @param other - Capabilities to copy from
     */
    MutableCapabilities(Capabilities other);
    
    /**
     * Create MutableCapabilities from Map
     * @param capabilities - Map of capability name-value pairs
     */
    MutableCapabilities(Map<String, ?> capabilities);
    
    /**
     * Set capability value
     * @param name - Capability name
     * @param value - Capability value
     * @return MutableCapabilities instance for chaining
     */
    MutableCapabilities setCapability(String name, Object value);
    
    /**
     * Merge capabilities from another Capabilities object
     * @param other - Capabilities to merge
     * @return MutableCapabilities instance for chaining
     */
    MutableCapabilities merge(Capabilities other);
}

/**
 * ImmutableCapabilities class providing read-only browser capabilities
 * Thread-safe implementation of Capabilities that cannot be modified after creation
 */
class ImmutableCapabilities implements Capabilities {
    /**
     * Create ImmutableCapabilities from Map
     * @param capabilities - Map of capability name-value pairs
     */
    ImmutableCapabilities(Map<String, ?> capabilities);
    
    /**
     * Create ImmutableCapabilities from key-value pairs
     * @param key - First capability name
     * @param value - First capability value
     * @param more - Additional key-value pairs (alternating keys and values)
     */
    ImmutableCapabilities(String key, Object value, Object... more);
}

/**
 * Proxy class for configuring proxy server settings
 * Supports HTTP, HTTPS, FTP, and SOCKS proxy configurations
 */
class Proxy {
    /**
     * Create Proxy with default settings
     */
    Proxy();
    
    /**
     * Set proxy type
     * @param proxyType - Type of proxy (DIRECT, MANUAL, PAC, AUTODETECT, SYSTEM)
     * @return Proxy instance for chaining
     */
    Proxy setProxyType(ProxyType proxyType);
    
    /**
     * Set HTTP proxy server
     * @param httpProxy - Proxy server in format "host:port"
     * @return Proxy instance for chaining
     */
    Proxy setHttpProxy(String httpProxy);
    
    /**
     * Set HTTPS/SSL proxy server
     * @param sslProxy - SSL proxy server in format "host:port"
     * @return Proxy instance for chaining
     */
    Proxy setSslProxy(String sslProxy);
    
    /**
     * Set FTP proxy server
     * @param ftpProxy - FTP proxy server in format "host:port"
     * @return Proxy instance for chaining
     */
    Proxy setFtpProxy(String ftpProxy);
    
    /**
     * Set SOCKS proxy server
     * @param socksProxy - SOCKS proxy server in format "host:port"
     * @return Proxy instance for chaining
     */
    Proxy setSocksProxy(String socksProxy);
    
    /**
     * Set hosts to bypass proxy
     * @param noProxy - Comma-separated list of hosts to bypass
     * @return Proxy instance for chaining
     */
    Proxy setNoProxy(String noProxy);
    
    /**
     * Set proxy authentication username
     * @param socksUsername - Username for SOCKS proxy authentication
     * @return Proxy instance for chaining
     */
    Proxy setSocksUsername(String socksUsername);
    
    /**
     * Set proxy authentication password
     * @param socksPassword - Password for SOCKS proxy authentication
     * @return Proxy instance for chaining
     */
    Proxy setSocksPassword(String socksPassword);
}

enum ProxyType {
    DIRECT, MANUAL, PAC, RESERVED_1, AUTODETECT, SYSTEM
}

import org.openqa.selenium.MutableCapabilities;
import org.openqa.selenium.ImmutableCapabilities;
import org.openqa.selenium.Platform;

// Create mutable capabilities
MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability("browserName", "chrome");
capabilities.setCapability("browserVersion", "latest");
capabilities.setCapability("platformName", "Windows 10");

// Add custom capabilities
capabilities.setCapability("enableVNC", true);
capabilities.setCapability("enableVideo", false);
capabilities.setCapability("screenResolution", "1920x1080x24");

// Create immutable capabilities
ImmutableCapabilities immutableCaps = new ImmutableCapabilities(
    "browserName", "firefox",
    "browserVersion", "91.0",
    "platformName", "Linux"
);

// Access capability values
String browserName = capabilities.getBrowserName();
String browserVersion = capabilities.getBrowserVersion();
Platform platform = capabilities.getPlatform();
Object customValue = capabilities.getCapability("enableVNC");

// Convert to map for inspection
Map<String, Object> capsMap = capabilities.asMap();
System.out.println("All capabilities: " + capsMap);

import org.openqa.selenium.Proxy;
import org.openqa.selenium.chrome.ChromeOptions;

// HTTP proxy configuration
Proxy proxy = new Proxy();
proxy.setProxyType(ProxyType.MANUAL);
proxy.setHttpProxy("proxy.company.com:8080");
proxy.setSslProxy("proxy.company.com:8080");

// Exclude certain hosts from proxy
proxy.setNoProxy("localhost,127.0.0.1,*.local");

// SOCKS proxy with authentication
Proxy socksProxy = new Proxy();
socksProxy.setProxyType(ProxyType.MANUAL);
socksProxy.setSocksProxy("socks.proxy.com:1080");
socksProxy.setSocksUsername("proxyuser");
socksProxy.setSocksPassword("proxypass");

// Apply proxy to browser options
ChromeOptions options = new ChromeOptions();
options.setCapability(CapabilityType.PROXY, proxy);

WebDriver driver = new ChromeDriver(options);

// Merge capabilities from multiple sources
MutableCapabilities baseCapabilities = new MutableCapabilities();
baseCapabilities.setCapability("browserName", "chrome");
baseCapabilities.setCapability("browserVersion", "latest");

MutableCapabilities testCapabilities = new MutableCapabilities();
testCapabilities.setCapability("enableVNC", true);
testCapabilities.setCapability("name", "My Test");

// Merge test capabilities into base
baseCapabilities.merge(testCapabilities);

// Platform-specific capabilities
MutableCapabilities windowsCapabilities = new MutableCapabilities();
windowsCapabilities.setCapability("platformName", "Windows 10");
windowsCapabilities.setCapability("browserName", "edge");

MutableCapabilities macCapabilities = new MutableCapabilities();
macCapabilities.setCapability("platformName", "macOS Big Sur");
macCapabilities.setCapability("browserName", "safari");

MutableCapabilities linuxCapabilities = new MutableCapabilities();
linuxCapabilities.setCapability("platformName", "Linux");
linuxCapabilities.setCapability("browserName", "firefox");

// Select capabilities based on environment
String osName = System.getProperty("os.name").toLowerCase();
MutableCapabilities platformCaps;
if (osName.contains("windows")) {
    platformCaps = windowsCapabilities;
} else if (osName.contains("mac")) {
    platformCaps = macCapabilities;
} else {
    platformCaps = linuxCapabilities;
}

// Cloud provider capabilities (Sauce Labs example)
MutableCapabilities sauceCapabilities = new MutableCapabilities();
sauceCapabilities.setCapability("platformName", "Windows 10");
sauceCapabilities.setCapability("browserName", "chrome");
sauceCapabilities.setCapability("browserVersion", "latest");
sauceCapabilities.setCapability("sauce:options", Map.of(
    "username", "your-username",
    "accessKey", "your-access-key",
    "name", "My Test Name",
    "build", "Build 123",
    "tags", Arrays.asList("tag1", "tag2")
));

// BrowserStack capabilities
MutableCapabilities browserStackCaps = new MutableCapabilities();
browserStackCaps.setCapability("os", "Windows");
browserStackCaps.setCapability("os_version", "10");
browserStackCaps.setCapability("browser", "Chrome");
browserStackCaps.setCapability("browser_version", "latest");
browserStackCaps.setCapability("bstack:options", Map.of(
    "userName", "your-username",
    "accessKey", "your-access-key",
    "projectName", "My Project",
    "buildName", "Build 123"
));

// Local Selenium Grid capabilities
MutableCapabilities gridCapabilities = new MutableCapabilities();
gridCapabilities.setCapability("browserName", "chrome");
gridCapabilities.setCapability("se:options", Map.of(
    "screenResolution", "1920x1080",
    "enableVNC", true,
    "enableVideo", true
));

// Use with RemoteWebDriver
RemoteWebDriver remoteDriver = new RemoteWebDriver(
    new URL("https://ondemand.saucelabs.com:443/wd/hub"),
    sauceCapabilities
);

// Mobile capabilities for Appium
MutableCapabilities mobileCapabilities = new MutableCapabilities();
mobileCapabilities.setCapability("platformName", "iOS");
mobileCapabilities.setCapability("platformVersion", "14.5");
mobileCapabilities.setCapability("deviceName", "iPhone 12");
mobileCapabilities.setCapability("browserName", "Safari");
mobileCapabilities.setCapability("automationName", "XCUITest");

// Android mobile capabilities
MutableCapabilities androidCapabilities = new MutableCapabilities();
androidCapabilities.setCapability("platformName", "Android");
androidCapabilities.setCapability("platformVersion", "11.0");
androidCapabilities.setCapability("deviceName", "Pixel 4");
androidCapabilities.setCapability("browserName", "Chrome");
androidCapabilities.setCapability("automationName", "UiAutomator2");

// Chrome mobile emulation
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.setExperimentalOption("mobileEmulation", Map.of(
    "deviceName", "iPhone X"
));

// Custom mobile emulation
Map<String, Object> deviceMetrics = Map.of(
    "width", 375,
    "height", 812,
    "pixelRatio", 3.0
);
chromeOptions.setExperimentalOption("mobileEmulation", Map.of(
    "deviceMetrics", deviceMetrics,
    "userAgent", "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X)"
));

// Performance logging capabilities
MutableCapabilities perfCapabilities = new MutableCapabilities();
LoggingPreferences logPrefs = new LoggingPreferences();
logPrefs.enable(LogType.PERFORMANCE, Level.INFO);
logPrefs.enable(LogType.BROWSER, Level.WARNING);
logPrefs.enable(LogType.DRIVER, Level.INFO);

perfCapabilities.setCapability(CapabilityType.LOGGING_PREFS, logPrefs);

// Network throttling (Chrome DevTools)
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.setExperimentalOption("useAutomationExtension", false);
chromeOptions.setExperimentalOption("excludeSwitches", Arrays.asList("enable-automation"));

// Custom performance flags
chromeOptions.addArguments("--enable-precise-memory-info");
chromeOptions.addArguments("--enable-benchmarking");
chromeOptions.addArguments("--enable-net-benchmarking");

perfCapabilities.merge(chromeOptions);

// Incognito/private browsing
ChromeOptions incognitoOptions = new ChromeOptions();
incognitoOptions.addArguments("--incognito");

FirefoxOptions privateOptions = new FirefoxOptions();  
privateOptions.addArguments("-private");

// Disable web security (for testing only)
ChromeOptions unsafeOptions = new ChromeOptions();
unsafeOptions.addArguments("--disable-web-security");
unsafeOptions.addArguments("--disable-features=VizDisplayCompositor");
unsafeOptions.addArguments("--allow-running-insecure-content");

// Certificate handling
MutableCapabilities certCapabilities = new MutableCapabilities();
certCapabilities.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);
certCapabilities.setCapability(CapabilityType.ACCEPT_SSL_CERTS, true);