### Standalone Configuration Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.en.md

Example of starting a standalone Selenium Grid with specified max sessions and port.

```APIDOC
## Standalone, setting max sessions and main port

### Description
Starts the Selenium Grid standalone component with configurations for maximum sessions and the main port.

### Method
java -jar

### Endpoint
selenium-server-<version>.jar standalone

### Parameters
#### Query Parameters
- **--max-sessions** (int) - Required - Maximum number of concurrent sessions.
- **--port** (int) - Required - The port on which the Grid will listen.

### Request Example
```
java -jar selenium-server-<version>.jar standalone --max-sessions 4 --port 4444
```
```

--------------------------------

### Node Configuration Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.en.md

Example of starting a Selenium Grid Node with specific configurations for sessions, logging, port, and supported drivers.

```APIDOC
## Node, with 4 max sessions, with debug(fine) log, 7777 as port, and only with Firefox and Edge

### Description
Starts the Selenium Grid Node component with configurations for maximum sessions, logging level, listening port, and specific driver implementations.

### Method
java -jar

### Endpoint
selenium-server-<version>.jar node

### Parameters
#### Query Parameters
- **--max-sessions** (int) - Optional - Maximum number of concurrent sessions the Node can handle.
- **--log-level** (string) - Optional - Sets the logging level. Example: `"fine"` for debug.
- **--port** (int) - Required - The port on which the Node will listen.
- **--driver-implementation** (string) - Optional - Specifies a supported browser driver. Can be specified multiple times.

### Request Example
```
java -jar selenium-server-<version>.jar node --max-sessions 4 --log-level "fine" --port 7777 --driver-implementation "firefox" --driver-implementation "edge"
```
```

--------------------------------

### Hub Configuration Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.en.md

Example of starting a Selenium Grid Hub with session request timeout, port, and tracing disabled.

```APIDOC
## Hub, setting a new session request timeout, a main port, and disabling tracing

### Description
Starts the Selenium Grid Hub component, configuring session request timeout, listening port, and disabling tracing.

### Method
java -jar

### Endpoint
selenium-server-<version>.jar hub

### Parameters
#### Query Parameters
- **--session-request-timeout** (int) - Optional - Timeout in milliseconds for new session requests.
- **--port** (int) - Required - The port on which the Hub will listen.
- **--tracing** (boolean) - Optional - Whether to enable tracing. `false` disables it.

### Request Example
```
java -jar selenium-server-<version>.jar hub --session-request-timeout 500 --port 3333 --tracing false
```
```

--------------------------------

### Starting Selenium Grid Component with Command-Line Flags

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.pt-br.md

This example demonstrates how to start a Selenium Grid component using command-line flags. It shows the general syntax for passing configuration options to the Selenium server JAR file. Replace `<version>`, `<component>`, and `<option>` with your specific values.

```bash
java -jar selenium-server-<version>.jar <component> --<option> value
```

--------------------------------

### Distributor Configuration Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.en.md

Example of starting a Selenium Grid Distributor with Session Map and Session Queue server URLs, and disabling bus.

```APIDOC
## Distributor, setting Session Map server url, Session Queue server url, and disabling bus

### Description
Starts the Selenium Grid Distributor component, configuring the URLs for the Session Map and Session Queue servers, and disabling the bus.

### Method
java -jar

### Endpoint
selenium-server-<version>.jar distributor

### Parameters
#### Query Parameters
- **--sessions** (uri) - Optional - The URL of the session map server.
- **--sessionqueue** (uri) - Optional - The URL of the session queue server.
- **--bind-bus** (boolean) - Optional - Whether to bind to the bus. `false` disables it.

### Request Example
```
java -jar selenium-server-<version>.jar distributor --sessions http://localhost:5556 --sessionqueue http://localhost:5559 --bind-bus false
```
```

--------------------------------

### Install Firefox Add-ons

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.zh-cn.md

Installs a signed .xpi extension file into the Firefox browser instance after the driver has started.

```APIDOC
## Install Firefox Add-on

### Description
Installs a signed XPI file into the Firefox profile.

### Parameters
#### Request Body
- **path** (string) - Required - Path to the signed .xpi file.

### Request Example
// Java Example
FirefoxDriver driver = new FirefoxDriver();
driver.installExtension(Paths.get("/path/to/extension.xpi"));
```

--------------------------------

### Setup and Run Selenium JavaScript Tests

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/examples/javascript/README.md

Commands to clone the repository, navigate to the project directory, install dependencies, and execute the full test suite.

```bash
git clone https://github.com/SeleniumHQ/seleniumhq.github.io.git
cd seleniumhq.github.io/examples/javascript
npm install
npm test
```

--------------------------------

### Configure Selenium Grid Components via CLI

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.zh-cn.md

