Selenium Safari Driver

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-safari-driver</artifactId>
    <version>3.141.59</version>
</dependency>

import org.openqa.selenium.safari.SafariDriver;
import org.openqa.selenium.safari.SafariOptions;
import org.openqa.selenium.safari.SafariDriverService;

import org.openqa.selenium.safari.SafariDriver;
import org.openqa.selenium.safari.SafariOptions;
import org.openqa.selenium.WebDriver;

// Basic Safari driver initialization
WebDriver driver = new SafariDriver();

// With Safari options
SafariOptions options = new SafariOptions();
options.setUseTechnologyPreview(true);
options.setAutomaticInspection(false);
WebDriver driver = new SafariDriver(options);

// Navigate and interact
driver.get("https://example.com");
String title = driver.getTitle();
driver.quit();

public class SafariDriver extends RemoteWebDriver {
    /**
     * Initializes a new SafariDriver with default SafariOptions.
     */
    public SafariDriver();
    
    /**
     * Initializes a new SafariDriver using SafariOptions.
     * @param safariOptions Configuration options for the driver
     */
    public SafariDriver(SafariOptions safariOptions);
    
    /**
     * Initializes a new SafariDriver with preconfigured service.
     * @param safariService Preconfigured SafariDriverService
     */
    public SafariDriver(SafariDriverService safariService);
    
    /**
     * Full constructor with both service and options.
     * @param safariService Preconfigured SafariDriverService
     * @param safariOptions Configuration options for the driver
     */
    public SafariDriver(SafariDriverService safariService, SafariOptions safariOptions);
    
    /**
     * @deprecated Use SafariDriver(SafariOptions) instead
     * @param desiredCapabilities Capabilities requested of the driver
     */
    @Deprecated
    public SafariDriver(Capabilities desiredCapabilities);
    
    /**
     * File detection is not supported in Safari.
     * @throws WebDriverException Always throws, as file detection is not supported
     */
    @Override
    public void setFileDetector(FileDetector detector);
    
    /**
     * Opens a new window or tab without switching to it.
     * This method uses Safari-specific WebDriver commands to create windows.
     * @param type The type of window to open (TAB or WINDOW)
     * @return The window handle of the new window
     */
    @Beta
    public String newWindow(WindowType type);
    
    public enum WindowType {
        TAB, WINDOW
    }
}

public class SafariOptions extends MutableCapabilities {
    /** Browser name constant for Safari Technology Preview */
    public static final String SAFARI_TECH_PREVIEW = "Safari Technology Preview";
    
    /** @deprecated Use constructor methods instead */
    @Deprecated
    public static final String CAPABILITY = "safari.options";
    
    /**
     * Default constructor for SafariOptions.
     */
    public SafariOptions();
    
    /**
     * Initialize SafariOptions from existing capabilities.
     * @param source Existing capabilities to copy from
     */
    public SafariOptions(Capabilities source);
    
    /**
     * Factory method to create SafariOptions from capabilities.
     * @param capabilities Capabilities to convert
     * @return New SafariOptions instance
     */
    public static SafariOptions fromCapabilities(Capabilities capabilities);
    
    /**
     * Merge additional capabilities into these options.
     * @param extraCapabilities Additional capabilities to merge
     * @return This SafariOptions instance for chaining
     */
    public SafariOptions merge(Capabilities extraCapabilities);
    
    /**
     * Enable or disable automatic inspection.
     * @param automaticInspection Whether to enable automatic inspection
     * @return This SafariOptions instance for chaining
     */
    public SafariOptions setAutomaticInspection(boolean automaticInspection);
    
    /**
     * Enable or disable automatic profiling.
     * @param automaticProfiling Whether to enable automatic profiling
     * @return This SafariOptions instance for chaining
     */
    public SafariOptions setAutomaticProfiling(boolean automaticProfiling);
    
    /**
     * Configure use of Safari Technology Preview.
     * @param useTechnologyPreview Whether to use Safari Technology Preview
     * @return This SafariOptions instance for chaining
     */
    public SafariOptions setUseTechnologyPreview(boolean useTechnologyPreview);
    
