Usage: java io.cucumber.core.cli.Main [options] [ PATH[.feature[:LINE]*] | URI[.feature[:LINE]*] | @PATH ]+

Options:

      --threads COUNT                      Number of threads to run tests under.
                                           Defaults to 1.

  -g, --glue PATH                          Package to load glue code (step
                                           definitions, hooks and plugins) from
                                           e.g: com.example.app.
                                           When neither glue, nor glue classes
                                           are  provided Cucumber will search
                                           the classpath.

  --glue-class FQCN                        A fully qualified glue class name
                                           e.g: com.example.app.StepDefinitions.
                                           When neither glue, nor glue classes
                                           are  provided Cucumber will search
                                           the classpath.

   --glue-[included|excluded]-class-name-pattern PATTERN
                                            A pattern for to include or classes
                                            from classpath scanning. e.g:
                                            .*StepDefinitions?|.*Hooks?

  -p, --plugin PLUGIN[:[PATH|[URI [OPTIONS]]]
                                           Register a plugin.
                                           Built-in PLUGIN types:
                                           html, json, junit, message, pretty,
                                           progress, rerun, summary, teamcity,
                                           testng, timeline, usage, unused

                                           PLUGIN can also be a fully
                                           qualified class name, allowing
                                           registration of 3rd party plugins.

                                           If a http:// or https:// URI is used,
                                           the output will be sent as a PUT
                                           request. This can be overridden by
                                           providing additional options.

                                           OPTIONS supports cUrls -X and -H
                                           commands.

  -t, --tags TAG_EXPRESSION                Only run scenarios tagged with tags
                                           matching TAG_EXPRESSION.

  -n, --name REGEXP                        Only run scenarios whose names match
                                           REGEXP.

  -d, --[no-]dry-run                       Skip execution of glue code.

  -m, --[no-]monochrome                    Don't colour terminal output.

      --snippets [underscore|camelcase]    Naming convention for generated
                                           snippets. Defaults to underscore.

  -v, --version                            Print version.

  -h, --help                               You're looking at it.
      --i18n-languages                     List all languages with a Gherkin
                                           localization
      --i18n-keywords LANG                 List keywords for in a particular
                                           Gherkin localization

  -w, --wip                                Fail if there are any passing
                                           scenarios.


      --order                              Run the scenarios in a different
                                           order. The options are 'reverse' and
                                           'random'. In case of 'random' order
                                           an optional seed parameter can be
                                           added 'random:<seed>'.

      --count                              Number of scenarios to be executed.
                                           If not specified all scenarios are
                                           run.

      --object-factory CLASSNAME           Uses the class specified by CLASSNAME
                                           as object factory. Be aware that the
                                           class is loaded through a service
                                           loader and therefore also needs to
                                           be specified in:
                                           META-INF/services/io.cucumber.core.backend.ObjectFactory

      --uuid-generator CLASSNAME           Uses the class specified by CLASSNAME
                                           as UUID generator. Be aware that the
                                           class is loaded through a service
                                           loader and therefore also needs to
                                           be specified in:
                                           META-INF/services/io.cucumber.core.eventbus.UuidGenerator

Feature path examples:
                                           When no feature path is provided
                                           cucumber will scan the classpath root
                                           and its sub directories.

  <path>                                   Load the files with the extension
                                           ".feature" for the directory <path>
                                           and its sub directories.

  <path>/<name>.feature                    Load the feature file
                                           <path>/<name>.feature from the file
                                           system.

  classpath:<path>/<name>.feature          Load the feature file
                                           <path>/<name>.feature from the
                                           classpath.

  <path>/<name>.feature:3:9                Load the scenarios on line 3 and line
                                           9 in the file <path>/<name>.feature.

  @<path>                                  Load all files in the <path> from the
                                           file system and parse feature paths
                                           generated by the rerun formatter.

  @<path>/<file>                           Load <path>/<file> from the file
                                           system and parse feature paths
                                           generated by the rerun formatter.


Properties, Environment variables and System properties:

Cucumber will in order of precedence parse properties from system properties,
environment variables and the `cucumber.properties` file.

Note that options provided by `@CucumberOptions` takes precedence over the
properties file and CLI arguments take precedence over all.

Supported properties are:

```
cucumber.ansi-colors.disabled=              # true or false. default: false

cucumber.execution.dry-run=                 # true or false. default: false

cucumber.execution.limit=                   # number of scenarios to execute (CLI only).

cucumber.execution.order=                   # lexical, reverse, random or random:[seed] (CLI only). default: lexical

cucumber.execution.wip=                     # true or false. default: false.
                                            # Fails if there any passing scenarios
                                            # CLI only.

cucumber.execution.threads=                 # number of threads used to execute scenarios (CLI only).

cucumber.features=                          # comma separated list of feature paths.
                                            # format: [ PATH[.feature[:LINE]*] | URI[.feature[:LINE]*] | @PATH ]
                                            # example: path/to/features, classpath:com/example/features, path/to/example.feature:42, @path/to/rerun.txt

cucumber.filter.name=                       # a regular expression
                                            # only scenarios with matching names are executed.
                                            # combined with cucumber.filter.tags using "and" semantics.
                                            # example: ^Hello (World|Cucumber)$

cucumber.filter.tags=                       # a cucumber tag expression.
                                            # only scenarios with matching tags are executed.
                                            # combined with cucumber.filter.name using "and" semantics.
                                            # example: @Cucumber and not (@Gherkin or @Zucchini)

cucumber.glue=                              # comma separated package names.
                                            # example: com.example.glue

cucumber.glue.classes=                      # comma separated class names.
                                            # example: com.example.StepDefinitionsA, com.example.StepDefinitionsB
                                            # note: classes that are explicitly included are not filtered by either the
                                            # included or excluded class name patterns

cucumber.glue.included-class-name-pattern=  # pattern for included glue classes
                                            # example: .*StepDefinitions?|.*Hooks?

cucumber.glue.excluded-class-name-pattern=  # pattern for excluded glue classes
                                            # example: .*UnwantedStepDefinitions?|.*UnwantedHooks?

cucumber.glue.hint.enabled=                 # true or false
                                            # default: true
                                            # enable displaying glue hint in case of inneficient configuration.

cucumber.glue.hint.threshold=               # threshold value as an ISO-8601 duration string
                                            # default: PT0.1S
                                            # if the expected gain is higher than this value, the glue hint is displayed.

cucumber.plugin=                            # comma separated plugin strings.
                                            # example: pretty, json:path/to/report.json
                                            # example: com.example.MyCustomPlugin:path/to/report.xml

cucumber.object-factory=                    # object factory class name.
                                            # example: com.example.MyObjectFactory

cucumber.uuid-generator                     # uuid generator class name of a registered service provider.
                                            # default: io.cucumber.core.eventbus.RandomUuidGenerator
                                            # example: com.example.MyUuidGenerator

cucumber.publish.enabled                    # true or false. default: false
                                            # enable publishing of test results

cucumber.publish.quiet                      # true or false. default: false
                                            # suppress publish banner after test execution

cucumber.publish.token                      # any string value.
                                            # publish authenticated test results

cucumber.publish.url                        # a valid url
                                            # location to publish test reports to

cucumber.snippet-type=                      # underscore or camelcase.
                                            # default: underscore
```

Each property also has an `UPPER_CASE` and `snake_case` variant. For example
`cucumber.ansi-colors.disabled` would also be understood as
`CUCUMBER_ANSI_COLORS_DISABLED` and `cucumber_ansi_colors_disabled`.