Examples of starting various Selenium Grid components with specific configuration flags such as ports, session limits, and log levels.

```bash
java -jar selenium-server-<version>.jar standalone --max-sessions 4 --port 4444
java -jar selenium-server-<version>.jar hub --session-request-timeout 500 --port 3333 --tracing false
java -jar selenium-server-<version>.jar node --max-sessions 4 --log-level "fine" --port 7777 --driver-implementation "firefox" --driver-implementation "edge"
java -jar selenium-server-<version>.jar distributor --sessions http://localhost:5556 --sessionqueue http://localhost:5559 --bind-bus false
```

--------------------------------

### Install Firefox Add-ons

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.en.md

Installs a signed .xpi extension file into the Firefox browser instance after the driver has started.

```Java
driver.installExtension(Paths.get("/path/to/extension.xpi"));
```

```Python
driver.install_addon("/path/to/extension.xpi")
```

```CSharp
driver.InstallAddOnFromManifest("/path/to/extension.xpi");
```

```Ruby
driver.install_addon("/path/to/extension.xpi")
```

```JavaScript
await driver.installAddon('/path/to/extension.xpi');
```

--------------------------------

### Addon Management

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.en.md

Examples for uninstalling and installing browser addons.

```APIDOC
## Addon Management

### Uninstalling an Addon

To uninstall an addon, you need its ID, which is returned upon installation.

### Installing an Unsigned Addon

Unsigned extensions can be installed as temporary addons using a zip file or a directory.

#### Java Example (Directory Installation)

```java
// Code for installing an unsigned addon from a directory
```

#### Python Example (Directory Installation)

```python
# Code for installing an unsigned addon from a directory
```

#### CSharp Example (Directory Installation)

```csharp
// Code for installing an unsigned addon from a directory
```

#### Ruby Example (Directory Installation)

```ruby
# Code for installing an unsigned addon from a directory
```

#### JavaScript Example (Directory Installation)

```javascript
// Code for installing an unsigned addon from a directory
```

#### Kotlin Example

```kotlin
// Code for installing an unsigned addon
```
```

--------------------------------

### Configuration Examples

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.pt-br.md

Examples of how to configure Selenium Grid using command-line flags.

```APIDOC
## Configuration Examples

### Command-line Flags
To pass config options as command-line flags, identify the valid options for the component and follow the template below.

```
java -jar selenium-server-<version>.jar <component> --<option> value
```

### TOML Configuration
We recommend the use of [Toml files](toml_options.md) to configure a Grid. Configuration files improve readability, and you can also check them in source control.

When needed, you can combine a Toml file configuration with CLI arguments.
```

--------------------------------

### Configuration Examples

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.zh-cn.md

Examples demonstrating how to use the configuration options, including recommendations for TOML files.

```APIDOC
## Configuration Examples

All the options mentioned above can be used when starting the Grid components. They are a good way of exploring the Grid options, and trying out values to find a suitable configuration.

We recommend the use of [Toml files](toml_options.md) to configure a Grid. Configuration files improve readability, and you can also check them in source control.

When needed, you can combine a Toml file configuration with CLI arguments.
```

--------------------------------

### Navigate to .NET Examples Directory

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/examples/dotnet/README.md

Changes the current directory to the location of the .NET Selenium examples within the cloned repository.

```bash
cd seleniumhq.github.io/examples/dotnet/SeleniumDocs
```

--------------------------------

### Initialize Default Driver Service

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/drivers/service.en.md

Demonstrates how to start a WebDriver with a default service instance. This is the basic setup for managing local drivers. Note that configuration methods vary by language, with some using builders, constructors, or properties.

```Java
ChromeDriverService service = ChromeDriverService.createDefaultService();
service.start();
```

```Python
from selenium.webdriver.chrome.service import Service
service = Service()
service.start()
```

```CSharp
var service = ChromeDriverService.CreateDefaultService();
service.Start();
```

```Ruby
service = Selenium::WebDriver::Chrome::Service.new
service.start
```

--------------------------------

### Navigate to Python Examples Directory

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/examples/python/README.md

Changes the current directory to the Python examples subdirectory within the cloned repository. This is where the test scripts are located.

```bash
cd seleniumhq.github.io/examples/python
```

--------------------------------

### Automated Driver Management with Selenium Manager (Ruby)

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/selenium_manager.ja.md

Provides Ruby examples of using Selenium Manager to automatically handle WebDriver binaries, contrasting the manual setup with the simplified, automated approach.

```Ruby
require 'selenium-webdriver'
require 'webdrivers'

Selenium::WebDriver::Chrome::Service.driver_path = Webdrivers::Chromedriver.download
options = Selenium::WebDriver::Chrome::Options.new
@driver = Selenium::WebDriver.for :chrome, service: Selenium::WebDriver::Chrome::Service.new, options: options
```