    /**
     * Set proxy configuration.
     * @param proxy Proxy configuration to use
     * @return This SafariOptions instance for chaining
     */
    public SafariOptions setProxy(Proxy proxy);
    
    /**
     * Get current automatic inspection setting.
     * @return Whether automatic inspection is enabled
     */
    public boolean getAutomaticInspection();
    
    /**
     * Get current automatic profiling setting.
     * @return Whether automatic profiling is enabled
     */
    public boolean getAutomaticProfiling();
    
    /**
     * Get current technology preview setting.
     * @return Whether Safari Technology Preview is enabled
     */
    public boolean getUseTechnologyPreview();
    
    /**
     * Set a capability with special handling for technology preview.
     * @param key Capability key
     * @param value Capability value
     */
    @Override
    public void setCapability(String key, Object value);
    
    /**
     * Set a boolean capability with special handling for technology preview.
     * @param key Capability key  
     * @param value Boolean capability value
     */
    @Override
    public void setCapability(String key, boolean value);
    
    /**
     * Serialize options to map representation.
     * @return Map representation of these options
     */
    public Map<String, Object> asMap();
}

public class SafariDriverService extends DriverService {
    /**
     * Create a service with default options.
     * @return New SafariDriverService instance
     */
    public static SafariDriverService createDefaultService();
    
    /**
     * Create a service with specified SafariOptions.
     * @param options SafariOptions to configure the service
     * @return New SafariDriverService instance
     */
    public static SafariDriverService createDefaultService(SafariOptions options);
    
    /**
     * Create a service from capabilities.
     * @param caps Capabilities to configure the service
     * @return New SafariDriverService instance
     */
    public static SafariDriverService createDefaultService(Capabilities caps);
    
    /**
     * Wait for the driver service to become available.
     */
    @Override
    protected void waitUntilAvailable();
    
    public static class Builder extends DriverService.Builder<SafariDriverService, SafariDriverService.Builder> {
        /**
         * Score how well this builder supports the given capabilities.
         * @param capabilities Capabilities to score
         * @return Compatibility score
         */
        public int score(Capabilities capabilities);
        
        /**
         * Configure whether to use Safari Technology Preview.
         * @param useTechnologyPreview Whether to use Technology Preview
         * @return This builder instance for chaining
         */
        public SafariDriverService.Builder usingTechnologyPreview(boolean useTechnologyPreview);
        
        /**
         * Find the default Safari driver executable.
         * @return File representing the default executable
         */
        @Override
        protected File findDefaultExecutable();
        
        /**
         * Create command line arguments for the service.
         * @return List of command line arguments
         */
        @Override
        protected ImmutableList<String> createArgs();
        
        /**
         * Create the driver service instance.
         * @param exe Executable file
         * @param port Port number
         * @param args Command line arguments
         * @param environment Environment variables
         * @return New SafariDriverService instance
         */
        @Override
        protected SafariDriverService createDriverService(
            File exe, 
            int port, 
            ImmutableList<String> args, 
            ImmutableMap<String, String> environment
        );
    }
}

public class SafariDriverInfo implements WebDriverInfo {
    /**
     * Get the display name for this driver.
     * @return "Safari"
     */
    @Override
    public String getDisplayName();
    
    /**
     * Get the canonical capabilities for Safari.
     * @return Default Safari capabilities
     */
    @Override
    public Capabilities getCanonicalCapabilities();
    
    /**
     * Check if this driver supports the given capabilities.
     * @param capabilities Capabilities to check
     * @return Whether capabilities are supported
     */
    @Override
    public boolean isSupporting(Capabilities capabilities);
    
    /**
     * Check if Safari driver is available on this system.
     * @return Whether Safari driver is available
     */
    @Override
    public boolean isAvailable();
    
    /**
     * Get maximum simultaneous sessions supported.
     * @return 1 (Safari limitation)
     */
    @Override
    public int getMaximumSimultaneousSessions();
    
    /**
     * Create a Safari WebDriver instance.
     * @param capabilities Desired capabilities
     * @return Optional WebDriver instance
     */
    @Override
    public Optional<WebDriver> createDriver(Capabilities capabilities);
}

