Annotated method style:

@Given("the following animals:")
public void the_following_animals(List<String> animals) {
}

Annotated method style:

@Before
public void doSomethingBefore() {
}

Lambda style:

Before(() -> {
});

You can specify an explicit order for hooks if you need to.

Annotated method style:

@Before(order = 10)
public void doSomething(){
    // Do something before each scenario
}

Lambda style:

Before(10, () -> {
    // Do something before each scenario
});

Annotated method style:

@After
public void doSomethingAfter(Scenario scenario){
    // Do something after after scenario
}

Lambda style:

After((Scenario scenario) -> {
});

Annotated method style:

@BeforeStep
public void doSomethingBeforeStep(Scenario scenario){
}

Lambda style:

BeforeStep((Scenario scenario) -> {

});

Annotated method style:

@AfterStep
public void doSomethingAfterStep(Scenario scenario){
}

Lambda style:

AfterStep((Scenario scenario) -> {
});

Annotated method style:

@After("@browser and not @headless")
public void doSomethingAfter(Scenario scenario){
}

Lambda style:

After("@browser and not @headless", (Scenario scenario) -> {
});

Annotated method style:

@BeforeAll
public static void beforeAll() {
    // Runs before all scenarios
}

Annotated method style:

@AfterAll
public static void afterAll() {
    // Runs after all scenarios
}

For JUnit 5 see the cucumber-junit-platform-engine documentation

For JUnit 4 and TestNG using a JVM system property:

mvn test -Dcucumber.filter.tags="@smoke and @fast"

Or an environment variable:

# Linux / OS X:
CUCUMBER_FILTER_TAGS="@smoke and @fast" mvn test

# Windows:
set CUCUMBER_FILTER_TAGS="@smoke and @fast"
mvn test

Or changing your JUnit 4/TestNG runner class:

@CucumberOptions(tags = "@smoke and @fast")
public class RunCucumberTest {}

Using JUnit runner class:

@CucumberOptions(tags = "not @smoke")
public class RunCucumberTest {}

Cucumber is a Java library with extensions for different tools and platforms. It is launched by running JUnit 4, JUnit 5, your build tool, your IDE or the CLI.

The Command-Line Interface Runner (CLI Runner) is an executable Java class that can be run from the command-line.

java io.cucumber.core.cli.Main

Note that you will need to add the cucumber-core jar and all of its transitive dependencies to your classpath, in addition to the location of your compiled .class files. You can find these jars in Maven Central.

You will also need to provide the CLI with your step definitions via the --glue option followed by its package name, and the filepath of your feature file(s).

For example:

java -cp "path/to/each/jar:path/to/compiled/.class/files" io.cucumber.core.cli.Main /path/to/your/feature/files --glue hellocucumber --glue anotherpackage

Alternatively if you are using a Maven project, you can run the CLI using the Exec Maven plugin:

mvn exec:java                                  \
    -Dexec.classpathScope=test                 \
    -Dexec.mainClass=io.cucumber.core.cli.Main \
    -Dexec.args="/path/to/your/feature/files --glue hellocucumber --glue anotherpackage"

See the cucumber-junit-platform-engine documentation for more information.

To use JUnit to execute cucumber scenarios add the cucumber-junit dependency to your pom.

<dependencies>
  [...]
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-junit</artifactId>
        <version>${cucumber.version}</version>
        <scope>test</scope>
    </dependency>
  [...]
</dependencies>

Note that cucumber-junit is based on JUnit 4. If you’re using JUnit 5, use the cucumber-junit-platform-engine or include junit-vintage-engine dependency, as well. For more information, please refer to JUnit 5 documentation

Create an empty class that uses the Cucumber JUnit runner.

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions()
public class RunCucumberTest {
}

package com.example

import io.cucumber.junit.Cucumber
import io.cucumber.junit.CucumberOptions
import org.junit.runner.RunWith

@RunWith(Cucumber::class)
@CucumberOptions()
class RunCucumberTest {
}

package com.example

import io.cucumber.junit.Cucumber
import io.cucumber.junit.CucumberOptions
import org.junit.runner.RunWith

@RunWith(classOf[Cucumber])
@CucumberOptions()
class RunCucumberTest {
}

This will execute all scenarios in same package as the runner, by default glue code is also assumed to be in the same package.

The @CucumberOptions can be used to provide additional configuration to the runner.

Using plugins:

For example if you want to tell Cucumber to use the two formatter plugins pretty and html, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(plugin = {"pretty", "html:target/cucumber.html"})
public class RunCucumberTest {
}

For example if you want to tell Cucumber to print code snippets for missing step definitions use the summary plugin, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(plugin = {"pretty", "summary"}, snippets = SnippetType.CAMELCASE)
public class RunCucumberTest {
}

The default option for snippets is UNDERSCORE. This settings can be used to specify the way code snippets will be created by Cucumber.

Performing a dry-run:

For example if you want to check whether all feature file steps have corresponding step definitions, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(dryRun=true)
public class RunCucumberTest {
}

The default option for dryRun is false.

Formatting console output:

For example if you want console output from Cucumber in a readable format, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(monochrome=true)
public class RunCucumberTest {
}

The default option for monochrome is false.

Select scenarios using tags:

For example if you want to tell Cucumber to only run the scenarios specified with specific tags, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(tags = "@foo and not @bar")
public class RunCucumberTest {
}

Specify an object factory:

For example if you are using Cucumber with a DI framework and want to use a custom object factory, you can specify it like this:

package com.example;

import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@CucumberOptions(objectFactory = FooFactory.class)
public class RunCucumberTest {
}

The default option for objectFactory is to use the default object factory. Additional information about using custom object factories can be found here

There are additional options available in the @CucumberOptions annotation.

Usually, the test class will be empty. You can, however, specify several JUnit rules.

The Cucumber runner acts like a suite of a JUnit tests. As such other JUnit features such as Categories, Custom JUnit Listeners and Reporters can all be expected to work.

For more information on JUnit, see the JUnit website

Pass the --help option to print out all the available configuration options:

java io.cucumber.core.cli.Main --help

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

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

Note that the cucumber-junit-platform-engine is provided with properties by the Junit Platform rather than Cucumber. See junit-platform-engine Configuration Options for more information.

For example, if you are using Maven and want to run a subset of scenarios tagged with @smoke:

mvn test -Dcucumber.filter.tags="@smoke"

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.
cucumber.features=              # comma separated paths to feature files. example: path/to/example.feature, path/to/other.feature
cucumber.filter.name=           # regex. example: .*Hello.*
cucumber.filter.tags=           # tag expression. example: @smoke and not @slow
cucumber.glue=                  # comma separated package names. example: com.example.glue
cucumber.plugin=                # comma separated plugin strings. example: pretty, json:path/to/report.json
cucumber.object-factory=        # object factory class name. example: com.example.MyObjectFactory
cucumber.snippet-type=          # underscore or camelcase. default: underscore

Note that the filter options cucumber.filter.name and cucumber.filter.tags are combined using an and operation. In other words, both expressions need to match.