```Ruby
require 'selenium-webdriver'

@driver = Selenium::WebDriver.for :chrome
```

--------------------------------

### se-config.toml Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/selenium_manager.ja.md

An example TOML configuration file for Selenium Manager, demonstrating how to set various options such as cache path, browser versions, and driver versions.

```toml
cache_path = "/tmp/selenium_cache"
chrome_version = "116.0.5845.188"
firefox_version = "117.0"
chrome_driver_version = "116.0.5845.97"

```

--------------------------------

### Install Ruby dependencies

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/examples/ruby/README.md

Use bundler to install all required gems for the project.

```bash
bundler install
```

--------------------------------

### Start Safari Session with Technology Preview

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/safari.ja.md

Configure and start a Safari session using the Technology Preview version of the browser. Ensure the correct options are set for the preview version.

```java
var options = new SafariOptions();
options.setUseTechnologyPreview(true);
var driver = new SafariDriver(options);
```

```python
from selenium.webdriver.safari.options import Options

options = Options()
options.use_technology_preview = True
driver = webdriver.Safari(options=options)
```

```ruby
options = Selenium::WebDriver::Safari::Options.new
options.use_technology_preview = true
driver = Selenium::WebDriver.for :safari, options: options
```

--------------------------------

### Install Firefox Add-on (XPI)

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.zh-cn.md

Install a Firefox add-on (XPI file) after the WebDriver has started. Unlike Chrome, Firefox add-ons are not added via capabilities but are installed programmatically.

```Java
driver.installExtension(new File("/path/to/your/extension.xpi"));
```

```Python
driver.install_addon("/path/to/your/extension.xpi")
```

```CSharp
driver.InstallAddon("/path/to/your/extension.xpi");
```

```Ruby
driver.install_addon('/path/to/your/extension.xpi')
```

```JavaScript
await driver.installAddon("/path/to/your/extension.xpi");
```

--------------------------------

### Firefox Driver Extension Installation

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.pt-br.md

Install Firefox extensions (XPI files) after the driver has started. Unlike Chrome, extensions are not added via capabilities.

```APIDOC
## Firefox Driver Extension Installation

### Description
Install Firefox extensions (XPI files) after the driver has started. Unlike Chrome, extensions are not added via capabilities.

### Method
Not Applicable (Configuration setting)

### Endpoint
Not Applicable (Configuration setting)

### Parameters
#### Query Parameters
- **extension** (string) - Required - Path to the XPI file for the extension to be installed.

#### Request Body
None

### Request Example
None

### Response
None

### Notes
Obtain XPI files from the [Mozilla Extras page](https://addons.mozilla.org/en-US/firefox/).
```

--------------------------------

### Start Selenium Grid Component with Config

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/toml_options.en.md

Command line instruction to launch a Selenium Grid component using a specified TOML configuration file.

```bash
java -jar selenium-server-<version>.jar <component> --config /path/to/file/<file-name>.toml
```

--------------------------------

### Script Pinning in C#

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/bidi/cdp/script.ja.md

Example of script pinning using CDP in C#. Requires appropriate CDP command execution setup.

```CSharp
await driver.ExecuteCdpCommandAsync("Page.enable", new Dictionary<string, object>());
            await driver.ExecuteCdpCommandAsync("Page.setScript", new Dictionary<string, object>());
```

--------------------------------

### Script Pinning in Java

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/bidi/cdp/script.ja.md

Example of script pinning using CDP in Java. Ensure necessary imports and setup for CDP interaction.

```Java
driver.executeCdpCommand("Page.enable", new HashMap<>());
        driver.executeCdpCommand("Page.setScript", new HashMap<>());
```

--------------------------------

### Start Grid Nodes with Custom Capabilities

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.en.md

Demonstrates starting Grid nodes with specific stereotypes to allow for custom capability matching. This enables routing session requests to specific nodes based on defined criteria.

```bash
java -jar selenium-server-<version>.jar node --detect-drivers false --driver-configuration display-name="Chrome (custom capability true)" max-sessions=1 stereotype='{"browserName":"chrome","gsg:customcap":true}' --port 6161
java -jar selenium-server-<version>.jar node --detect-drivers false --driver-configuration display-name="Chrome (custom capability true)" max-sessions=1 stereotype='{"browserName":"chrome","gsg:customcap":false}' --port 6262
```

--------------------------------

### Configure Internet Explorer Command-Line Arguments

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/internet_explorer.en.md

Demonstrates how to initialize Internet Explorer with specific command-line switches such as kiosk mode. Requires the ForceCreateProcessApi setting to be enabled for the arguments to take effect.