public class SafariTechPreviewDriverInfo implements WebDriverInfo {
    /**
     * Get the display name for this driver.
     * @return "Safari Technology Preview"
     */
    @Override
    public String getDisplayName();
    
    /**
     * Get the canonical capabilities for Safari Technology Preview.
     * @return Default Safari Technology Preview capabilities
     */
    @Override
    public Capabilities getCanonicalCapabilities();
    
    /**
     * Check if this driver supports the given capabilities.
     * @param capabilities Capabilities to check
     * @return Whether capabilities are supported
     */
    @Override
    public boolean isSupporting(Capabilities capabilities);
    
    /**
     * Check if Safari Technology Preview driver is available.
     * @return Whether Safari Technology Preview driver is available
     */
    @Override
    public boolean isAvailable();
    
    /**
     * Get maximum simultaneous sessions supported.
     * @return 1 (Safari limitation)
     */
    @Override
    public int getMaximumSimultaneousSessions();
    
    /**
     * Create a Safari Technology Preview WebDriver instance.
     * @param capabilities Desired capabilities
     * @return Optional WebDriver instance
     */
    @Override
    public Optional<WebDriver> createDriver(Capabilities capabilities);
}

public class ConnectionClosedException extends WebDriverException {
    /**
     * Create an exception for Safari driver connection failures.
     * @param message Error message describing the connection failure
     */
    public ConnectionClosedException(String message);
}

import org.openqa.selenium.safari.SafariDriver;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.By;

public class BasicSafariExample {
    public static void main(String[] args) {
        // Create Safari driver
        WebDriver driver = new SafariDriver();
        
        try {
            // Navigate to a page
            driver.get("https://www.example.com");
            
            // Find and interact with elements
            String title = driver.getTitle();
            System.out.println("Page title: " + title);
            
            // Find element and click
            driver.findElement(By.linkText("More information...")).click();
            
        } finally {
            driver.quit();
        }
    }
}

import org.openqa.selenium.safari.SafariDriver;
import org.openqa.selenium.safari.SafariOptions;
import org.openqa.selenium.WebDriver;

public class SafariTechPreviewExample {
    public static void main(String[] args) {
        // Configure Safari Technology Preview
        SafariOptions options = new SafariOptions();
        options.setUseTechnologyPreview(true);
        options.setAutomaticInspection(false);
        options.setAutomaticProfiling(false);
        
        // Create driver with Technology Preview
        WebDriver driver = new SafariDriver(options);
        
        try {
            driver.get("https://developer.mozilla.org");
            // Test modern web features
        } finally {
            driver.quit();
        }
    }
}

import org.openqa.selenium.safari.SafariDriver;
import org.openqa.selenium.safari.SafariDriverService;
import org.openqa.selenium.safari.SafariOptions;

public class CustomServiceExample {
    public static void main(String[] args) {
        // Build custom service
        SafariDriverService service = new SafariDriverService.Builder()
            .usingTechnologyPreview(true)
            .usingPort(4444)
            .build();
        
        SafariOptions options = new SafariOptions();
        options.setAutomaticInspection(true);
        
        SafariDriver driver = new SafariDriver(service, options);
        
        try {
            driver.get("https://webkit.org");
        } finally {
            driver.quit();
            service.stop();
        }
    }
}

import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.safari.SafariOptions;
import java.net.URL;

public class RemoteSafariExample {
    public static void main(String[] args) throws Exception {
        SafariOptions options = new SafariOptions();
        options.setUseTechnologyPreview(false);
        
        // Connect to remote Selenium Grid
        RemoteWebDriver driver = new RemoteWebDriver(
            new URL("http://localhost:4444/wd/hub"), 
            options
        );
        
        try {
            driver.get("https://selenium.dev");
        } finally {
            driver.quit();
        }
    }
}

// From org.openqa.selenium
interface WebDriver {
    void get(String url);
    String getCurrentUrl();
    String getTitle();
    void quit();
    WebElement findElement(By by);
    List<WebElement> findElements(By by);
    // ... other standard WebDriver methods
}

