Marathon Cloud

https://docs.marathonlabs.io
Admin
Marathon Cloud is a cloud testing infrastructure that automatically provisions virtual devices and...
Tokens:33,338
Snippets:535
Trust Score:6.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Configure Install Options (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Specify additional installation options using 'installOptions' in the Marathonfile.

```yaml
vendorConfiguration:
  type: "Android"
  installOptions: "-d"
```

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

### Install Extra Applications (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

List APKs to be installed on the device before test execution. This is useful for installing helper applications like test-butler.

```yaml
vendorConfiguration:
  type: "Android"
  extraApplicationsApk:
    - "dist/extra.apk"
    - "dist/extra_two.apk"

```

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

### Configure Install Options (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure 'installOptions' using Kotlin DSL to specify additional installation flags.

```kotlin
marathon {
  installOptions = "-d"
}
```

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

### iOS Project File Structure

Source: https://docs.marathonlabs.io/runner/intro/overview

Example file structure for an iOS project using Marathon.

```bash
foo@bar $ tree .    
.  
├── Marathondevices  
├── Marathonfile  
├── build  
│   ├── my.app  
│   ├── my.xctest  
  

```

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

### Install Marathon Cloud CLI

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Installs the Marathon Cloud CLI after adding the repository. This command fetches and installs the latest version of the CLI.

```bash
brew install malinskiy/tap/marathon-cloud  
```

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

### Android Project File Structure

Source: https://docs.marathonlabs.io/runner/intro/overview

Example file structure for an Android project using Marathon.

```bash
foo@bar $ tree .    
.  
├── Marathondevices  
├── Marathonfile  
├── dist  
│   ├── app-debug.apk  
│   ├── app-debug-androidTest.apk  

```

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

### Basic Marathonfile Configuration

Source: https://docs.marathonlabs.io/runner/intro/configure

A simple Marathonfile example showing basic configuration options like name, output directory, and debug mode.

```yaml
name: "My awesome tests"  
outputDir: "marathon"  
debug: false  

```

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

### Install Extra Applications (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Specify additional APKs to install before running tests using Kotlin DSL. Supports both relative and absolute file paths.

```kotlin
marathon {
  extraApplications = listOf(
    File(project.rootDir, "test-butler-app-2.2.1.apk")
      File ("/home/user/other-apk-with-absolute-path.apk"),
  )
}

```

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

### Specify Extra Applications to Install

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

List paths to additional applications that Marathon should install on the device before running tests.

```yaml
extraApplications:
  - "/path/to/additional.app"
```

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

### Install Marathon Cloud CLI using Homebrew

Source: https://docs.marathonlabs.io/cli/installation

Install the Marathon Cloud CLI after adding the MarathonLabs repository. This command installs the CLI tool for managing Marathon Cloud resources.

```bash
brew install malinskiy/tap/marathon-cloud  

```

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

### Specify Android Platform Configuration

Source: https://docs.marathonlabs.io/runner/intro/configure

Define the target platform for the test run. This example specifies Android as the vendor.

```yaml
vendorConfiguration:
  type: "Android"  

```

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

### Install Marathon on Other OS

Source: https://docs.marathonlabs.io/runner/intro/install

Download the latest release from GitHub, extract the archive, and add the binary to your PATH. This is for systems other than macOS that do not use Homebrew.

```bash
unzip -d $DESTINATION marathon-X.X.X.zip
export PATH=$PATH:$DESTINATION/marathon-X.X.X/bin
```

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

### Install Marathon on macOS with Homebrew

Source: https://docs.marathonlabs.io/runner/intro/install

Use this command to install Marathon on macOS using Homebrew. Ensure you have tapped the malinskiy/tap repository first.

```bash
brew tap malinskiy/tap
brew install malinskiy/tap/marathon
```

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

### Start Marathon Test Runner

Source: https://docs.marathonlabs.io/runner/intro/overview

Execute the Marathon test runner from the root of your project directory. This command initiates the test execution process.

```bash
$ marathon   
XXX [main] INFO com.malinskiy.marathon.cli.ApplicationView - Starting marathon  
XXX [main] INFO com.malinskiy.marathon.cli.config.ConfigFactory - Checking Marathonfile config  
...  

```

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

### Add MarathonLabs Repository using Homebrew

Source: https://docs.marathonlabs.io/cli/installation

Add the MarathonLabs repository to your Homebrew installation. This is a prerequisite for installing the Marathon Cloud CLI.

```bash
brew tap malinskiy/tap  

```

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

### Configure Marathon Gradle Plugin (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/install

Configure the Marathon Gradle plugin using Kotlin DSL. This example demonstrates setting up various testing parameters like output directories, sharding, and flakiness strategies.

```kotlin
marathon {
  name = "sample-app tests"
  baseOutputDir = "./marathon"
  outputConfiguration {
    maxPath = 1024
  }
  analytics {
    influx {
      url = "http://influx.svc.cluster.local:8086"
      user = "root"
      password = "root"
      dbName = "marathon"
    }
  }
  poolingStrategy {
    operatingSystem = true
  }
  shardingStrategy {
    countSharding {
      count = 5
    }
  }
  sortingStrategy {
    executionTime {
      percentile = 90.0
      executionTime = Instant.now().minus(3, ChronoUnit.DAYS)
    }
  }
  batchingStrategy {
    fixedSize {
      size = 10
    }
  }
  flakinessStrategy {
    probabilityBased {
      minSuccessRate = 0.8
      maxCount = 3
      timeLimit = Instant.now().minus(30, ChronoUnit.DAYS)
    }
  }
  retryStrategy {
    fixedQuota {
      totalAllowedRetryQuota = 200
      retryPerTestQuota = 3
    }
  }
  filteringConfiguration {
    allowlist {
      add(SimpleClassnameFilterConfiguration(".*".toRegex()))
    }
    blocklist {
      add(SimpleClassnameFilterConfiguration("$^".toRegex()))
    }
  }
  includeSerialRegexes = emptyList()
  excludeSerialRegexes = emptyList()
  uncompletedTestRetryQuota = 100
  ignoreFailures = false
  isCodeCoverageEnabled = false
  fallbackToScreenshots = false
  testOutputTimeoutMillis = 30_000
  debug = true
  autoGrantPermission = true
}

```

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

### Add MarathonLabs Homebrew Repository

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Adds the MarathonLabs repository to your Homebrew installation. This is a prerequisite for installing the CLI.

```bash
brew tap malinskiy/tap  
```

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

### Configure Hybrid macOS Desktop Devices (SSH and Local)

Source: https://docs.marathonlabs.io/runner/apple/workers

Configuration for a hybrid setup using both remote (SSH) and local macOS instances for desktop app testing.

```yaml
workers:
  - transport:
      type: ssh
      addr: 10.0.0.2
    devices:
      - type: host
  - transport:
      type: local
    devices:
      - type: host

```

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

### Enable Automatic Permission Granting (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Set 'autoGrantPermission' to true in the Marathonfile to automatically grant all runtime permissions during application installation.

```yaml
vendorConfiguration:
  type: "Android"
  autoGrantPermission: true
```

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

### Configure NM Test Parser

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Use this configuration for the 'nm' test parser, which doesn't require app installation but doesn't support runtime-generated tests.

```yaml
testParserConfiguration:
  type: "nm"
  testClassRegexes:
    - "^((?!Abstract).)*Test[s]*$"

```

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

### Fixed Size Batching Strategy

Source: https://docs.marathonlabs.io/runner/configuration/batching

Configure 'fixed-size' batching with optional duration limits and last mile optimization. 'size' is required. 'durationMillis' and 'timeLimit' can prevent excessively long batches, while 'lastMileLength' optimizes the final tests on multi-device setups.

```yaml
batchingStrategy:  
  type: "fixed-size"  
  size: 5  
  durationMillis: 100000  
  percentile: 80.0  
  timeLimit: "-PT1H"  
  lastMileLength: 10  
```

```groovy
marathon {
  batchingStrategy {
    fixedSize {
      size = 5
      durationMillis = 100000
      percentile = 80.0
      timeLimit = Instant.now().minus(Duration.parse("PT1H"))
      lastMileLength = 10
    }
  }
}

```

```kotlin
marathon {
  batchingStrategy {
    fixedSize {
      size = 5
      durationMillis = 100000
      percentile = 80.0
      timeLimit = Instant.now().minus(Duration.parse("PT1H"))
      lastMileLength = 10
    }
  }
}

```

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

### Clone Marathon Repository

Source: https://docs.marathonlabs.io/runner/intro/contribute

Clone the Marathon repository to your local machine to start contributing.

```bash
foo@bar $ git clone https://github.com/MarathonLabs/marathon.git  
```

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

### Enable Code Coverage in Marathonfile

Source: https://docs.marathonlabs.io/runner/intro/configure

Enable code coverage collection in Marathonfile. Note that user setup for coverage generation is assumed.

```yaml
isCodeCoverageEnabled: true  

```

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

### Configure Shell Timeout (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure the timeout for shell commands using the Kotlin DSL. This example sets the shell timeout to 30 seconds.

```kotlin
marathon {
  timeoutConfiguration {
    shell = Duration.ofSeconds(30)
  }
}

```

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

### Enable Code Coverage in Kotlin DSL

Source: https://docs.marathonlabs.io/runner/intro/configure

Enable code coverage collection using the Kotlin DSL. User setup for coverage generation is assumed.

```kotlin
marathon {
  isCodeCoverageEnabled = true  
}

```

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

### List Available Runtimes

Source: https://docs.marathonlabs.io/runner/apple/workers

Command to list all available simulator runtimes and their versions on your system.

```bash
foo@bar $ xcrun simctl list runtimes -v
== Runtimes ==
iOS 16.2 (16.2 - 20C52) - com.apple.CoreSimulator.SimRuntime.iOS-16-2 [/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Library/Developer/CoreSimulator/Profiles/Runtimes/iOS.simruntime]
tvOS 16.1 (16.1 - 20K67) - com.apple.CoreSimulator.SimRuntime.tvOS-16-1 [/Library/Developer/CoreSimulator/Volumes/tvOS_20K67/Library/Developer/CoreSimulator/Profiles/Runtimes/tvOS 16.1.simruntime]
watchOS 9.1 (9.1 - 20S75) - com.apple.CoreSimulator.SimRuntime.watchOS-9-1 [/Library/Developer/CoreSimulator/Volumes/watchOS_20S75/Library/Developer/CoreSimulator/Profiles/Runtimes/watchOS 9.1.simruntime]
...  

```

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

### Download Sample iOS Application

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Downloads a prebuilt sample iOS application for testing. Save the downloaded zip file to a local directory.

```bash
curl https://cloud.marathonlabs.io/samples/ios/sample.zip -o sample.zip  
```

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

### Download Sample Android Application

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Downloads a prebuilt sample Android application (APK). Save this file for use in test execution.

```bash
curl https://cloud.marathonlabs.io/samples/android/app.apk -o app.apk  
```

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

### Marathon CLI Run Command Help

Source: https://docs.marathonlabs.io/runner/intro/execute

Shows help for the 'run' command, detailing options for executing tests.

```bash
foo@bar $ marathon run -h  
Usage: marathon run [OPTIONS]  
  
  Run Marathon to execute tests  
  
Options:  
  -m, --marathonfile PATH    Marathonfile file path  
  --analyticsTracking VALUE  Enable/Disable anonymous analytics tracking  
  --bugsnag VALUE            Enable/Disable anonymous crash reporting. Enabled by default  
  -h, --help                 Show this message and exit  
```

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

### Marathon CLI Help

Source: https://docs.marathonlabs.io/runner/intro/execute

Displays general help information for the Marathon CLI, including available options.

```bash
foo@bar $ marathon -h  
usage: marathon [-h] [--marathonfile MARATHONFILE]  
  
optional arguments:  
  -h, --help                     show this help message and exit  
  
  --marathonfile MARATHONFILE,   marathonfile file path  
  -m MARATHONFILE  
```

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

### Display Marathon Cloud CLI Help

Source: https://docs.marathonlabs.io/cli/parameters

Run this command to view all available commands and options for the Marathon Cloud CLI.

```bash
--> marathon-cloud help  
  
Command-line client for Marathon Cloud  
  
Usage: marathon-cloud [OPTIONS] [COMMAND]  
  
Commands:  
  run          Submit a test run  
  download     Download artifacts from a previous test run  
  completions  Output shell completion code for the specified shell (bash, zsh, fish)  
  help         Print this message or the help of the given subcommand(s)  
  
Options:  
  -v, --verbose...  Increase logging verbosity  
  -q, --quiet...    Decrease logging verbosity  
  -h, --help        Print help  
  -V, --version     Print version  
```

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

### Build iOS Application for Testing

Source: https://docs.marathonlabs.io/intro/ios

Use this command to build your application and its tests into .app bundles. Ensure the destination is correctly specified for your environment.

```bash
xcodebuild build-for-testing \
   -project sample.xcodeproj \
   -scheme sample \
   -destination 'platform=iOS Simulator,name=iPhone 14,OS=16.1' \
   -derivedDataPath ./build
```

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

### Configure Local macOS Desktop Device

Source: https://docs.marathonlabs.io/runner/apple/workers

Configuration for using a local macOS instance for desktop app testing.

```yaml
workers:
  - transport:
      type: local
    devices:
      - type: host

```

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

### Download Sample Android Test Application

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Downloads a prebuilt sample Android test application APK. This is used alongside the main application for running tests.

```bash
curl https://cloud.marathonlabs.io/samples/android/appTest.apk -o appTest.apk  
```

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

### Grant Permissions for macOS

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Configure permissions to be granted to an application during device setup on macOS. Note: Requires disabling System Integrity Protection.

```yaml
permissions:
  grant:
    - accessibility
    - developer-tool

```

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

### Download Sample iOS Test Application

Source: https://docs.marathonlabs.io/demo/android/html/pools/omni/127.0.0.1-5037-emulator-5556/com.example.NamedParameterizedTest.test%5Bcompute%20test%20for%20input%205%3A%205%5D.html

Downloads a prebuilt sample iOS test application runner. This is used in conjunction with the main application for test execution.

```bash
curl https://cloud.marathonlabs.io/samples/ios/sampleUITests-Runner.zip -o sampleUITests-Runner.zip  
```

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

### Enable Code Coverage in Groovy DSL

Source: https://docs.marathonlabs.io/runner/intro/configure

Enable code coverage collection using the Groovy DSL. User setup for coverage generation is assumed.

```groovy
marathon {
  codeCoverageEnabled = true  
}

```

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

### Marathon CLI Version Command Help

Source: https://docs.marathonlabs.io/runner/intro/execute

Shows help for the 'version' command, used to display the current version.

```bash
foo@bar $ marathon version -h  
Usage: marathon version [OPTIONS]  
  
  Print version and exit  
  
Options:  
  -h, --help  Show this message and exit  
```

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

### Maestro Test with Environment Variables

Source: https://docs.marathonlabs.io/intro/maestro

Define and use environment variables within Maestro tests for dynamic data. Variables must start with MAESTRO_ and are referenced using ${VARIABLE_NAME}.

```yaml
appId: your.app.id
---
- launchApp
- inputText: ${MAESTRO_USERNAME}
```

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

### Publish to Local Repository

Source: https://docs.marathonlabs.io/runner/intro/contribute

Publish all modules to a local Maven-like repository structure for testing Gradle plugin changes. Use -PreleaseMode=SNAPSHOT for snapshot releases.

```bash
./gradlew publishDefaultPublicationToLocalRepository -PreleaseMode=SNAPSHOT  
```

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

### Executing Marathon with Dynamic Variables via CLI

Source: https://docs.marathonlabs.io/runner/configuration/dynamic-configuration

Set environment variables before executing the Marathon CLI command to pass dynamic values. For example, set MARATHON_FRAGMENT_INDEX to control test fragmentation.

```bash
foo@bar:~$ MARATHON_FRAGMENT_INDEX=0 marathon

```

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

### Build Android App and Test APKs

Source: https://docs.marathonlabs.io/intro/android

Use this Gradle command to build both the application APK and the Android test APK. Ensure your primary application is located under the 'app/' subproject.

```bash
./gradlew :app:assembleDebug :app:assembleDebugAndroidTest
```

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

### Create Distribution Zip

Source: https://docs.marathonlabs.io/runner/intro/contribute

Create a distributable zip archive of the CLI. The output will be located in cli/build/distributions.

```bash
foo@bar $ ./gradlew :cli:distZip  
```

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

### Download Sample Android Test Application

Source: https://docs.marathonlabs.io/demo/ios/html/pools/omni/55CADA10-DB80-4A64-954C-80635FE50E04-malinskiy-192.168.2.27-22/sample_appUITests.MoreTests.testPresentModal.html

Download the pre-built sample Android test application. This APK file contains the test runner for your Android application.

```bash
curl https://cloud.marathonlabs.io/samples/android/appTest.apk -o appTest.apk  

```

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

### Marathon CLI Default Command Usage

Source: https://docs.marathonlabs.io/runner/intro/execute

Demonstrates the default command behavior, which is equivalent to the 'run' command, allowing a simplified syntax.

```bash
foo@bar $ marathon -m MARATHONFILE  
```

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

### Add CLI to PATH

Source: https://docs.marathonlabs.io/runner/intro/contribute

Export the built CLI binary to your system's PATH for easier access. Replace MARATHON_CHECKOUT_DIR with the actual path to your Marathon checkout.

```bash
foo@bar $ export PATH=$PATH:$MARATHON_CHECKOUT_DIR/cli/build/install/marathon/bin  
```

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

### List Available Simulator Device Types

Source: https://docs.marathonlabs.io/runner/apple/workers

Use the `xcrun simctl list devicetypes` command to find identifiers for available simulator device types.

```bash
foo@bar $ xcrun simctl list devicetypes
== Device Types ==
iPhone 4s (com.apple.CoreSimulator.SimDeviceType.iPhone-4s)
iPhone 5 (com.apple.CoreSimulator.SimDeviceType.iPhone-5)
iPhone 5s (com.apple.CoreSimulator.SimDeviceType.iPhone-5s)
...
```

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

### Enable Device Log Capture

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Enable this option to capture system logs from the device. Logs will be saved to `$output-folder/device-files` per batch.

```yaml
deviceLog: true

```

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

### Configure Test Run Lifecycle Hooks

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Define actions for test run preparation (`onPrepare`) and disposal (`onDispose`), such as `ERASE` or `SHUTDOWN` simulators. `SHUTDOWN` is generally recommended over `TERMINATE` due to potential simulator instability.

```yaml
lifecycle:
  onPrepare:
    - ERASE
  onDispose:
    - SHUTDOWN
```

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

### Set Device Initialization Timeout in Marathonfile

Source: https://docs.marathonlabs.io/runner/intro/configure

Configure the timeout for device provider initialization in Marathonfile. Defaults to 3 minutes.

```yaml
deviceInitializationTimeoutMillis: 300000  

```

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

### Configure Screen Recorder Type

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Set the preferred type for screen recording. Use `"screenshot"` to prioritize capturing screenshots over video recording.

```yaml
screenRecordConfiguration:
  preferableRecorderType: "screenshot"
```

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

### Configure Raw Application and Test Bundles

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Specifies the paths to the raw application (.app) and test bundle (.xctest) for Marathon to use. Ensure these paths are correct for your build output.

```yaml
application: "build/my.app"
testApplication: "build/my.xctest"
```

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

### ABI Pooling Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices based on their Application Binary Interface (ABI).

```yaml
poolingStrategy:  
  type: "abi"  
```

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

### Omni Pooling Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Configures all connected devices into a single group. This is the default behavior.

```yaml
poolingStrategy:  
  type: "omni"  
```

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

### Configure Pushing Files to Device (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure files and folders to push to Android devices before each test batch execution using Kotlin DSL. This method uses the FilePushEntry class.

```kotlin
marathon {
  fileSyncConfiguration {
    push.add(FilePushEntry("/home/user/folder"))
    push.add(FilePushEntry("/home/user/testfile.txt"))
  }
}

```

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

### Configure Multiple ADB Servers (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Specify multiple ADB server endpoints for distributed test execution. Ensure remote ADB servers are exposed to external traffic.

```yaml
vendorConfiguration:
  type: "Android"
  adbServers:
    - host: 127.0.0.1
    - host: 10.0.0.2
      port: 5037

```

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

### Build CLI Distribution

Source: https://docs.marathonlabs.io/runner/intro/contribute

Build the CLI distribution of Marathon using the Gradle wrapper. This task compiles the binary with all its dependencies.

```bash
foo@bar $ ./gradlew :cli:installDist  
```

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

### Execute Marathon tests

Source: https://docs.marathonlabs.io/runner

Execute tests using the marathon command after connecting devices. The output shows the progress of test execution.

```bash
foo@bar:~$ marathon
00% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.AdbActivityTest#testUnsafeAccess started
03% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.AdbActivityTest#testUnsafeAccess failed
03% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.ScreenshotTest#testScreencapture started
05% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.ScreenshotTest#testScreencapture failed
05% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.ParameterizedTest#test[0] started
08% | [omni]-[127.0.0.1:5037:emulator-5554] com.example.ParameterizedTest#test[0] ended
...
```

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

### Configure Kotlin DSL Screen Recording

Source: https://docs.marathonlabs.io/runner/android/configure

Set screen recording parameters using Kotlin DSL, including recorder type, video, and screenshot configurations. Be aware of the 180-second video limit.

```kotlin
marathon {
  screenRecordConfiguration = ScreenRecordConfiguration(
    RecorderType.SCREENSHOT,
    VideoConfiguration(
      false, //enabled
      1080, //width
      1920, //height
      2, //Bitrate in Mbps
      300 //Max duration in seconds
    ),
    ScreenshotConfiguration(
      false, //enabled
      1080, //width
      1920, //height
      200 //Delay between taking screenshots
    )
  )
}

```

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

### Enable Window Animations (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure Marathon to enable window animations during test execution. By default, animations are disabled.

```yaml
vendorConfiguration:
  type: "Android"
  disableWindowAnimation: false

```

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

### OS Version Pooling Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices based on their operating system version, such as '24' or '25'.

```yaml
poolingStrategy:  
  type: "os-version"  
```

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

### Enable Compact Output

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Toggle compact output mode to remove timestamps from log entries, making the output more concise. Set to `true` to enable.

```yaml
compactOutput: true

```

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

### Configure Pulling Files from Device (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure which files and folders to pull from Android devices after test execution. Specify the relative path, aggregation mode, and path root.

```yaml
vendorConfiguration:
  type: "Android"
  fileSyncConfiguration:
    pull:
      - relativePath: "my-device-folder1"
        aggregationMode: TEST_RUN
        pathRoot: EXTERNAL_STORAGE
      - relativePath: "my-device-folder2"
        aggregationMode: DEVICE
        pathRoot: EXTERNAL_STORAGE
      - relativePath: "my-device-folder3"
        aggregationMode: DEVICE_AND_POOL
        pathRoot: EXTERNAL_STORAGE
      - relativePath: "my-device-folder4"
        aggregationMode: POOL
        pathRoot: EXTERNAL_STORAGE

```

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

### Marathon CLI Parse Command Help

Source: https://docs.marathonlabs.io/runner/intro/execute

Displays help for the 'parse' command, which lists tests without executing them.

```bash
foo@bar $ marathon parse -h  
Usage: marathon parse [<options>]  
  
  Print the list of tests without executing them  
  
Options:  
  -m, --marathonfile=<path>  Marathonfile file path  
  -o, --output=<text>        Output file name in yaml format  
  -f, --include-flaky-tests=<value>  
                             Include/exclude flaky tests that will have  
                             preventive retries according to the current  
                             flakinessStrategy  
  -h, --help                 Show this message and exit  
```

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

### Set ADB Initialization Timeout (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Specify 'adbInitTimeoutMillis' in the Marathonfile to adjust the ADB initialization timeout in milliseconds.

```yaml
vendorConfiguration:
  type: "Android"
  adbInitTimeoutMillis: 60000
```

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

### Configure Graphite Analytics in Marathonfile

Source: https://docs.marathonlabs.io/runner/configuration/analytics

Set up Graphite as the analytics backend using Marathonfile. Specify the host, port, and an optional prefix for metrics. The 'readOnly' flag indicates if the backend is write-protected.

```yaml
analyticsConfiguration:
  type: "graphite"
  host: "influx.svc.cluster.local"
  port: "8080"
  prefix: "prf"
  defaults:
    successRate: 0.1
    duration: "PT300S"
  readOnly: false

```

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

### Configure Execution Strategy to Any Success (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/intro/configure

Configure the execution strategy to `ANY_SUCCESS` using the Kotlin DSL. This is the default strategy and works best without complex sharding.

```kotlin
marathon {
  executionStrategy = ExecutionStrategyConfiguration(ExecutionMode.ANY_SUCCESS)
}
```

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

### Configuring Marathon Output Directory in Gradle (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/dynamic-configuration

Configure the Marathon output directory in your Gradle build script using the Kotlin DSL. Use the `property()` function to read dynamic properties passed via the command line.

```kotlin
marathon {
  output = property("marathonOutputDir")
}

```

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

### Configure Pushing Files to Device (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure files and folders to push to Android devices before each test batch execution using Marathonfile. By default, files are pushed to LOCAL_TMP.

```yaml
vendorConfiguration:
  type: "Android"
  fileSyncConfiguration:
    push:
      - path: "/home/user/folder"
      - path: "/home/user/testfile.txt"

```

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

### Serve HTML Reports Locally with Python HTTP Server

Source: https://docs.marathonlabs.io/runner/intro/faq

If your logs or screenshots are missing from the HTML report when opening with `file://`, you can serve the report directory using a local web server. This bypasses browser security restrictions.

```bash
python3 -m http.server 8000
```

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

### Configure Pushing Files to Device (Groovy DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure files and folders to push to Android devices before each test batch execution using Groovy DSL. This method uses the FilePushEntry class.

```groovy
marathon {
  fileSyncConfiguration {
    push.add(new FilePushEntry("/home/user/folder"))
    push.add(new FilePushEntry("/home/user/testfile.txt"))
  }
}

```

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

### Configure Pulling Files from Device (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure which files and folders to pull from Android devices after test execution using Kotlin DSL. This method uses the FileSyncEntry class.

```kotlin
marathon {
  fileSyncConfiguration {
    pull.add(
      FileSyncEntry(
        "my-device-folder1",
        AggregationMode.TEST_RUN,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder2",
        AggregationMode.DEVICE,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder3",
        AggregationMode.DEVICE_AND_POOL,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder4",
        AggregationMode.POOL,
        PathRoot.EXTERNAL_STORAGE
      )
    )
  }
}

```

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

### Configure Archive Application and Test Bundles

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Specifies the paths to application archives (.ipa) and zip files containing test bundles (.zip). Marathon will extract the necessary bundles from these archives.

```yaml
application: "build/my.ipa"
testApplication: "build/my.zip"
```

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

### Configure Screenshot Recording

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Enable screenshot recording and configure parameters such as image type, display, mask, dimensions, and frame delay. The `delay` uses ISO 8601 duration format.

```yaml
screenRecordConfiguration:
  screenshotConfiguration:
    enabled: true
    type: jpeg
    display: internal
    mask: black
    width: 720
    height: 1280
    # ISO_8601 duration
    delay: PT1S
```

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

### Device Model Pooling Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices by their specific model name, like LG-D855 or SM-N950F.

```yaml
poolingStrategy:  
  type: "device-model"  
```

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

### OS Version Pooling Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices based on their operating system version using Kotlin DSL.

```kotlin
marathon {
  poolingStrategy {
    operatingSystem = true
  }
}
```

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

### Configure Multiple ADB Servers (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Define multiple ADB server endpoints using Kotlin DSL for distributed test execution. Ensure remote ADB servers are exposed to external traffic.

```kotlin
marathon {
  adbServers = listOf(
    AdbEndpoint(host = "127.0.0.1"),
    AdbEndpoint(host = "10.0.0.2", port = 5037)
  )
}

```

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

### Probability Based Flakiness Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/flakiness

Configure a probability-based flakiness strategy to maximize the chance of test success by retrying. Specify the minimum success rate, maximum retry count, and a time limit for the strategy.

```yaml
flakinessStrategy:  
  type: "probability"  
  minSuccessRate: 0.7  
  maxCount: 3  
  timeLimit: "2015-03-14T09:26:53.590Z"  

```

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

### ABI Pooling Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices based on their Application Binary Interface (ABI) using Kotlin DSL.

```kotlin
marathon {
  poolingStrategy {
    abi = true
  }
}
```

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

### Marathonfile: Running Specific Tests by FQTN

Source: https://docs.marathonlabs.io/runner/configuration/filtering

Execute a specific list of tests using their Fully Qualified Test Names (FQTN) in the Marathonfile format.

```yaml
filteringConfiguration:
  allowlist:
    - type: "fully-qualified-test-name"
      values:
        - "com.example.ElaborateTest#testMethod"
        - "com.example.subpackage.OtherTest#testSomethingElse"

```

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

### Set Device Initialization Timeout in Kotlin DSL

Source: https://docs.marathonlabs.io/runner/intro/configure

Configure the timeout for device provider initialization using the Kotlin DSL. Defaults to 3 minutes.

```kotlin
marathon {
  deviceInitializationTimeoutMillis = 300000  
}

```

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

### Allowlist Smoke Tests using Annotation

Source: https://docs.marathonlabs.io/runner/configuration/filtering

Configure an allowlist to include only tests annotated with 'com.example.SmokeTest'. This is useful for running a specific subset of tests.

```yaml
filteringConfiguration:
  allowlist:
    - type: "annotation"
      values:
        - "com.example.SmokeTest"

```

```kotlin
marathon {
  filteringConfiguration {
    allowlist {
      add(AnnotationFilterConfiguration(values = listOf("com.example.SmokeTest")))
    }
  }
}

```

```kotlin
marathon {
  filteringConfiguration {
    allowlist {
      annotationFilter = ['com.example.SmokeTest']
    }
  }
}

```

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

### Kotlin DSL: Running Specific Tests by FQTN

Source: https://docs.marathonlabs.io/runner/configuration/filtering

Configure the execution of specific tests using their Fully Qualified Test Names (FQTN) via the Kotlin DSL.

```kotlin
marathon {
  filteringConfiguration {
    allowlist {
      add(
        FullyQualifiedTestnameFilterConfiguration(
          values = listOf(
            "com.example.ElaborateTest#testMethod",
            "com.example.subpackage.OtherTest#testSomethingElse",
          )
        )
      )
    }
  }
}

```

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

### Configuring Marathon Output Directory in Gradle (Groovy DSL)

Source: https://docs.marathonlabs.io/runner/configuration/dynamic-configuration

Configure the Marathon output directory in your Gradle build script using the Groovy DSL. Use the `property()` function to read dynamic properties passed via the command line.

```groovy
marathon {
  output = property('marathonOutputDir')
}

```

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

### Configure 'xctest' Test Parser

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Select the 'xctest' parser for precise test parsing and support for runtime-generated tests, enabling parallel execution. This requires a booted device and a fake test run.

```yaml
testParserConfiguration:
  type: "xctest"

```

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

### Enable Test Access Configuration (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Enable advanced test access features such as ADB, gRPC, and console communication using the Kotlin DSL. This provides tests with enhanced control over the device.

```kotlin
marathon {
  testAccessConfiguration = TestAccessConfiguration(
    adb = true,
    grpc = true,
    console = true,
    consoleToken = "cantFoolMe"
  )
}

```

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

### Run Tests and Lint

Source: https://docs.marathonlabs.io/runner/intro/contribute

Execute unit and integration tests, generate a JaCoCo test report, and run the detekt linter to check code quality before pushing changes.

```bash
./gradlew clean test jacocoTestReport integrationTest
```

```bash
./gradlew clean detektCheck
```

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

### Apply Marathon Gradle Plugin (Groovy DSL)

Source: https://docs.marathonlabs.io/runner/android/install

Apply the Marathon Gradle plugin using Groovy DSL. This provides an alternative syntax for integrating the plugin.

```groovy
plugins {
  id 'com.malinskiy.marathon' version 'X.X.X'
}

```

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

### Configure Screen Recording Policy

Source: https://docs.marathonlabs.io/runner/intro/configure

Set `screenRecordingPolicy` to `"ON_ANY"` to save screen recordings for all tests, regardless of their pass/failure status. The default is `ON_FAILURE` to save space and reduce test duration.

```yaml
screenRecordingPolicy: "ON_ANY"  
```

```kotlin
marathon {
  screenRecordingPolicy = ScreenRecordingPolicy.ON_ANY
}
```

```groovy
marathon {
  screenRecordingPolicy = ScreenRecordingPolicy.ON_ANY
}
```

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

### Set Base Output Directory in Kotlin DSL

Source: https://docs.marathonlabs.io/runner/intro/configure

Configure the base output directory for runner artifacts using the Kotlin DSL. This path is relative to the Marathonfile.

```kotlin
marathon {
  baseOutputDir = "some-path"  
}

```

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

### Configure Pulling Files from Device (Groovy DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure which files and folders to pull from Android devices after test execution using Groovy DSL. This method uses the FileSyncEntry class.

```groovy
marathon {
  fileSyncConfiguration {
    pull.add(
      new FileSyncEntry(
        "my-device-folder1",
        AggregationMode.TEST_RUN,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder2",
        AggregationMode.DEVICE,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder3",
        AggregationMode.DEVICE_AND_POOL,
        PathRoot.EXTERNAL_STORAGE
      )
    )
    pull.add(
      FileSyncEntry(
        "my-device-folder4",
        AggregationMode.POOL,
        PathRoot.EXTERNAL_STORAGE
      )
    )
  }
}

```

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

### Enable AndroidX ScreenCapture API

Source: https://docs.marathonlabs.io/runner/android/configure

Integrate with AndroidX ScreenCapture API for automatic screenshot pulling. Requires adding a specific annotation producer and enabling a custom processor.

```kotlin
Screenshot.addScreenCaptureProcessors(setOf(AdamScreenCaptureProcessor()))

```

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

### Specify iOS Vendor Configuration

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Use this to indicate that you are using a vendor configuration for iOS.

```yaml
vendorConfiguration:
  type: "iOS"
  additional_option1: ...
  additional_option2: ...
```

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

### Device Model Pooling Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices by their specific model name using Kotlin DSL.

```kotlin
marathon {
  poolingStrategy {
    model = true
  }
}
```

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

### Configure Android SDK Path

Source: https://docs.marathonlabs.io/runner/android/configure

Specify the Android SDK path if it cannot be automatically detected. This is required for CLI usage without environment variables.

```yaml
vendorConfiguration:
  type: "Android"
  androidSdk: "/usr/share/local/android"
```

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

### Set ADB Initialization Timeout (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure 'adbInitTimeout' in milliseconds using Kotlin DSL to adjust the ADB initialization timeout.

```kotlin
marathon {
  adbInitTimeout = 100000
}
```

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

### Ignore Flakiness Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/flakiness

Use this strategy to disable any preventative measures for flakiness. This is the default behavior.

```yaml
flakinessStrategy:  
  type: "ignore"  

```

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

### Manufacturer Pooling Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices by their manufacturer, such as Samsung or Yota.

```yaml
poolingStrategy:  
  type: "manufacturer"  
```

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

### Specify tvOS Vendor Configuration

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Use this to indicate that you are using a vendor configuration for tvOS.

```yaml
vendorConfiguration:
  type: "tvOS"
  additional_option1: ...
  additional_option2: ...
```

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

### Run Android Tests with Marathon Cloud CLI

Source: https://docs.marathonlabs.io/demo/ios/html/pools/omni/55CADA10-DB80-4A64-954C-80635FE50E04-malinskiy-192.168.2.27-22/sample_appUITests.MoreTests.testPresentModal.html

Set your Marathon Cloud API key as an environment variable and then use the marathon-cloud CLI to run your Android tests. Provide the paths to your application and test application APK files.

```bash
export MARATHON_CLOUD_API_KEY=generated_api_key  
marathon-cloud run android --application app.apk --test-application appTest.apk  

```

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

### Run iOS Tests with Marathon Cloud CLI

Source: https://docs.marathonlabs.io/demo/ios/html/pools/omni/55CADA10-DB80-4A64-954C-80635FE50E04-malinskiy-192.168.2.27-22/sample_appUITests.MoreTests.testPresentModal.html

Set your Marathon Cloud API key as an environment variable and then use the marathon-cloud CLI to run your iOS tests. Provide the paths to your application and test application zip files.

```bash
export MARATHON_CLOUD_API_KEY=generated_api_key  
marathon-cloud run ios --application sample.zip --test-application sampleUITests-Runner.zip  

```

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

### Configure Multi-Module APK Paths

Source: https://docs.marathonlabs.io/runner/android/configure

For multi-module testing, specify both application and test application APKs for each module. This mode is not supported by the Gradle Plugin.

```yaml
vendorConfiguration:
  type: "Android"
  outputs:
    - application: "dist/app-debug.apk"
      testApplication: "dist/app-debug-androidTest.apk"
    - testApplication: "dist/library-debug-androidTest.apk"
```

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

### Probability Based Flakiness Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/flakiness

Configure a probability-based flakiness strategy using the Kotlin DSL. This strategy retries tests to ensure a minimum success rate within a specified time.

```kotlin
marathon {
  flakinessStrategy {
    probabilityBased {
      minSuccessRate = 0.7
      maxCount = 3
      timeLimit = Instant.now().minus(Duration.parse("PT1H"))
    }
  }
}

```

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

### Specify watchOS Vendor Configuration

Source: https://docs.marathonlabs.io/runner/apple/configure/ios

Use this to indicate that you are using a vendor configuration for watchOS.

```yaml
vendorConfiguration:
  type: "watchOS"
  additional_option1: ...
  additional_option2: ...
```

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

### Enable Automatic Permission Granting (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure 'autoGrantPermission' to true using Kotlin DSL for automatic runtime permission granting.

```kotlin
marathon {
  autoGrantPermission = true
}
```

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

### Manufacturer Pooling Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Groups devices by their manufacturer using Kotlin DSL.

```kotlin
marathon {
  poolingStrategy {
    manufacturer = true
  }
}
```

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

### Configure Application APK Path

Source: https://docs.marathonlabs.io/runner/android/configure

Specify the path to the application APK for single module testing. This is automatically detected when using the Gradle Plugin.

```yaml
vendorConfiguration:
  type: "Android"
  applicationApk: "dist/app-debug.apk"
```

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

### iOS Marathonfile Configuration

Source: https://docs.marathonlabs.io/runner/intro/overview

Configure Marathon for iOS projects. Specify the output directory and the application and test application bundles.

```yaml
name: "My application"  
outputDir: "derived-data/Marathon"  
vendorConfiguration:  
  type: "iOS"  
  bundle:  
    application: "sample.app"  
    testApplication: "sampleUITests.xctest"  
    testType: xcuitest  

```

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

### Count Sharding Strategy (Marathonfile)

Source: https://docs.marathonlabs.io/runner/configuration/sharding

Configures Marathon to execute each test a specified number of times within each pool, useful for testing flakiness.

```yaml
shardingStrategy:  
  type: "count"  
  count: 5  
```

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

### Run Android Tests with Marathon Cloud CLI

Source: https://docs.marathonlabs.io/cli/parameters

Use this command to submit test runs for Android applications. Specify test application, API key, and other optional parameters like OS version, system image, and output folder.

```bash
--> marathon-cloud run android -h  
                                                   
Run tests for Android  
  
Usage: marathon-cloud run android [OPTIONS] --test-application <TEST_APPLICATION> --api-key <API_KEY>  
  
Options:  
  -a, --application <APPLICATION>  
          application filepath, example: /home/user/workspace/sample.apk  
  -t, --test-application <TEST_APPLICATION>  
          test application filepath, example: /home/user/workspace/testSample.apk  
      --os-version <OS_VERSION>  
          OS version [10, 11, 12, 13]  
      --system-image <SYSTEM_IMAGE>  
          Runtime system image [possible values: default, google-apis]  
  -v, --verbose...  
          More output per occurrence  
  -o, --output <OUTPUT>  
          Output folder for test run results  
  -q, --quiet...  
          Less output per occurrence  
      --isolated <ISOLATED>  
          Run each test in isolation, i.e. isolated batching. [possible values: true, false]  
      --filter-file <FILTER_FILE>  
          Test filters supplied as a YAML file following the schema at https://docs.marathonlabs.io/runner/configuration/filtering/#filtering-logic. For iOS see also https://docs.marathonlabs.io/runner/next/ios#test-plans  
      --wait  
          Wait for test run to finish if true, exits after triggering a run if false  
      --name <NAME>  
          name for run, for example it could be description of commit  
      --link <LINK>  
          link to commit  
      --api-key <API_KEY>  
          Marathon Cloud API key [env: MARATHON_CLOUD_API_KEY=]  
      --base-url <BASE_URL>  
          Base url for Marathon Cloud API [default: https://cloud.marathonlabs.io/api/v1]  
      --instrumentation-arg <INSTRUMENTATION_ARG>  
          Instrumentation arguments, example: FOO=BAR  
  -h, --help  
          Print help  
```

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

### Analyze Marathon test run summary

Source: https://docs.marathonlabs.io/runner

View the summary of a Marathon test run, including passed, failed, and ignored tests, flakiness overhead, and incomplete tests. This provides an overview of the execution.

```bash
foo@bar:~$ marathon
...
...
...
Marathon run finished:
Device pool omni:
        22 passed, 15 failed, 3 ignored tests
        Failed tests:
                com.example.MainActivityFlakyTest#testTextFlaky
                ...
        Flakiness overhead: 1849ms
        Raw: 22 passed, 15 failed, 3 ignored, 6 incomplete tests
                com.example.MainActivityFlakyTest#testTextFlaky failed 1 time(s)
        Incomplete tests:
                com.example.BeforeTestFailureTest#testThatWillNotSeeTheLightOfDay incomplete 3 time(s)
Total time: 0H 1m 45s
Marathon execution failed
```

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

### Configure No Retries

Source: https://docs.marathonlabs.io/runner/configuration/retries

Use this strategy when no retries should be performed. This is the default behavior.

```yaml
retryStrategy:  
  type: "no-retry"  
```

```kotlin
marathon {
  retryStrategy {}
}

```

```groovy
marathon {
  retryStrategy {}
}

```

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

### Configure SSH Public Key Authentication

Source: https://docs.marathonlabs.io/runner/apple/configure/macos

Sets up SSH to use public key authentication for remote workers. Requires specifying the username and the path to the private key.

```yaml
ssh:
  authentication:
    type: "publicKey"
    username: "username"
    key: "/home/user/.ssh/id_rsa"
```

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

### Configure Remote macOS Desktop Devices (SSH)

Source: https://docs.marathonlabs.io/runner/apple/workers

Configuration for using remote macOS instances via SSH for desktop app testing. Multiple remote workers can be defined.

```yaml
workers:
  - transport:
      type: ssh
      addr: 10.0.0.2
    devices:
      - type: host
  - transport:
      type: ssh
      addr: 10.0.0.3
    devices:
      - type: host

```

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

### Omni Pooling Strategy (Kotlin DSL)

Source: https://docs.marathonlabs.io/runner/configuration/pooling

Configures all connected devices into a single group using Kotlin DSL. This is the default behavior.

```kotlin
marathon {
  poolingStrategy {}
}
```

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

### Enable Test Access Configuration (Marathonfile)

Source: https://docs.marathonlabs.io/runner/android/configure

Configure advanced test access features like ADB, gRPC, and console access for your Android tests. This allows tests to interact with the device more deeply.

```yaml
vendorConfiguration:
  type: "Android"
  testAccessConfiguration:
    adb: true
    grpc: true
    console: true
    consoleToken: "cantFoolMe"

```
Tokens:
Raw