```Java
import org.openqa.selenium.Capabilities;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.ie.InternetExplorerOptions;

public class ieTest {
    public static void main(String[] args) {
        InternetExplorerOptions options = new InternetExplorerOptions();
        options.useCreateProcessApiToLaunchIe();
        options.addCommandSwitches("-k");
        InternetExplorerDriver driver = new InternetExplorerDriver(options);
        try {
            driver.get("https://google.com/ncr");
            Capabilities caps = driver.getCapabilities();
            System.out.println(caps);
        } finally {
            driver.quit();
        }
    }
}
```

```CSharp
using System;
using OpenQA.Selenium;
using OpenQA.Selenium.IE;

namespace ieTest {
 class Program {
  static void Main(string[] args) {
   InternetExplorerOptions options = new InternetExplorerOptions();
   options.ForceCreateProcessApi = true;
   options.BrowserCommandLineArguments = "-k";
   IWebDriver driver = new InternetExplorerDriver(options);
   driver.Url = "https://google.com/ncr";
  }
 }
}
```

```JavaScript
const ie = require('selenium-webdriver/ie');
let options = new ie.Options();
options.addBrowserCommandSwitches('-k');
options.addBrowserCommandSwitches('-private');
options.forceCreateProcessApi(true);

driver = await env.builder()
          .setIeOptions(options)
          .build();
```

```Kotlin
import org.openqa.selenium.Capabilities
import org.openqa.selenium.ie.InternetExplorerDriver
import org.openqa.selenium.ie.InternetExplorerOptions

fun main() {
    val options = InternetExplorerOptions()
    options.useCreateProcessApiToLaunchIe()
    options.addCommandSwitches("-k")
    val driver = InternetExplorerDriver(options)
    try {
        driver.get("https://google.com/ncr")
        val caps = driver.getCapabilities()
        println(caps)
    } finally {
        driver.quit()
    }
}
```

--------------------------------

### Configure Selenium Distributor

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.pt-br.md

Starts the Selenium Distributor with specified session server URLs and disables the bus. This component is part of a distributed Selenium Grid setup.

```bash
java -jar selenium-server-<version>.jar distributor --sessions http://localhost:5556 --sessionqueue http://localhost:5559 --bind-bus false
```

--------------------------------

### Start Selenium Grid in Standalone Mode

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/getting_started.en.md

Starts a fully functional Selenium Grid on a single machine. This mode is ideal for local development, debugging, or simple CI/CD setups. It listens for RemoteWebDriver requests on http://localhost:4444 by default and automatically detects available browser drivers from the system PATH.

```shell
java -jar selenium-server-<version>.jar standalone
```

--------------------------------

### Run Hugo Development Server

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/about/contributing.en.md

Commands to navigate to the documentation directory and start the local Hugo server for live previews. Use the ignoreCache flag if updates from GitHub are not reflecting.

```shell
cd website_and_docs
hugo server
hugo server --ignoreCache
```

--------------------------------

### Running a Custom Node JAR with Selenium Grid

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/advanced_features/customize_node.ja.md

This command demonstrates how to start the Selenium server and load a custom Node implementation packaged as a JAR file. It specifies the main Selenium server JAR, the custom Node JAR, and the fully qualified name of the custom Node class.

```bash
java -jar selenium-server-4.6.0.jar \
--ext custom_node-1.0-SNAPSHOT.jar node \
--node-implementation org.seleniumhq.samples.DecoratedLoggingNode
```

--------------------------------

### GET /status

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/architecture.zh-cn.md

The Distributor polls the Node's /status endpoint to gather information for Grid setup and health checks. This endpoint is crucial for the Grid to understand the Node's capabilities and current state.

```APIDOC
## GET /status

### Description
Retrieves the current status and capabilities of a Selenium Grid Node.

### Method
GET

### Endpoint
/status

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **availability** (string) - The availability status of the Node (`up`, `draining`, or `down`).
- **externalUrl** (string) - The URI for other Grid components to connect to the Node.
- **lastSessionCreated** (integer) - Epoch timestamp of the last session creation.
- **maxSessionCount** (integer) - Maximum number of concurrent sessions the Node can handle.
- **nodeId** (string) - A unique identifier for the Node instance.
- **osInfo** (object) - Information about the Node's operating system (`arch`, `name`, `version`).
- **slots** (array) - An array of Slot objects representing available slots on the Node.
- **version** (string) - The version of the Node software.

#### Response Example
```json
{
  "availability": "up",
  "externalUrl": "http://localhost:4444",
  "lastSessionCreated": 1678886400000,
  "maxSessionCount": 5,
  "nodeId": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
  "osInfo": {
    "arch": "x64",
    "name": "Windows",
    "version": "10"
  },
  "slots": [
    {
      "id": "slot-1",
      "lastStarted": "2023-03-15T10:00:00Z",
      "stereotype": {"browserName": "chrome"},
      "session": null
    }
  ],
  "version": "4.8.0"
}
```
```