// From org.openqa.selenium.remote
class RemoteWebDriver implements WebDriver {
    protected RemoteWebDriver();
    public RemoteWebDriver(Capabilities capabilities);
    public RemoteWebDriver(URL remoteAddress, Capabilities capabilities);
    // ... WebDriver implementation methods
}

// From org.openqa.selenium
interface WebDriverInfo {
    String getDisplayName();
    Capabilities getCanonicalCapabilities();
    boolean isSupporting(Capabilities capabilities);
    boolean isAvailable();
    int getMaximumSimultaneousSessions();
    Optional<WebDriver> createDriver(Capabilities capabilities);
}

// From org.openqa.selenium.Capabilities
interface Capabilities {
    String getBrowserName();
    String getVersion();
    String getPlatform();
    boolean is(String capabilityName);
    Object getCapability(String capabilityName);
    Map<String, Object> asMap();
}

// From org.openqa.selenium.MutableCapabilities
class MutableCapabilities implements Capabilities {
    public void setCapability(String key, Object value);
    public void setCapability(String key, boolean value);
    public Capabilities merge(Capabilities other);
}

// From org.openqa.selenium.Proxy
class Proxy {
    public enum ProxyType { DIRECT, MANUAL, PAC, AUTODETECT, SYSTEM }
    public void setHttpProxy(String httpProxy);
    public void setSslProxy(String sslProxy);
    public void setFtpProxy(String ftpProxy);
    public void setNoProxy(String noProxy);
}

// From org.openqa.selenium.remote.service.DriverService
abstract class DriverService {
    public abstract void start();
    public abstract void stop();
    public abstract boolean isRunning();
    public abstract URL getUrl();
}

// From org.openqa.selenium.remote.service.DriverService.Builder
abstract class DriverService.Builder<DS extends DriverService, B extends DriverService.Builder<DS, B>> {
    public B usingPort(int port);
    public B withEnvironment(Map<String, String> environment);
    public B withLogFile(File logFile);
    public DS build();
}

// From org.openqa.selenium
class WebDriverException extends RuntimeException {
    public WebDriverException(String message);
    public WebDriverException(String message, Throwable cause);
}

// From org.openqa.selenium
class SessionNotCreatedException extends WebDriverException {
    public SessionNotCreatedException(String message);
    public SessionNotCreatedException(String message, Throwable cause);
}

// From org.openqa.selenium
class InvalidArgumentException extends WebDriverException {
    public InvalidArgumentException(String message);
    public InvalidArgumentException(String message, Throwable cause);
}

// From org.openqa.selenium.remote
class FileDetector {
    public File getLocalFile(CharSequence... keySequence);
}

// Java Standard Library Types
interface Optional<T> {
    static <T> Optional<T> empty();
    static <T> Optional<T> of(T value);
    boolean isPresent();
    T get();
}

interface List<E> extends Collection<E> {
    // Standard List interface methods
}

interface Map<K, V> {
    V put(K key, V value);
    V get(Object key);
    Set<K> keySet();
    Collection<V> values();
}

// From com.google.common.collect (Guava)
interface ImmutableList<E> extends List<E> {
    static <E> ImmutableList<E> of();
    static <E> ImmutableList<E> of(E element);
    // Immutable list implementation
}

interface ImmutableMap<K, V> extends Map<K, V> {
    static <K, V> ImmutableMap<K, V> of();
    static <K, V> ImmutableMap<K, V> of(K key, V value);
    // Immutable map implementation
}

// Java Standard Library
class File {
    public File(String pathname);
    public boolean exists();
    public String getAbsolutePath();
}

class URL {
    public URL(String spec);
    public String toString();
}

try {
    SafariDriver driver = new SafariDriver(options);
    // Driver operations
} catch (ConnectionClosedException e) {
    // Safari connection failed
    System.err.println("Safari connection failed: " + e.getMessage());
} catch (WebDriverException e) {
    // General WebDriver error
    System.err.println("WebDriver error: " + e.getMessage());
}