Cucumber JUnit

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

package com.example;

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

@RunWith(Cucumber.class)
@CucumberOptions(plugin = "pretty")
public class RunCucumberTest {
}

@API(status = API.Status.STABLE)
public final class Cucumber extends ParentRunner<ParentRunner<?>> {
    /**
     * Constructor called by JUnit to create the Cucumber runner.
     * Parses configuration options, initializes plugins, and creates feature runners.
     * 
     * @param clazz the test class annotated with @RunWith(Cucumber.class) 
     * @throws InitializationError if feature parsing fails, invalid options are provided,
     *         or the test class contains Cucumber annotations (step definitions/hooks)
     */
    public Cucumber(Class<?> clazz) throws InitializationError;
    
    /**
     * Set custom scheduler for parallel execution of feature files.
     * Enables thread-safe parallel execution across multiple threads.
     * 
     * @param scheduler the RunnerScheduler implementation to control parallel execution
     */
    public void setScheduler(RunnerScheduler scheduler);
}

@RunWith(Cucumber.class)
@CucumberOptions(
    features = "src/test/resources/features",
    glue = "com.example.steps",
    tags = "@smoke and not @slow"
)
public class AcceptanceTest {
}

@API(status = API.Status.STABLE)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface CucumberOptions {
    /** Skip glue code execution */
    boolean dryRun() default false;
    
    /** Feature file paths */
    String[] features() default {};
    
    /** Package paths for step definitions and hooks */
    String[] glue() default {};
    
    /** Additional glue packages */
    String[] extraGlue() default {};
    
    /** Tag expression for filtering scenarios */
    String tags() default "";
    
    /** Register plugins (junit, html, pretty, progress, json, etc.) */
    String[] plugin() default {};
    
    /** Publish reports to https://reports.cucumber.io */
    boolean publish() default false;
    
    /** Disable colored terminal output */
    boolean monochrome() default false;
    
    /** Filter scenarios by name regex */
    String[] name() default {};
    
    /** Format of generated snippets */
    SnippetType snippets() default SnippetType.UNDERSCORE;
    
    /** Use filename compatible names */
    boolean useFileNameCompatibleName() default false;
    
    /** Include steps in notifications */
    boolean stepNotifications() default false;
    
    /** Custom ObjectFactory implementation */
    Class<? extends io.cucumber.core.backend.ObjectFactory> objectFactory() default NoObjectFactory.class;
    
    /** Custom UuidGenerator implementation */
    Class<? extends io.cucumber.core.eventbus.UuidGenerator> uuidGenerator() default NoUuidGenerator.class;
}

@CucumberOptions(
    plugin = "pretty",
    monochrome = true
)

@CucumberOptions(
    features = {"src/test/resources/features/login", "src/test/resources/features/checkout"},
    glue = {"com.example.steps", "com.example.hooks"},
    tags = "@regression and not @slow",
    plugin = {
        "pretty", 
        "html:target/cucumber-reports",
        "json:target/cucumber-reports/Cucumber.json",
        "junit:target/cucumber-reports/Cucumber.xml"
    },
    stepNotifications = true,
    useFileNameCompatibleName = true
)

public enum SnippetType {
    /** Use underscore style for method names */
    UNDERSCORE,
    /** Use camel case style for method names */
    CAMELCASE
}

@CucumberOptions(snippets = SnippetType.CAMELCASE)

@RunWith(Cucumber.class)
public class RunCucumberTest {
    @ClassRule
    public static TestRule rule = new MyTestRule();
    
    @BeforeClass
    public static void setUp() {
        // Runs before all scenarios
    }
    
    @AfterClass
    public static void tearDown() {
        // Runs after all scenarios
    }
}

import static org.junit.Assume.assumeTrue;

@Given("^a precondition is met$")
public void preconditionCheck() {
    assumeTrue("Skipping test due to environment", isEnvironmentReady());
}

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <parallel>both</parallel>
        <threadCount>4</threadCount>
    </configuration>
</plugin>

/**
 * Exception thrown when Cucumber encounters undefined steps during execution.
 * Contains generated code snippets to help implement missing step definitions.
 */
final class UndefinedStepException extends RuntimeException {
    /**
     * Creates exception with snippet suggestions for undefined steps
     * @param suggestions Collection of step definition suggestions with generated code snippets
     */
    UndefinedStepException(Collection<Suggestion> suggestions);
}

// JUnit framework types
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerScheduler;
import org.junit.runner.RunWith;

// Cucumber JUnit types
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import io.cucumber.junit.CucumberOptions.SnippetType;

// Cucumber core types (dependencies)
import io.cucumber.core.backend.ObjectFactory;
import io.cucumber.core.eventbus.UuidGenerator;
import io.cucumber.plugin.event.SnippetsSuggestedEvent.Suggestion;

// Annotation support
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.apiguardian.api.API;

// Java standard library
import java.util.Collection;