--------------------------------

### Create and Log In User Account for Testing

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/test_practices/overview.en.md

This code demonstrates the setup phase of a Selenium test by creating a common user with specific permissions and then logging in as that user. This approach ensures that test data is prepared before browser automation begins, leading to faster and more reliable tests. The user's credentials are often randomly generated and not explicitly needed by the test.

```Java
User user = UserFactory.createCommonUser(); //This method is defined elsewhere.

// Log in as this user.
// Logging in on this site takes you to your personal "My Account" page, so the
// AccountPage object is returned by the loginAs method, allowing you to then
// perform actions from the AccountPage.
AccountPage accountPage = loginAs(user.getEmail(), user.getPassword());
```

```Python
# Create a user who has read-only permissions--they can configure a unicorn,
# but they do not have payment information set up, nor do they have
# administrative privileges. At the time the user is created, its email
# address and password are randomly generated--you don't even need to
# know them.
user = user_factory.create_common_user() #This method is defined elsewhere.

# Log in as this user.
# Logging in on this site takes you to your personal "My Account" page, so the
# AccountPage object is returned by the loginAs method, allowing you to then
# perform actions from the AccountPage.
account_page = login_as(user.get_email(), user.get_password())
```

```CSharp
// Create a user who has read-only permissions--they can configure a unicorn,
// but they do not have payment information set up, nor do they have
// administrative privileges. At the time the user is created, its email
// address and password are randomly generated--you don't even need to
// know them.
User user = UserFactory.CreateCommonUser(); //This method is defined elsewhere.

// Log in as this user.
// Logging in on this site takes you to your personal "My Account" page, so the
// AccountPage object is returned by the loginAs method, allowing you to then
// perform actions from the AccountPage.
AccountPage accountPage = LoginAs(user.Email, user.Password);
```

```Ruby
# Create a user who has read-only permissions--they can configure a unicorn,
# but they do not have payment information set up, nor do they have
# administrative privileges. At the time the user is created, its email
# address and password are randomly generated--you don't even need to
# know them.
user = UserFactory.create_common_user #This method is defined elsewhere.

# Log in as this user.

```

--------------------------------

### Demonstrate Nested Loadable Components Test - Java Selenium

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/test_practices/design_strategies.en.md

A JUnit test class demonstrating the setup and usage of nested LoadableComponents. It initializes ProjectPage, SecuredPage, and EditIssue, then calls get() on EditIssue to trigger the loading of all nested components before interacting with the page elements.

```java
public class FooTest {
  private EditIssue editIssue;

  @Before
  public void prepareComponents() {
    WebDriver driver = new FirefoxDriver();

    ProjectPage project = new ProjectPage(driver, "selenium");
    SecuredPage securedPage = new SecuredPage(driver, project, "example", "top secret");
    editIssue = new EditIssue(driver, securedPage);
  }

  @Test
  public void demonstrateNestedLoadableComponents() {
    editIssue.get();

    editIssue.title.sendKeys('Title');
    editIssue.body.sendKeys('What Happened');
    editIssue.setHowToReproduce('How to Reproduce');
    editIssue.setLogOutput('Log Output');
    editIssue.setOperatingSystem('Operating System');
    editIssue.setSeleniumVersion('Selenium Version');
    editIssue.setBrowserVersion('Browser Version');
    editIssue.setDriverVersion('Driver Version');
    editIssue.setUsingGrid('I Am Using Grid');
  }

}
```

--------------------------------

### Navigate to the Ruby directory

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/examples/ruby/README.md

Change the working directory to the location of the Ruby examples.

```bash
cd seleniumhq.github.io/examples/ruby
```

--------------------------------

### Start a Custom Selenium Grid Node

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/advanced_features/customize_node.ja.md

This command demonstrates how to launch a custom Selenium Grid Node by specifying the fully qualified class name of the custom implementation using the --node-implementation argument.

```bash
java -jar custom_node-server.jar node --node-implementation org.seleniumhq.samples.DecoratedLoggingNode
```

--------------------------------

### Manage Chromedriver with Selenium Manager

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/selenium_manager.en.md

This example demonstrates how to use Selenium Manager to automatically detect and download the correct chromedriver for a locally installed Chrome browser. It shows the command-line invocation and the resulting debug and info logs, indicating the browser detection, driver download, and final paths.

```bash
$ ./selenium-manager --browser chrome --debug
DEBUG chromedriver not found in PATH
DEBUG chrome detected at C:\Program Files\Google\Chrome\Application\chrome.exe
DEBUG Detected browser: chrome 139.0.7258.67
DEBUG Discovering versions from https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json
DEBUG Required driver: chromedriver 139.0.7258.68
DEBUG Acquiring lock: C:\Users\boni\.cache\selenium\chromedriver\win64\139.0.7258.68\sm.lock
DEBUG Downloading chromedriver 139.0.7258.68 from https://storage.googleapis.com/chrome-for-testing-public/139.0.7258.68/win64/chromedriver-win64.zip
INFO  Driver path: C:\Users\boni\.cache\selenium\chromedriver\win64\139.0.7258.68\chromedriver.exe
INFO  Browser path: C:\Program Files\Google\Chrome\Application\chrome.exe
```

--------------------------------

### Install Selenium for Python using Pip

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/getting_started/install_library.en.md

Install the Selenium library for Python projects using pip, the standard package installer for Python. This command downloads and installs the latest stable version.

```shell
pip install selenium
```

--------------------------------

### Hello Selenium Script in Multiple Languages

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/_index.en.md

Demonstrates a basic 'Hello Selenium' script to initialize and interact with a browser using WebDriver. This example is provided in multiple programming languages to showcase cross-language compatibility. It requires the respective Selenium language bindings and a compatible WebDriver executable.

```Java
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class HelloSelenium {
    public static void main(String[] args) {
        // Set the path to your ChromeDriver executable
        System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
        
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.selenium.dev/");
        System.out.println("Page title is: " + driver.getTitle());
        driver.quit();
    }
}
```

```Python
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

options = webdriver.ChromeOptions()
# Uncomment the line below to run in headless mode
# options.add_argument('--headless')

service = Service(ChromeDriverManager().install())
driver = webdriver.Chrome(service=service, options=options)

driver.get("https://www.selenium.dev/")
print(f"Page title is: {driver.title}")
driver.quit()
```

```CSharp
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

public class HelloSelenium
{
    public static void Main(string[] args)
    {
        // Set the path to your ChromeDriver executable
        // For newer versions, WebDriverManager can handle this automatically
        // Example using WebDriverManager (install via NuGet):
        // using WebDriverManager;
        // WebDriverManager.Setup("chromedriver");
        
        using (IWebDriver driver = new ChromeDriver())
        {
            driver.Navigate().GoToUrl("https://www.selenium.dev/");
            Console.WriteLine("Page title is: " + driver.Title);
        }
    }
}
```

```Ruby
require 'selenium-webdriver'

# Set the path to your ChromeDriver executable
# For newer versions, WebDriverManager can handle this automatically
# Example using WebDriverManager (install via gem):
# require 'webdrivers'
# driver = Selenium::WebDriver.for :chrome

driver = Selenium::WebDriver.for :chrome
driver.navigate.to "https://www.selenium.dev/"
puts "Page title is: #{driver.title}"
driver.quit
```

```JavaScript
const { Builder, By, Key, until } = require('selenium-webdriver');
const chrome = require('selenium-webdriver/chrome');

async function helloSelenium() {
  // Set the path to your ChromeDriver executable
  // For newer versions, WebDriverManager can handle this automatically
  // Example using WebDriverManager (install via npm):
  // require('chromedriver');
  
  let driver = await new Builder().forBrowser('chrome').build();
  try {
    await driver.get('https://www.selenium.dev/');
    console.log(`Page title is: ${await driver.getTitle()}`);
  } finally {
    await driver.quit();
  }
}

helloSelenium();
```

```Kotlin
import org.openqa.selenium.WebDriver
import org.openqa.selenium.chrome.ChromeDriver

fun main() {
    // Set the path to your ChromeDriver executable
    System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver")
    
    val driver: WebDriver = ChromeDriver()
    driver.get("https://www.selenium.dev/")
    println("Page title is: ${driver.title}")
    driver.quit()
}
```

--------------------------------

### Navigated Started Event

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/bidi/w3c/browsing_context.ja.md

This section covers the Navigated Started event, which is triggered when a navigation has started in a browsing context.

```APIDOC
## Navigated Started Event

### Description
This event is triggered when a navigation has started in a browsing context.

### Method
N/A (Event)

### Endpoint
N/A (Event)

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **context** (string) - The ID of the browsing context where navigation started.
- **url** (string) - The URL that navigation started towards.

#### Response Example
```json
{
  "context": "some-context-id",
  "url": "http://example.com"
}
```
```

--------------------------------

### Install Unsigned Browser Add-on

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/firefox.zh-cn.md

Shows how to install an unsigned browser add-on, typically used for unfinished or unpublished extensions. It can be installed as a temporary add-on from a zip file or a directory.

```Java
driver.installAddon("path/to/unpacked/Addon", "my-addon-id");
```

```Python
driver.install_addon("path/to/unpacked/Addon", "my-addon-id")
```

```CSharp
driver.InstallAddon("path/to/unpacked/Addon", "my-addon-id");
```

```Ruby
driver.install_addon('path/to/unpacked/Addon', 'my-addon-id')
```

```JavaScript
await driver.installAddon("path/to/unpacked/Addon", "my-addon-id");
```

--------------------------------

### Manage Chrome Beta with Selenium Manager

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/selenium_manager.en.md

This example shows how to use Selenium Manager to manage a specific version of Chrome, such as a beta release. It details the command-line arguments required and the output logs, illustrating the process of discovering, downloading, and caching the specified Chrome beta version and its corresponding chromedriver.

```bash
$ ./selenium-manager --browser chrome --browser-version beta --debug
DEBUG chromedriver not found in PATH
DEBUG chrome not found in PATH
DEBUG chrome beta not found in the system
DEBUG Discovering versions from https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json
DEBUG Required browser: chrome 140.0.7339.16
DEBUG Acquiring lock: C:\Users\boni\.cache\selenium\chrome\win64\140.0.7339.16\sm.lock
DEBUG Downloading chrome 140.0.7339.16 from https://storage.googleapis.com/chrome-for-testing-public/140.0.7339.16/win64/chrome-win64.zip
DEBUG chrome 140.0.7339.16 is available at C:\Users\boni\.cache\selenium\chrome\win64\140.0.7339.16\chrome.exe
DEBUG Discovering versions from https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json
DEBUG Required driver: chromedriver 140.0.7339.16
DEBUG Acquiring lock: C:\Users\boni\.cache\selenium\chromedriver\win64\140.0.7339.16\sm.lock
DEBUG Downloading chromedriver 140.0.7339.16 from https://storage.googleapis.com/chrome-for-testing-public/140.0.7339.16/win64/chromedriver-win64.zip
INFO  Driver path: C:\Users\boni\.cache\selenium\chromedriver\win64\140.0.7339.16\chromedriver.exe
INFO  Browser path: C:\Users\boni\.cache\selenium\chrome\win64\140.0.7339.16\chrome.exe
```

--------------------------------

### Start Safari Session with Options

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/browsers/safari.ja.md

Initiate a Safari browser session with basic defined options. Ensure SafariOptions are imported.

```java
var options = new SafariOptions();
var driver = new SafariDriver(options);
```

```python
from selenium.webdriver.safari.options import Options

options = Options()
driver = webdriver.Safari(options=options)
```

```csharp
var options = new SafariOptions();
var driver = new SafariDriver(options);
```

```ruby
options = Selenium::WebDriver::Safari::Options.new
driver = Selenium::WebDriver.for :safari, options: options
```

```javascript
const { SafariDriver, SafariOptions } = require('selenium-webdriver/safari');

const options = new SafariOptions();
const driver = new SafariDriver(options);
```

```kotlin
val options = SafariOptions()
val driver = SafariDriver(options)
```

--------------------------------

### Example Code Snippet Format

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/blog/2021/public-project-meeting-20210715.md

A reference example for how code snippets should be structured in the documentation.

```markdown
https://gist.github.com/harsha509/e690dd2c72f1f5c5785be4c8a47c87fd
```

--------------------------------

### Install Selenium for Ruby using Gem

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/getting_started/install_library.en.md

Install the Selenium WebDriver gem for Ruby projects using the `gem install` command. This makes the Selenium library available for use in your Ruby automation scripts.

```shell
gem install selenium-webdriver
```

--------------------------------

### Compare Manual vs Automated Driver Management

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/selenium_manager.zh-cn.md

Examples showing the transition from manual driver path configuration to the automated Selenium Manager approach across different languages.

```java
// Previously
System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
WebDriver driver = new ChromeDriver();

// Selenium Manager
WebDriver driver = new ChromeDriver();
```

```python
# Previously
from selenium.webdriver.chrome.service import Service
service = Service(executable_path="/path/to/chromedriver")
driver = webdriver.Chrome(service=service)

# Selenium Manager
driver = webdriver.Chrome()
```

```csharp
var service = ChromeDriverService.CreateDefaultService("/path/to/", "chromedriver.exe");
var driver = new ChromeDriver(service);

// Selenium Manager
var driver = new ChromeDriver();
```

```ruby
# Previously
Selenium::WebDriver::Chrome::Service.driver_path = "/path/to/chromedriver"
driver = Selenium::WebDriver.for :chrome

# Selenium Manager
driver = Selenium::WebDriver.for :chrome
```

```javascript
// Previously
const { Options } = require('selenium-webdriver/chrome');
const service = new chrome.ServiceBuilder('/path/to/chromedriver').build();
const driver = chrome.Driver.createSession(new Options(), service);

// Selenium Manager
let driver = await new Builder().forBrowser('chrome').build();
```

--------------------------------

### Response Started Event

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/webdriver/bidi/w3c/network.en.md

An event triggered when the response headers for a network request have started to be received.

```APIDOC
## Event: network.responseStarted

### Description
This event is triggered when the response headers for a network request have started to be received. It provides information about the response, such as status code and headers.

### Parameters
- **requestId** (string) - The unique identifier for the network request.
- **url** (string) - The URL of the request.
- **status** (integer) - The HTTP status code of the response.
- **headers** (array of objects) - The response headers.
- **mimeType** (string) - The MIME type of the response.

### Event Example
```json
{
  "type": "event",
  "method": "network.responseStarted",
  "params": {
    "requestId": "request-123",
    "url": "https://example.com/api/data",
    "status": 200,
    "headers": [
      {"name": "Content-Type", "value": "application/json"}
    ],
    "mimeType": "application/json"
  }
}
```
```

--------------------------------

### Initialize a basic Selenium WebDriver test

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/_index.zh-cn.md

A minimal example demonstrating how to launch a browser and perform a basic interaction using the WebDriver API across different supported languages.

```Java
{{< gh-codeblock path="/examples/java/src/test/java/dev/selenium/hello/HelloSelenium.java" >}}
```

```Python
{{< gh-codeblock path="/examples/python/tests/hello/hello_selenium.py" >}}
```

```CSharp
{{< gh-codeblock path="/examples/dotnet/HelloSelenium.cs" >}}
```

```Ruby
{{< gh-codeblock path="/examples/ruby/spec/hello/hello_selenium.rb" >}}
```

```JavaScript
{{< gh-codeblock path="/examples/javascript/test/hello/helloSelenium.js" >}}
```

```Kotlin
{{< gh-codeblock path="/examples/kotlin/src/test/kotlin/dev/selenium/hello/HelloSelenium.kt" >}}
```

--------------------------------

### Direct cURL Example

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/blog/2026/selenium-grid-4-41-deep-dive.md

Example of how to send a session event using cURL for scripting or debugging.

```APIDOC
## Direct cURL Example

For scripting or debugging purposes, you can directly invoke the session event endpoint using cURL.

```bash
curl -X POST http://localhost:4444/session/${SESSION_ID}/se/event \
  -H 'Content-Type: application/json' \
  -d '{"eventType": "test:failed", "payload": {"testName": "LoginTest"}}'
```

Replace `${SESSION_ID}` with the actual session ID and adjust the URL if your Selenium Grid is running on a different host or port.
```

--------------------------------

### Enable Managed Downloads in Selenium Grid

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.pt-br.md

Shows how to start the Selenium Hub and a Node with managed downloads enabled, and how to set the corresponding capability in the test code.

```bash
java -jar selenium-server-<version>.jar hub
```

```bash
java -jar selenium-server-<version>.jar node --enable-managed-downloads true
```

--------------------------------

### Custom Capabilities for Node Matching

Source: https://github.com/seleniumhq/seleniumhq.github.io/blob/trunk/website_and_docs/content/documentation/grid/configuration/cli_options.pt-br.md

Demonstrates how to start Hub and Nodes with custom capabilities and how to match them from the client.

```APIDOC
## Custom Capabilities for Node Matching

### Description
This section explains how to use custom capabilities to match specific Nodes with client session requests. Custom capabilities must be configured on both Nodes and in session requests.

### Method
Command Line & Java Client

### Endpoint
N/A

### Parameters
#### Hub Start Command
- No specific parameters for custom capability matching during Hub start.

#### Node Start Command Arguments
- `--detect-drivers` (boolean) - Optional - Whether to auto-detect drivers. Set to `false` when using `stereotype`.
- `--driver-configuration` (string) - Optional - Configuration for a driver, including `display-name`, `max-sessions`, and `stereotype`.
  - `stereotype` (JSON string) - Required within `driver-configuration` - Defines the capabilities for the Node, including custom ones.
- `--port` (integer) - Optional - The port the Node will listen on.

### Request Example (Starting Hub)
```bash
java -jar selenium-server-<version>.jar hub
```

### Request Example (Starting Node A with custom cap `true`)
```bash
java -jar selenium-server-<version>.jar node --detect-drivers false --driver-configuration display-name="Chrome (custom capability true)" max-sessions=1 stereotype='{"browserName":"chrome","gsg:customcap":true}' --port 6161
```

### Request Example (Starting Node B with custom cap `false`)
```bash
java -jar selenium-server-<version>.jar node --detect-drivers false --driver-configuration display-name="Chrome (custom capability false)" max-sessions=1 stereotype='{"browserName":"chrome","gsg:customcap":false}' --port 6262
```

### Request Example (Client Matching Node A)
```java
ChromeOptions options = new ChromeOptions();
options.setCapability("gsg:customcap", true);
WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444"), options);
driver.get("https://selenium.dev");
driver.quit();
```

### Response
N/A

### Note
Set the custom capability to `false` in order to match Node B.
```