diff --git a/.github/workflows/labels-verify.yml b/.github/workflows/labels-verify.yml
index 077315bba..c9980ead9 100644
--- a/.github/workflows/labels-verify.yml
+++ b/.github/workflows/labels-verify.yml
@@ -2,7 +2,7 @@ name: "Verify type labels"
 
 on:
   pull_request:
-    types: [ opened, labeled, unlabeled, synchronize ]
+    types: [ labeled, unlabeled ]
 
 jobs:
   triage:
diff --git a/allure-cucumber7-jvm/build.gradle.kts b/allure-cucumber7-jvm/build.gradle.kts
new file mode 100644
index 000000000..b6104c0aa
--- /dev/null
+++ b/allure-cucumber7-jvm/build.gradle.kts
@@ -0,0 +1,32 @@
+description = "Allure CucumberJVM 7.0"
+
+val cucumberVersion = "7.0.0"
+val cucumberGherkinVersion = "22.0.0"
+
+dependencies {
+    api(project(":allure-java-commons"))
+    compileOnly("io.cucumber:cucumber-plugin:$cucumberVersion")
+    implementation("io.cucumber:gherkin:$cucumberGherkinVersion")
+    testImplementation("io.cucumber:gherkin:$cucumberGherkinVersion")
+    testImplementation("io.cucumber:cucumber-core:$cucumberVersion")
+    testImplementation("io.cucumber:cucumber-java:$cucumberVersion")
+    testImplementation("commons-io:commons-io")
+    testImplementation("io.github.glytching:junit-extensions")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-java-commons-test"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks.jar {
+    manifest {
+        attributes(mapOf(
+                "Automatic-Module-Name" to "io.qameta.allure.cucumber7jvm"
+        ))
+    }
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java
new file mode 100644
index 000000000..467f533af
--- /dev/null
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/AllureCucumber7Jvm.java
@@ -0,0 +1,440 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm;
+
+import io.cucumber.messages.types.Examples;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.messages.types.TableRow;
+import io.cucumber.plugin.ConcurrentEventListener;
+import io.cucumber.plugin.event.DataTableArgument;
+import io.cucumber.plugin.event.EmbedEvent;
+import io.cucumber.plugin.event.EventHandler;
+import io.cucumber.plugin.event.EventPublisher;
+import io.cucumber.plugin.event.HookTestStep;
+import io.cucumber.plugin.event.HookType;
+import io.cucumber.plugin.event.PickleStepTestStep;
+import io.cucumber.plugin.event.Result;
+import io.cucumber.plugin.event.StepArgument;
+import io.cucumber.plugin.event.TestCase;
+import io.cucumber.plugin.event.TestCaseFinished;
+import io.cucumber.plugin.event.TestCaseStarted;
+import io.cucumber.plugin.event.TestSourceRead;
+import io.cucumber.plugin.event.TestStepFinished;
+import io.cucumber.plugin.event.TestStepStarted;
+import io.cucumber.plugin.event.WriteEvent;
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.cucumber7jvm.testsourcemodel.TestSourcesModelProxy;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.model.TestResultContainer;
+
+import java.io.ByteArrayInputStream;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static io.qameta.allure.util.ResultsUtils.createParameter;
+import static io.qameta.allure.util.ResultsUtils.getStatus;
+import static io.qameta.allure.util.ResultsUtils.getStatusDetails;
+import static io.qameta.allure.util.ResultsUtils.md5;
+
+/**
+ * Allure plugin for Cucumber JVM 7.0.
+ */
+@SuppressWarnings({
+        "ClassDataAbstractionCoupling",
+        "ClassFanOutComplexity",
+        "PMD.ExcessiveImports",
+        "PMD.GodClass",
+})
+public class AllureCucumber7Jvm implements ConcurrentEventListener {
+
+    private final AllureLifecycle lifecycle;
+
+    private final ConcurrentHashMap<String, String> scenarioUuids = new ConcurrentHashMap<>();
+    private final TestSourcesModelProxy testSources = new TestSourcesModelProxy();
+
+    private final ThreadLocal<Feature> currentFeature = new InheritableThreadLocal<>();
+    private final ThreadLocal<URI> currentFeatureFile = new InheritableThreadLocal<>();
+    private final ThreadLocal<TestCase> currentTestCase = new InheritableThreadLocal<>();
+    private final ThreadLocal<String> currentContainer = new InheritableThreadLocal<>();
+    private final ThreadLocal<Boolean> forbidTestCaseStatusChange = new InheritableThreadLocal<>();
+
+    private final EventHandler<TestSourceRead> featureStartedHandler = this::handleFeatureStartedHandler;
+    private final EventHandler<TestCaseStarted> caseStartedHandler = this::handleTestCaseStarted;
+    private final EventHandler<TestCaseFinished> caseFinishedHandler = this::handleTestCaseFinished;
+    private final EventHandler<TestStepStarted> stepStartedHandler = this::handleTestStepStarted;
+    private final EventHandler<TestStepFinished> stepFinishedHandler = this::handleTestStepFinished;
+    private final EventHandler<WriteEvent> writeEventHandler = this::handleWriteEvent;
+    private final EventHandler<EmbedEvent> embedEventHandler = this::handleEmbedEvent;
+
+    private static final String TXT_EXTENSION = ".txt";
+    private static final String TEXT_PLAIN = "text/plain";
+
+    @SuppressWarnings("unused")
+    public AllureCucumber7Jvm() {
+        this(Allure.getLifecycle());
+    }
+
+    public AllureCucumber7Jvm(final AllureLifecycle lifecycle) {
+        this.lifecycle = lifecycle;
+    }
+
+    /*
+    Event Handlers
+     */
+    @Override
+    public void setEventPublisher(final EventPublisher publisher) {
+        publisher.registerHandlerFor(TestSourceRead.class, featureStartedHandler);
+
+        publisher.registerHandlerFor(TestCaseStarted.class, caseStartedHandler);
+        publisher.registerHandlerFor(TestCaseFinished.class, caseFinishedHandler);
+
+        publisher.registerHandlerFor(TestStepStarted.class, stepStartedHandler);
+        publisher.registerHandlerFor(TestStepFinished.class, stepFinishedHandler);
+
+        publisher.registerHandlerFor(WriteEvent.class, writeEventHandler);
+        publisher.registerHandlerFor(EmbedEvent.class, embedEventHandler);
+    }
+
+    private void handleFeatureStartedHandler(final TestSourceRead event) {
+        testSources.addTestSourceReadEvent(event.getUri(), event);
+    }
+
+    private void handleTestCaseStarted(final TestCaseStarted event) {
+        currentFeatureFile.set(event.getTestCase().getUri());
+        currentFeature.set(testSources.getFeature(currentFeatureFile.get()));
+        currentTestCase.set(event.getTestCase());
+        currentContainer.set(UUID.randomUUID().toString());
+        forbidTestCaseStatusChange.set(false);
+
+        final Deque<String> tags = new LinkedList<>(currentTestCase.get().getTags());
+
+        final Feature feature = currentFeature.get();
+        final LabelBuilder labelBuilder = new LabelBuilder(feature, currentTestCase.get(), tags);
+
+        final String name = currentTestCase.get().getName();
+        final String featureName = feature.getName();
+
+        final TestResult result = new TestResult()
+                .setUuid(getTestCaseUuid(currentTestCase.get()))
+                .setHistoryId(getHistoryId(currentTestCase.get()))
+                .setFullName(featureName + ": " + name)
+                .setName(name)
+                .setLabels(labelBuilder.getScenarioLabels())
+                .setLinks(labelBuilder.getScenarioLinks());
+
+        final Scenario scenarioDefinition =
+                testSources.getScenarioDefinition(
+                        currentFeatureFile.get(),
+                        currentTestCase.get().getLocation().getLine()
+                );
+
+        if (scenarioDefinition.getExamples() != null) {
+            result.setParameters(
+                    getExamplesAsParameters(scenarioDefinition, currentTestCase.get())
+            );
+        }
+
+        final String description = Stream.of(feature.getDescription(), scenarioDefinition.getDescription())
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.joining("\n"));
+
+        if (!description.isEmpty()) {
+            result.setDescription(description);
+        }
+
+        final TestResultContainer resultContainer = new TestResultContainer()
+                .setName(String.format("%s: %s", scenarioDefinition.getKeyword(), scenarioDefinition.getName()))
+                .setUuid(getTestContainerUuid())
+                .setChildren(Collections.singletonList(getTestCaseUuid(currentTestCase.get())));
+
+        lifecycle.scheduleTestCase(result);
+        lifecycle.startTestContainer(getTestContainerUuid(), resultContainer);
+        lifecycle.startTestCase(getTestCaseUuid(currentTestCase.get()));
+    }
+
+    private void handleTestCaseFinished(final TestCaseFinished event) {
+
+        final String uuid = getTestCaseUuid(event.getTestCase());
+        final Optional<StatusDetails> details = getStatusDetails(event.getResult().getError());
+        details.ifPresent(statusDetails -> lifecycle.updateTestCase(
+                uuid,
+                testResult -> testResult.setStatusDetails(statusDetails)
+        ));
+        lifecycle.stopTestCase(uuid);
+        lifecycle.stopTestContainer(getTestContainerUuid());
+        lifecycle.writeTestCase(uuid);
+        lifecycle.writeTestContainer(getTestContainerUuid());
+    }
+
+    private void handleTestStepStarted(final TestStepStarted event) {
+        if (event.getTestStep() instanceof PickleStepTestStep) {
+            final PickleStepTestStep pickleStep = (PickleStepTestStep) event.getTestStep();
+            final String stepKeyword = Optional.ofNullable(
+                    testSources.getKeywordFromSource(currentFeatureFile.get(), pickleStep.getStep().getLine())
+            ).orElse("UNDEFINED");
+
+            final StepResult stepResult = new StepResult()
+                    .setName(String.format("%s %s", stepKeyword, pickleStep.getStep().getText()))
+                    .setStart(System.currentTimeMillis());
+
+            lifecycle.startStep(getTestCaseUuid(currentTestCase.get()), getStepUuid(pickleStep), stepResult);
+
+            final StepArgument stepArgument = pickleStep.getStep().getArgument();
+            if (stepArgument instanceof DataTableArgument) {
+                final DataTableArgument dataTableArgument = (DataTableArgument) stepArgument;
+                createDataTableAttachment(dataTableArgument);
+            }
+        } else if (event.getTestStep() instanceof HookTestStep) {
+            initHook((HookTestStep) event.getTestStep());
+        }
+    }
+
+    private void initHook(final HookTestStep hook) {
+
+        final FixtureResult hookResult = new FixtureResult()
+                .setName(hook.getCodeLocation())
+                .setStart(System.currentTimeMillis());
+
+        if (hook.getHookType() == HookType.BEFORE) {
+            lifecycle.startPrepareFixture(getTestContainerUuid(), getHookStepUuid(hook), hookResult);
+        } else {
+            lifecycle.startTearDownFixture(getTestContainerUuid(), getHookStepUuid(hook), hookResult);
+        }
+
+    }
+
+    private void handleTestStepFinished(final TestStepFinished event) {
+        if (event.getTestStep() instanceof HookTestStep) {
+            handleHookStep(event);
+        } else {
+            handlePickleStep(event);
+        }
+    }
+
+    private void handleWriteEvent(final WriteEvent event) {
+        lifecycle.addAttachment(
+                "Text output",
+                TEXT_PLAIN,
+                TXT_EXTENSION,
+                Objects.toString(event.getText()).getBytes(StandardCharsets.UTF_8)
+        );
+    }
+
+    private void handleEmbedEvent(final EmbedEvent event) {
+        lifecycle.addAttachment(event.name, event.getMediaType(), null, new ByteArrayInputStream(event.getData()));
+    }
+
+    /*
+    Utility Methods
+     */
+
+    private String getTestContainerUuid() {
+        return currentContainer.get();
+    }
+
+    private String getTestCaseUuid(final TestCase testCase) {
+        return scenarioUuids.computeIfAbsent(getHistoryId(testCase), it -> UUID.randomUUID().toString());
+    }
+
+    private String getStepUuid(final PickleStepTestStep step) {
+        return currentFeature.get().getName() + getTestCaseUuid(currentTestCase.get())
+                + step.getStep().getText() + step.getStep().getLine();
+    }
+
+    private String getHookStepUuid(final HookTestStep step) {
+        return currentFeature.get().getName() + getTestCaseUuid(currentTestCase.get())
+                + step.getHookType().toString() + step.getCodeLocation();
+    }
+
+    private String getHistoryId(final TestCase testCase) {
+        final String testCaseLocation = testCase.getUri().toString()
+                .substring(testCase.getUri().toString().lastIndexOf('/') + 1)
+                + ":" + testCase.getLocation().getLine();
+        return md5(testCaseLocation);
+    }
+
+    private Status translateTestCaseStatus(final Result testCaseResult) {
+        switch (testCaseResult.getStatus()) {
+            case FAILED:
+                return getStatus(testCaseResult.getError())
+                        .orElse(Status.FAILED);
+            case PASSED:
+                return Status.PASSED;
+            case SKIPPED:
+            case PENDING:
+                return Status.SKIPPED;
+            case AMBIGUOUS:
+            case UNDEFINED:
+            default:
+                return null;
+        }
+    }
+
+    private List<Parameter> getExamplesAsParameters(
+            final Scenario scenario, final TestCase localCurrentTestCase
+    ) {
+        final Optional<Examples> maybeExample =
+                scenario.getExamples().stream()
+                        .filter(example -> example.getTableBody().stream()
+                                .anyMatch(row -> row.getLocation().getLine()
+                                        == localCurrentTestCase.getLocation().getLine())
+                        )
+                        .findFirst();
+
+        if (!maybeExample.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        final Examples examples = maybeExample.get();
+
+        final Optional<TableRow> maybeRow = examples.getTableBody().stream()
+                .filter(example -> example.getLocation().getLine() == localCurrentTestCase.getLocation().getLine())
+                .findFirst();
+
+        if (!maybeRow.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        final TableRow row = maybeRow.get();
+
+        return IntStream.range(0, examples.getTableHeader().getCells().size())
+                .mapToObj(index -> {
+                    final String name = examples.getTableHeader().getCells().get(index).getValue();
+                    final String value = row.getCells().get(index).getValue();
+                    return createParameter(name, value);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private void createDataTableAttachment(final DataTableArgument dataTableArgument) {
+        final List<List<String>> rowsInTable = dataTableArgument.cells();
+        final StringBuilder dataTableCsv = new StringBuilder();
+        for (List<String> columns : rowsInTable) {
+            if (!columns.isEmpty()) {
+                for (int i = 0; i < columns.size(); i++) {
+                    if (i == columns.size() - 1) {
+                        dataTableCsv.append(columns.get(i));
+                    } else {
+                        dataTableCsv.append(columns.get(i));
+                        dataTableCsv.append('\t');
+                    }
+                }
+                dataTableCsv.append('\n');
+            }
+        }
+        final String attachmentSource = lifecycle
+                .prepareAttachment("Data table", "text/tab-separated-values", "csv");
+        lifecycle.writeAttachment(attachmentSource,
+                new ByteArrayInputStream(dataTableCsv.toString().getBytes(StandardCharsets.UTF_8)));
+    }
+
+    private void handleHookStep(final TestStepFinished event) {
+        final HookTestStep hookStep = (HookTestStep) event.getTestStep();
+        final String uuid = getHookStepUuid(hookStep);
+        final FixtureResult fixtureResult = new FixtureResult().setStatus(translateTestCaseStatus(event.getResult()));
+
+        if (!Status.PASSED.equals(fixtureResult.getStatus())) {
+            final TestResult testResult = new TestResult().setStatus(translateTestCaseStatus(event.getResult()));
+            final StatusDetails statusDetails = getStatusDetails(event.getResult().getError())
+                    .orElseGet(StatusDetails::new);
+
+            final String errorMessage = event.getResult().getError() == null ? hookStep.getHookType()
+                    .name() + " is failed." : hookStep.getHookType()
+                    .name() + " is failed: " + event.getResult().getError().getLocalizedMessage();
+            statusDetails.setMessage(errorMessage);
+
+            if (hookStep.getHookType() == HookType.BEFORE) {
+                final TagParser tagParser = new TagParser(currentFeature.get(), currentTestCase.get());
+                statusDetails
+                        .setFlaky(tagParser.isFlaky())
+                        .setMuted(tagParser.isMuted())
+                        .setKnown(tagParser.isKnown());
+                testResult.setStatus(Status.SKIPPED);
+                updateTestCaseStatus(testResult.getStatus());
+                forbidTestCaseStatusChange.set(true);
+            } else {
+                testResult.setStatus(Status.BROKEN);
+                updateTestCaseStatus(testResult.getStatus());
+            }
+            fixtureResult.setStatusDetails(statusDetails);
+        }
+
+        lifecycle.updateFixture(uuid, result -> result.setStatus(fixtureResult.getStatus())
+                .setStatusDetails(fixtureResult.getStatusDetails()));
+        lifecycle.stopFixture(uuid);
+    }
+
+    private void handlePickleStep(final TestStepFinished event) {
+
+        final Status stepStatus = translateTestCaseStatus(event.getResult());
+        final StatusDetails statusDetails;
+        if (event.getResult().getStatus() == io.cucumber.plugin.event.Status.UNDEFINED) {
+            updateTestCaseStatus(Status.PASSED);
+
+            statusDetails =
+                    getStatusDetails(new IllegalStateException("Undefined Step. Please add step definition"))
+                            .orElse(new StatusDetails());
+            lifecycle.updateTestCase(getTestCaseUuid(currentTestCase.get()), scenarioResult ->
+                    scenarioResult
+                            .setStatusDetails(statusDetails));
+        } else {
+            statusDetails =
+                    getStatusDetails(event.getResult().getError())
+                            .orElse(new StatusDetails());
+            updateTestCaseStatus(stepStatus);
+        }
+
+        if (!Status.PASSED.equals(stepStatus) && stepStatus != null) {
+            forbidTestCaseStatusChange.set(true);
+        }
+
+        final TagParser tagParser = new TagParser(currentFeature.get(), currentTestCase.get());
+        statusDetails
+                .setFlaky(tagParser.isFlaky())
+                .setMuted(tagParser.isMuted())
+                .setKnown(tagParser.isKnown());
+
+        lifecycle.updateStep(getStepUuid((PickleStepTestStep) event.getTestStep()),
+                stepResult -> stepResult.setStatus(stepStatus).setStatusDetails(statusDetails));
+        lifecycle.stopStep(getStepUuid((PickleStepTestStep) event.getTestStep()));
+    }
+
+    private void updateTestCaseStatus(final Status status) {
+        if (!forbidTestCaseStatusChange.get()) {
+            lifecycle.updateTestCase(getTestCaseUuid(currentTestCase.get()),
+                    result -> result.setStatus(status));
+        }
+    }
+}
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java
new file mode 100644
index 000000000..961138543
--- /dev/null
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/LabelBuilder.java
@@ -0,0 +1,192 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm;
+
+import io.cucumber.messages.types.Feature;
+import io.cucumber.plugin.event.TestCase;
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
+import io.qameta.allure.util.ResultsUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.qameta.allure.util.ResultsUtils.createFeatureLabel;
+import static io.qameta.allure.util.ResultsUtils.createFrameworkLabel;
+import static io.qameta.allure.util.ResultsUtils.createHostLabel;
+import static io.qameta.allure.util.ResultsUtils.createLabel;
+import static io.qameta.allure.util.ResultsUtils.createLanguageLabel;
+import static io.qameta.allure.util.ResultsUtils.createStoryLabel;
+import static io.qameta.allure.util.ResultsUtils.createSuiteLabel;
+import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
+import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+
+/**
+ * Scenario labels and links builder.
+ */
+@SuppressWarnings({"CyclomaticComplexity", "PMD.CyclomaticComplexity", "PMD.NcssCount", "MultipleStringLiterals"})
+class LabelBuilder {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LabelBuilder.class);
+    private static final String COMPOSITE_TAG_DELIMITER = "=";
+
+    private static final String SEVERITY = "@SEVERITY";
+    private static final String ISSUE_LINK = "@ISSUE";
+    private static final String TMS_LINK = "@TMSLINK";
+    private static final String PLAIN_LINK = "@LINK";
+
+    private final List<Label> scenarioLabels = new ArrayList<>();
+    private final List<Link> scenarioLinks = new ArrayList<>();
+
+    LabelBuilder(final Feature feature, final TestCase scenario, final Deque<String> tags) {
+        final TagParser tagParser = new TagParser(feature, scenario);
+
+        while (tags.peek() != null) {
+            final String tag = tags.remove();
+
+            if (tag.contains(COMPOSITE_TAG_DELIMITER)) {
+
+                final String[] tagParts = tag.split(COMPOSITE_TAG_DELIMITER, 2);
+                if (tagParts.length < 2 || Objects.isNull(tagParts[1]) || tagParts[1].isEmpty()) {
+                    // skip empty tags, e.g. '@tmsLink=', to avoid formatter errors
+                    continue;
+                }
+
+                final String tagKey = tagParts[0].toUpperCase();
+                final String tagValue = tagParts[1];
+
+                // Handle composite named links
+                if (tagKey.startsWith(PLAIN_LINK + ".")) {
+                    tryHandleNamedLink(tag);
+                    continue;
+                }
+
+                switch (tagKey) {
+                    case SEVERITY:
+                        getScenarioLabels().add(ResultsUtils.createSeverityLabel(tagValue.toLowerCase()));
+                        break;
+                    case TMS_LINK:
+                        getScenarioLinks().add(ResultsUtils.createTmsLink(tagValue));
+                        break;
+                    case ISSUE_LINK:
+                        getScenarioLinks().add(ResultsUtils.createIssueLink(tagValue));
+                        break;
+                    case PLAIN_LINK:
+                        getScenarioLinks().add(ResultsUtils.createLink(null, tagValue, tagValue, null));
+                        break;
+                    default:
+                        LOGGER.warn("Composite tag {} is not supported. adding it as RAW", tagKey);
+                        getScenarioLabels().add(getTagLabel(tag));
+                        break;
+                }
+            } else if (tagParser.isPureSeverityTag(tag)) {
+                getScenarioLabels().add(ResultsUtils.createSeverityLabel(tag.substring(1)));
+            } else if (!tagParser.isResultTag(tag)) {
+                getScenarioLabels().add(getTagLabel(tag));
+            }
+        }
+
+        final String featureName = feature.getName();
+        final URI uri = scenario.getUri();
+
+        getScenarioLabels().addAll(ResultsUtils.getProvidedLabels());
+        getScenarioLabels().addAll(Arrays.asList(
+                createHostLabel(),
+                createThreadLabel(),
+                createFeatureLabel(featureName),
+                createStoryLabel(scenario.getName()),
+                createSuiteLabel(featureName),
+                createTestClassLabel(scenario.getName()),
+                createFrameworkLabel("cucumber4jvm"),
+                createLanguageLabel("java"),
+                createLabel("gherkin_uri", uri.toString())
+        ));
+
+        featurePackage(uri.toString(), featureName)
+                .map(ResultsUtils::createPackageLabel)
+                .ifPresent(getScenarioLabels()::add);
+    }
+
+    public List<Label> getScenarioLabels() {
+        return scenarioLabels;
+    }
+
+    public List<Link> getScenarioLinks() {
+        return scenarioLinks;
+    }
+
+    private Label getTagLabel(final String tag) {
+        return ResultsUtils.createTagLabel(tag.substring(1));
+    }
+
+    /**
+     * Handle composite named links.
+     *
+     * @param tagString Full tag name and value
+     */
+    private void tryHandleNamedLink(final String tagString) {
+        final String namedLinkPatternString = PLAIN_LINK + "\\.(\\w+-?)+=(\\w+(-|_)?)+";
+        final Pattern namedLinkPattern = Pattern.compile(namedLinkPatternString, Pattern.CASE_INSENSITIVE);
+
+        if (namedLinkPattern.matcher(tagString).matches()) {
+            final String type = tagString.split(COMPOSITE_TAG_DELIMITER)[0].split("[.]")[1];
+            final String name = tagString.split(COMPOSITE_TAG_DELIMITER)[1];
+            getScenarioLinks().add(ResultsUtils.createLink(null, name, null, type));
+        } else {
+            LOGGER.warn("Composite named tag {} does not match regex {}. Skipping", tagString,
+                    namedLinkPatternString);
+        }
+    }
+
+    private Optional<String> featurePackage(final String uriString, final String featureName) {
+        final Optional<URI> maybeUri = safeUri(uriString);
+        if (!maybeUri.isPresent()) {
+            return Optional.empty();
+        }
+        URI uri = maybeUri.get();
+
+        if (!uri.isOpaque()) {
+            final URI work = new File("").toURI();
+            uri = work.relativize(uri);
+        }
+        final String schemeSpecificPart = uri.normalize().getSchemeSpecificPart();
+        final Stream<String> folders = Stream.of(schemeSpecificPart.replaceAll("\\.", "_").split("/"));
+        final Stream<String> name = Stream.of(featureName);
+        return Optional.of(Stream.concat(folders, name)
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isEmpty())
+                .collect(Collectors.joining(".")));
+    }
+
+    private static Optional<URI> safeUri(final String uri) {
+        try {
+            return Optional.of(URI.create(uri));
+        } catch (Exception e) {
+            LOGGER.debug("could not parse feature uri {}", uri, e);
+        }
+        return Optional.empty();
+    }
+}
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java
new file mode 100644
index 000000000..8ef92b7ab
--- /dev/null
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/TagParser.java
@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm;
+
+import io.cucumber.messages.types.Feature;
+import io.cucumber.plugin.event.TestCase;
+import io.qameta.allure.SeverityLevel;
+
+import java.util.Arrays;
+
+/**
+ * Parser for tags.
+ */
+class TagParser {
+    private static final String FLAKY = "@FLAKY";
+    private static final String KNOWN = "@KNOWN";
+    private static final String MUTED = "@MUTED";
+
+    private final Feature feature;
+    private final TestCase scenario;
+
+    TagParser(final Feature feature, final TestCase scenario) {
+        this.feature = feature;
+        this.scenario = scenario;
+    }
+
+    public boolean isFlaky() {
+        return getStatusDetailByTag(FLAKY);
+    }
+
+    public boolean isMuted() {
+        return getStatusDetailByTag(MUTED);
+    }
+
+    public boolean isKnown() {
+        return getStatusDetailByTag(KNOWN);
+    }
+
+    private boolean getStatusDetailByTag(final String tagName) {
+        return scenario.getTags().stream()
+                .anyMatch(tag -> tag.equalsIgnoreCase(tagName))
+                || feature.getTags().stream()
+                .anyMatch(tag -> tag.getName().equalsIgnoreCase(tagName));
+    }
+
+    public boolean isResultTag(final String tag) {
+        return Arrays.asList(new String[]{FLAKY, KNOWN, MUTED})
+                .contains(tag.toUpperCase());
+    }
+
+    public boolean isPureSeverityTag(final String tag) {
+        return Arrays.stream(SeverityLevel.values())
+                .map(SeverityLevel::value)
+                .map(value -> "@" + value)
+                .anyMatch(value -> value.equalsIgnoreCase(tag));
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java
new file mode 100644
index 000000000..7741c41dc
--- /dev/null
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModel.java
@@ -0,0 +1,186 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.testsourcemodel;
+
+import io.cucumber.gherkin.Gherkin;
+import io.cucumber.messages.types.Background;
+import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.Examples;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.FeatureChild;
+import io.cucumber.messages.types.GherkinDocument;
+import io.cucumber.messages.types.RuleChild;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.messages.types.Step;
+import io.cucumber.messages.types.TableRow;
+import io.cucumber.plugin.event.TestSourceRead;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+import static io.cucumber.gherkin.Gherkin.makeSourceEnvelope;
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.toList;
+
+final class TestSourcesModel {
+    private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
+    private final Map<URI, GherkinDocument> pathToAstMap = new HashMap<>();
+    private final Map<URI, Map<Long, AstNode>> pathToNodeMap = new HashMap<>();
+
+    public static Scenario getScenarioDefinition(final AstNode astNode) {
+        AstNode candidate = astNode;
+        while (candidate != null && !(candidate.node instanceof Scenario)) {
+            candidate = candidate.parent;
+        }
+        return candidate == null ? null : (Scenario) candidate.node;
+    }
+
+    public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
+        pathToReadEventMap.put(path, event);
+    }
+
+    public Feature getFeature(final URI path) {
+        if (!pathToAstMap.containsKey(path)) {
+            parseGherkinSource(path);
+        }
+        if (pathToAstMap.containsKey(path)) {
+            return pathToAstMap.get(path).getFeature();
+        }
+        return null;
+    }
+
+    private void parseGherkinSource(final URI path) {
+        if (!pathToReadEventMap.containsKey(path)) {
+            return;
+        }
+        final String source = pathToReadEventMap.get(path).getSource();
+
+        final List<Envelope> sources = singletonList(
+                makeSourceEnvelope(source, path.toString()));
+
+        final List<Envelope> envelopes = Gherkin.fromSources(
+                sources,
+                true,
+                true,
+                true,
+                () -> String.valueOf(UUID.randomUUID())).collect(toList());
+
+        final GherkinDocument gherkinDocument = envelopes.stream()
+                .map(Envelope::getGherkinDocument)
+                .filter(Objects::nonNull)
+                .findFirst()
+                .orElse(null);
+
+        pathToAstMap.put(path, gherkinDocument);
+        final Map<Long, AstNode> nodeMap = new HashMap<>();
+        final AstNode currentParent = createAstNode(Objects.requireNonNull(gherkinDocument).getFeature(), null);
+        for (FeatureChild child : gherkinDocument.getFeature().getChildren()) {
+            processFeatureDefinition(nodeMap, child, currentParent);
+        }
+        pathToNodeMap.put(path, nodeMap);
+
+    }
+
+    private void processFeatureDefinition(
+            final Map<Long, AstNode> nodeMap, final FeatureChild child, final AstNode currentParent) {
+        if (child.getBackground() != null) {
+            processBackgroundDefinition(nodeMap, child.getBackground(), currentParent);
+        } else if (child.getScenario() != null) {
+            processScenarioDefinition(nodeMap, child.getScenario(), currentParent);
+        } else if (child.getRule() != null) {
+            final AstNode childNode = createAstNode(child.getRule(), currentParent);
+            nodeMap.put(child.getRule().getLocation().getLine(), childNode);
+            for (RuleChild ruleChild : child.getRule().getChildren()) {
+                processRuleDefinition(nodeMap, ruleChild, childNode);
+            }
+        }
+    }
+
+    private void processBackgroundDefinition(
+            final Map<Long, AstNode> nodeMap, final Background background, final AstNode currentParent
+    ) {
+        final AstNode childNode = createAstNode(background, currentParent);
+        nodeMap.put(background.getLocation().getLine(), childNode);
+        for (Step step : background.getSteps()) {
+            nodeMap.put(step.getLocation().getLine(), createAstNode(step, childNode));
+        }
+    }
+
+    private void processScenarioDefinition(
+            final Map<Long, AstNode> nodeMap, final Scenario child, final AstNode currentParent) {
+        final AstNode childNode = createAstNode(child, currentParent);
+        nodeMap.put(child.getLocation().getLine(), childNode);
+        for (Step step : child.getSteps()) {
+            nodeMap.put(step.getLocation().getLine(), createAstNode(step, childNode));
+        }
+        if (child.getExamples().size() > 0) {
+            processScenarioOutlineExamples(nodeMap, child, childNode);
+        }
+    }
+
+    private void processRuleDefinition(
+            final Map<Long, AstNode> nodeMap, final RuleChild child, final AstNode currentParent) {
+        if (child.getBackground() != null) {
+            processBackgroundDefinition(nodeMap, child.getBackground(), currentParent);
+        } else if (child.getScenario() != null) {
+            processScenarioDefinition(nodeMap, child.getScenario(), currentParent);
+        }
+    }
+
+    private void processScenarioOutlineExamples(
+            final Map<Long, AstNode> nodeMap, final Scenario scenarioOutline, final AstNode parent
+    ) {
+        for (Examples examples : scenarioOutline.getExamples()) {
+            final AstNode examplesNode = createAstNode(examples, parent);
+            final TableRow headerRow = examples.getTableHeader();
+            final AstNode headerNode = createAstNode(headerRow, examplesNode);
+            nodeMap.put(headerRow.getLocation().getLine(), headerNode);
+            for (int i = 0; i < examples.getTableBody().size(); ++i) {
+                final TableRow examplesRow = examples.getTableBody().get(i);
+                final AstNode expandedScenarioNode = createAstNode(examplesRow, examplesNode);
+                nodeMap.put(examplesRow.getLocation().getLine(), expandedScenarioNode);
+            }
+        }
+    }
+
+    public AstNode getAstNode(final URI path, final int line) {
+        if (!pathToNodeMap.containsKey(path)) {
+            parseGherkinSource(path);
+        }
+        if (pathToNodeMap.containsKey(path)) {
+            return pathToNodeMap.get(path).get((long) line);
+        }
+        return null;
+    }
+
+    private AstNode createAstNode(final Object node, final AstNode astNode) {
+        return new AstNode(node, astNode);
+    }
+
+    private static class AstNode {
+        private final Object node;
+        private final AstNode parent;
+
+        AstNode(final Object node, final AstNode parent) {
+            this.node = node;
+            this.parent = parent;
+        }
+    }
+}
diff --git a/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java
new file mode 100644
index 000000000..662adf763
--- /dev/null
+++ b/allure-cucumber7-jvm/src/main/java/io/qameta/allure/cucumber7jvm/testsourcemodel/TestSourcesModelProxy.java
@@ -0,0 +1,76 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.testsourcemodel;
+
+import io.cucumber.gherkin.GherkinDialect;
+import io.cucumber.gherkin.GherkinDialectProvider;
+import io.cucumber.messages.types.Feature;
+import io.cucumber.messages.types.Scenario;
+import io.cucumber.plugin.event.TestSourceRead;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public class TestSourcesModelProxy {
+
+    private final Map<URI, TestSourceRead> pathToReadEventMap = new HashMap<>();
+    private final TestSourcesModel testSources;
+
+    public TestSourcesModelProxy() {
+        this.testSources = new TestSourcesModel();
+    }
+
+    public void addTestSourceReadEvent(final URI path, final TestSourceRead event) {
+        this.pathToReadEventMap.put(path, event);
+        testSources.addTestSourceReadEvent(path, event);
+    }
+
+    public Feature getFeature(final URI path) {
+        return testSources.getFeature(path);
+    }
+
+    public Scenario getScenarioDefinition(final URI path, final int line) {
+        return TestSourcesModel.getScenarioDefinition(testSources.getAstNode(path, line));
+    }
+
+    public String getKeywordFromSource(final URI uri, final int stepLine) {
+        return this.getKeywordFromSourceInternal(uri, stepLine);
+    }
+
+    private String getKeywordFromSourceInternal(final URI uri, final int stepLine) {
+        final Feature feature = getFeature(uri);
+        if (feature != null) {
+            final TestSourceRead event = this.getTestSourceReadEvent(uri);
+            final String trimmedSourceLine = Objects.requireNonNull(event).getSource().split("\n")[stepLine - 1].trim();
+            final GherkinDialect dialect = new GherkinDialectProvider(feature.getLanguage()).getDefaultDialect();
+            for (String keyword : dialect.getStepKeywords()) {
+                if (trimmedSourceLine.startsWith(keyword)) {
+                    return keyword;
+                }
+            }
+        }
+        return "";
+    }
+
+    private TestSourceRead getTestSourceReadEvent(final URI uri) {
+        if (this.pathToReadEventMap.containsKey(uri)) {
+            return pathToReadEventMap.get(uri);
+        }
+        return null;
+    }
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java
new file mode 100644
index 000000000..56cd80f72
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/AllureCucumber7JvmTest.java
@@ -0,0 +1,768 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm;
+
+import io.cucumber.core.eventbus.EventBus;
+import io.cucumber.core.feature.FeatureParser;
+import io.cucumber.core.feature.FeatureWithLines;
+import io.cucumber.core.resource.ClassLoaders;
+import io.cucumber.core.runtime.FeaturePathFeatureSupplier;
+import io.cucumber.core.runtime.Runtime;
+import io.cucumber.core.options.CommandlineOptionsParser;
+import io.cucumber.core.options.RuntimeOptions;
+import io.cucumber.core.runtime.TimeServiceEventBus;
+import io.github.glytching.junit.extension.system.SystemProperty;
+import io.github.glytching.junit.extension.system.SystemPropertyExtension;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.model.Attachment;
+import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
+import io.qameta.allure.model.Parameter;
+import io.qameta.allure.model.Stage;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.model.StepResult;
+import io.qameta.allure.model.TestResult;
+import io.qameta.allure.test.AllureFeatures;
+import io.qameta.allure.test.AllureResultsWriterStub;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.parallel.ResourceLock;
+
+import java.nio.charset.StandardCharsets;
+import java.time.Clock;
+import java.time.Instant;
+import java.util.*;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static io.qameta.allure.util.ResultsUtils.PACKAGE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.SUITE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TEST_CLASS_LABEL_NAME;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.junit.jupiter.api.parallel.ResourceAccessMode.READ_WRITE;
+import static org.junit.jupiter.api.parallel.Resources.SYSTEM_PROPERTIES;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@SuppressWarnings("unchecked")
+class AllureCucumber7JvmTest {
+
+    @AllureFeatures.Base
+    @Test
+    void shouldSetName() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName)
+                .containsExactlyInAnyOrder("Add a to b");
+    }
+
+    @AllureFeatures.PassedTests
+    @Test
+    void shouldSetStatus() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.PASSED);
+    }
+
+    @AllureFeatures.FailedTests
+    @Test
+    void shouldSetFailedStatus() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/failed.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.FAILED);
+    }
+
+    @AllureFeatures.FailedTests
+    @Test
+    void shouldSetStatusDetails() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/failed.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatusDetails)
+                .extracting(StatusDetails::getMessage)
+                .containsExactlyInAnyOrder("expecting 15 to be equal to 123");
+    }
+
+    @AllureFeatures.BrokenTests
+    @Test
+    void shouldSetBrokenStatus() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/broken.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.BROKEN);
+    }
+
+    @AllureFeatures.Stages
+    @Test
+    void shouldSetStage() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStage)
+                .containsExactlyInAnyOrder(Stage.FINISHED);
+    }
+
+    @AllureFeatures.Timings
+    @Test
+    void shouldSetStart() {
+        final long before = Instant.now().toEpochMilli();
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+        final long after = Instant.now().toEpochMilli();
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStart)
+                .allMatch(v -> v >= before && v <= after);
+    }
+
+    @AllureFeatures.Timings
+    @Test
+    void shouldSetStop() {
+        final long before = Instant.now().toEpochMilli();
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+        final long after = Instant.now().toEpochMilli();
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStop)
+                .allMatch(v -> v >= before && v <= after);
+    }
+
+    @AllureFeatures.FullName
+    @Test
+    void shouldSetFullName() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getFullName)
+                .containsExactlyInAnyOrder("Simple feature: Add a to b");
+    }
+
+    @AllureFeatures.Descriptions
+    @Test
+    void shouldSetDescription() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/description.feature");
+
+        final String expected = "This is description for current feature.\n"
+                + "It should appear on each scenario in report";
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getDescription)
+                .containsExactlyInAnyOrder(
+                        expected,
+                        expected
+                );
+    }
+
+    @AllureFeatures.Descriptions
+    @Test
+    void shouldSetScenarioDescription() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/scenario_description.feature");
+
+        final String expected = "This is description for current feature.\n"
+                + "It should appear on each scenario in report";
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getDescription)
+                .containsExactlyInAnyOrder(
+                        expected + "\n    scenario description 1",
+                        expected + "\n    scenario description 2"
+                );
+    }
+
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAddDataTableAttachment() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/datatable.feature");
+
+        final List<Attachment> attachments = writer.getTestResults().stream()
+                .map(TestResult::getSteps)
+                .flatMap(Collection::stream)
+                .map(StepResult::getAttachments)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactlyInAnyOrder(
+                        tuple("Data table", "text/tab-separated-values")
+                );
+
+        final Attachment dataTableAttachment = attachments.iterator().next();
+        final Map<String, byte[]> attachmentFiles = writer.getAttachments();
+        assertThat(attachmentFiles)
+                .containsKeys(dataTableAttachment.getSource());
+
+        final byte[] bytes = attachmentFiles.get(dataTableAttachment.getSource());
+        final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
+
+        assertThat(attachmentContent)
+                .isEqualTo("name\tlogin\temail\n" +
+                        "Viktor\tclicman\tclicman@ya.ru\n" +
+                        "Viktor2\tclicman2\tclicman2@ya.ru\n"
+                );
+
+    }
+
+    @AllureFeatures.Attachments
+    @Test
+    void shouldAddAttachments() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/attachments.feature");
+
+        final List<Attachment> attachments = writer.getTestResults().stream()
+                .map(TestResult::getSteps)
+                .flatMap(Collection::stream)
+                .map(StepResult::getAttachments)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .containsExactlyInAnyOrder(
+                        tuple("TextAttachment", "text/plain"),
+                        tuple("ImageAttachment", "image/png")
+                );
+
+        final List<String> attachmentContents = writer.getAttachments().values().stream()
+                .map(bytes -> new String(bytes, StandardCharsets.UTF_8))
+                .collect(Collectors.toList());
+
+        assertThat(attachmentContents)
+                .containsExactlyInAnyOrder("text attachment", "image attachment");
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldAddBackgroundSteps() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/background.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getSteps)
+                .extracting(StepResult::getName)
+                .containsExactly(
+                        "Given  cat is sad",
+                        "And  cat is murmur",
+                        "When  Pet the cat",
+                        "Then  Cat is happy"
+                );
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldAddParametersFromExamples() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/examples.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2);
+
+        assertThat(testResults.get(0).getParameters())
+                .hasSize(3);
+
+        assertThat(testResults.get(1).getParameters())
+                .hasSize(3);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "1"), tuple("b", "3"), tuple("result", "4"),
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldHandleMultipleExamplesPerOutline() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/multi-examples.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "1"), tuple("b", "3"), tuple("result", "4"),
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldSupportTaggedExamplesBlocks() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/multi-examples.feature", "--tags", "@ExamplesTag2");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(1);
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("tag", "ExamplesTag2")
+                );
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .containsExactlyInAnyOrder(
+                        tuple("a", "2"), tuple("b", "4"), tuple("result", "6")
+                );
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddTags() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/tags.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("tag", "FeatureTag"),
+                        tuple("tag", "good")
+                );
+    }
+
+    @AllureFeatures.Links
+    @ExtendWith(SystemPropertyExtension.class)
+    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @Test
+    void shouldAddLinks() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/tags.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLinks)
+                .extracting(Link::getName, Link::getType, Link::getUrl)
+                .contains(
+                        tuple("OAT-4444", "tms", "https://example.org/tms/OAT-4444"),
+                        tuple("BUG-22400", "issue", "https://example.org/issue/BUG-22400")
+                );
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddBddLabels() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/tags.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("feature", "Test Simple Scenarios"),
+                        tuple("story", "Add a to b")
+                );
+    }
+
+    @AllureFeatures.Timeline
+    @Test
+    void shouldAddThreadHostLabels() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/tags.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName)
+                .contains("host", "thread");
+    }
+
+    @AllureFeatures.MarkerAnnotations
+    @Test
+    void shouldAddCommonLabels() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/tags.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple(PACKAGE_LABEL_NAME, "src.test.resources.features.tags_feature.Test Simple Scenarios"),
+                        tuple(SUITE_LABEL_NAME, "Test Simple Scenarios"),
+                        tuple(TEST_CLASS_LABEL_NAME, "Add a to b")
+                );
+    }
+
+    @AllureFeatures.Steps
+    @Test
+    void shouldProcessUndefinedSteps() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/undefined.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.SKIPPED);
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 5", Status.PASSED),
+                        tuple("When  step is undefined", null),
+                        tuple("Then  b is 10", Status.SKIPPED)
+                );
+    }
+
+    @AllureFeatures.SkippedTests
+    @AllureFeatures.Steps
+    @Test
+    void shouldProcessPendingExceptionsInSteps() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/pending.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getStatus)
+                .containsExactlyInAnyOrder(Status.SKIPPED);
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 5", Status.PASSED),
+                        tuple("When  step is yet to be implemented", Status.SKIPPED),
+                        tuple("Then  b is 10", Status.SKIPPED)
+                );
+    }
+
+    @AllureFeatures.Base
+    @Test
+    void shouldSupportDryRunForSimpleFeatures() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature", "--dry-run");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Add a to b", Status.PASSED)
+                );
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 5", Status.PASSED),
+                        tuple("And  b is 10", Status.PASSED),
+                        tuple("When  I add a to b", Status.PASSED),
+                        tuple("Then  result is 15", Status.PASSED)
+                );
+    }
+
+    @AllureFeatures.Fixtures
+    @AllureFeatures.Base
+    @Test
+    void shouldSupportDryRunForHooks() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/hooks.feature", "--dry-run", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .startsWith(
+                        tuple("Simple scenario with Before and After hooks", Status.PASSED)
+                );
+
+        assertThat(writer.getTestResultContainers().get(0).getBefores())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.beforeHook()", Status.PASSED)
+                );
+
+        assertThat(writer.getTestResultContainers().get(0).getAfters())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.afterHook()", Status.PASSED)
+                );
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 7", Status.PASSED),
+                        tuple("And  b is 8", Status.PASSED),
+                        tuple("When  I add a to b", Status.PASSED),
+                        tuple("Then  result is 15", Status.PASSED)
+                );
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldPersistHistoryIdForScenarios() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/simple.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults.get(0).getHistoryId())
+                .isEqualTo("8eea9ed4458a49d418859d1398580671");
+    }
+
+    @AllureFeatures.History
+    @Test
+    void shouldPersistHistoryIdForExamples() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/examples.feature", "--threads", "2");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getHistoryId)
+                .containsExactlyInAnyOrder("42a7821e775ec18b112f92e96f0510a5", "afb27d131ed8d41b3f867895a26d2590");
+    }
+
+    private Comparator<TestResult> byHistoryId =
+            Comparator.comparing(TestResult::getHistoryId);
+
+    @AllureFeatures.Parallel
+    @Test
+    void shouldProcessScenariosInParallelMode() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/parallel.feature", "--threads", "3");
+
+        final List<TestResult> testResults = writer.getTestResults();
+
+        assertThat(testResults)
+                .hasSize(3);
+
+        assertThat(testResults)
+                .extracting(testResult -> testResult.getSteps().stream().map(StepResult::getName).collect(Collectors.toList()))
+                .containsSubsequence(
+                        Arrays.asList("Given  a is 1",
+                        "And  b is 3",
+                        "When  I add a to b",
+                        "Then  result is 4")
+                );
+
+        assertThat(testResults)
+                .extracting(testResult -> testResult.getSteps().stream().map(StepResult::getName).collect(Collectors.toList()))
+                .containsSubsequence(
+                        Arrays.asList("Given  a is 2",
+                                "And  b is 4",
+                                "When  I add a to b",
+                                "Then  result is 6")
+                );
+
+        assertThat(testResults)
+                .extracting(testResult -> testResult.getSteps().stream().map(StepResult::getName).collect(Collectors.toList()))
+                .containsSubsequence(
+                        Arrays.asList("Given  a is 7",
+                                "And  b is 8",
+                                "When  I add a to b",
+                                "Then  result is 15")
+                );
+    }
+
+    @AllureFeatures.Fixtures
+    @AllureFeatures.Stages
+    @Test
+    void shouldDisplayHooksAsStages() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/hooks.feature", "-t",
+                "@WithHooks or @BeforeHookWithException or @AfterHookWithException");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Simple scenario with Before and After hooks", Status.PASSED),
+                        tuple("Simple scenario with Before hook with Exception", Status.SKIPPED),
+                        tuple("Simple scenario with After hook with Exception", Status.BROKEN)
+                );
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 7", Status.PASSED),
+                        tuple("And  b is 8", Status.PASSED),
+                        tuple("When  I add a to b", Status.PASSED),
+                        tuple("Then  result is 15", Status.PASSED)
+                );
+
+
+        assertThat(writer.getTestResultContainers().get(0).getBefores())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.beforeHook()", Status.PASSED)
+                );
+
+        assertThat(writer.getTestResultContainers().get(0).getAfters())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.afterHook()", Status.PASSED)
+                );
+
+        assertThat(testResults.get(1).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 7", Status.SKIPPED),
+                        tuple("And  b is 8", Status.SKIPPED),
+                        tuple("When  I add a to b", Status.SKIPPED),
+                        tuple("Then  result is 15", Status.SKIPPED)
+                );
+
+
+        assertThat(writer.getTestResultContainers().get(1).getBefores())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.beforeHookWithException()", Status.FAILED)
+                );
+
+
+        assertThat(testResults.get(2).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Given  a is 7", Status.PASSED),
+                        tuple("And  b is 8", Status.PASSED),
+                        tuple("When  I add a to b", Status.PASSED),
+                        tuple("Then  result is 15", Status.PASSED)
+                );
+
+        assertThat(writer.getTestResultContainers().get(2).getAfters())
+                .extracting(FixtureResult::getName, FixtureResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("io.qameta.allure.cucumber7jvm.samples.HookSteps.afterHookWithException()", Status.FAILED)
+                );
+
+    }
+
+    @AllureFeatures.BrokenTests
+    @Test
+    void shouldHandleAmbigiousStepsExceptions() {
+        final AllureResultsWriterStub writer = new AllureResultsWriterStub();
+        runFeature(writer, "features/ambigious.feature");
+
+        final List<TestResult> testResults = writer.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .containsExactlyInAnyOrder(
+                        tuple("Simple scenario with ambigious steps", Status.SKIPPED)
+                );
+
+        assertThat(testResults.get(0).getSteps())
+                .extracting(StepResult::getName, StepResult::getStatus)
+                .containsExactly(
+                        tuple("When  ambigious step present", null),
+                        tuple("Then  something bad should happen", Status.SKIPPED)
+                );
+    }
+
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SystemProperty(name = "allure.label.x-provided", value = "cucumberjvm7-test-provided")
+    @Test
+    void shouldSupportProvidedLabels() {
+        final AllureResultsWriterStub results = new AllureResultsWriterStub();
+        runFeature(results, "features/simple.feature");
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple("x-provided", "cucumberjvm7-test-provided")
+                );
+    }
+
+    @SystemProperty(name="cucumber.junit-platform.naming-strategy", value="long")
+    private byte runFeature(final AllureResultsWriterStub writer,
+                            final String featureResource,
+                            final String... moreOptions) {
+
+        final AllureLifecycle lifecycle = new AllureLifecycle(writer);
+        final AllureCucumber7Jvm cucumber7jvm = new AllureCucumber7Jvm(lifecycle);
+        Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
+        final List<String> opts = new ArrayList<>(Arrays.asList(
+                "--glue", "io.qameta.allure.cucumber7jvm.samples",
+                "--no-summary"
+        ));
+        opts.addAll(Arrays.asList(moreOptions));
+        FeatureWithLines featureWithLines = FeatureWithLines.parse("src/test/resources/"+featureResource);
+        final RuntimeOptions options = new CommandlineOptionsParser(System.out)
+                .parse(opts.toArray(new String[]{})).addFeature(featureWithLines).build();
+        boolean mt = options.isMultiThreaded();
+
+        EventBus bus = new TimeServiceEventBus(Clock.systemUTC(), UUID::randomUUID);
+        FeatureParser parser = new FeatureParser(bus::generateId);
+        FeaturePathFeatureSupplier supplier = new FeaturePathFeatureSupplier(classLoader, options, parser);
+
+        final Runtime runtime = Runtime.builder()
+                .withClassLoader(classLoader)
+                .withRuntimeOptions(options)
+                .withAdditionalPlugins(cucumber7jvm)
+                .withFeatureSupplier(supplier)
+                .build();
+
+        runtime.run();
+        return runtime.exitStatus();
+    }
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java
new file mode 100644
index 000000000..c74d4c10d
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AmbigiousSteps.java
@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class AmbigiousSteps {
+
+    @When("^ambigious step (.+)$")
+    public void ambigious_1() {
+        // nothing here
+    }
+
+    @When("^ambigious step ([a-z]+)$")
+    public void ambigious_2() {
+        // nothing here
+    }
+
+    @Then("^something bad should happen")
+    public void somethingBadStep(){
+        //nothing here
+    }
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java
new file mode 100644
index 000000000..c0242a460
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/AttachmentSteps.java
@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.Scenario;
+import io.cucumber.java.Before;
+import io.cucumber.java.en.Given;
+
+public class AttachmentSteps {
+    private Scenario scenario;
+
+    @Before("@attachments")
+    public void setup(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @Given("step with scenario write")
+    public void stepWithScenarioWrite() {
+        scenario.attach("text attachment".getBytes(), "text/plain", "TextAttachment");
+    }
+
+    @Given("step with scenario embed")
+    public void stepWithScenarioEmbed() {
+        scenario.attach("image attachment".getBytes(), "image/png", "ImageAttachment");
+    }
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java
new file mode 100644
index 000000000..5442225d0
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BackgroundFeatureSteps.java
@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class BackgroundFeatureSteps {
+
+    @Given("^cat is sad$")
+    public void catIsSad() {
+    }
+
+    @Given("^cat is murmur$")
+    public void catIsMurMur() {
+    }
+
+    @When("^pet the cat$")
+    public void petTheCat() {
+    }
+
+    @Then("^cat is happy$")
+    public void catIsHappy() {
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java
new file mode 100644
index 000000000..df3f7042b
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/BrokenFeatureSteps.java
@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.en.Given;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class BrokenFeatureSteps {
+
+    @Given("^everything is broken$")
+    public void everythingIsBroken() {
+        throw new RuntimeException("Oops");
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java
new file mode 100644
index 000000000..ae937b57f
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/DatatableFeatureSteps.java
@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.Given;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@SuppressWarnings("unused")
+public class DatatableFeatureSteps {
+
+    @Given("^users are:$")
+    public void usersAre(DataTable table) {
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java
new file mode 100644
index 000000000..247572252
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/HookSteps.java
@@ -0,0 +1,64 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.After;
+import io.cucumber.java.Before;
+import org.assertj.core.api.Assertions;
+
+/**
+ * @author letsrokk (Dmitry Mayer).
+ */
+public class HookSteps {
+
+    @Before("@WithHooks")
+    public void beforeHook(){
+        // nothing
+    }
+
+    @After("@WithHooks")
+    public void afterHook(){
+        // nothing
+    }
+
+    @Before("@BeforeHookWithException")
+    public void beforeHookWithException(){
+        Assertions.fail("Exception in Hook step");
+    }
+
+    @After("@AfterHookWithException")
+    public void afterHookWithException(){
+        Assertions.fail("Exception in Hook step");
+    }
+
+    @Before("@bp")
+    public void beforePassed() {
+    }
+
+    @Before("@bf")
+    public void beforeFailed() {
+        throw new AssertionError("This hook should fail");
+    }
+
+    @After("@ap")
+    public void afterPassed() {
+    }
+
+    @After("@af")
+    public void afterFailed() {
+        throw new AssertionError("This hook should fail");
+    }
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java
new file mode 100644
index 000000000..060e5c1dc
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/PendingSteps.java
@@ -0,0 +1,32 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.PendingException;
+import io.cucumber.java.en.Given;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class PendingSteps {
+
+    @Given("^step is yet to be implemented$")
+    public void stepIsYetToBeImplemented() {
+        // Write code here that turns the phrase above into concrete actions
+        throw new PendingException();
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java
new file mode 100644
index 000000000..69d63049b
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/java/io/qameta/allure/cucumber7jvm/samples/SimpleFeatureSteps.java
@@ -0,0 +1,55 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.cucumber7jvm.samples;
+
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import org.assertj.core.api.Assertions;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class SimpleFeatureSteps {
+
+    private int a;
+    private int b;
+    private int c;
+
+    @Given("^a is (\\d+)$")
+    public void a_is(int arg1) {
+        this.a = arg1;
+    }
+
+    @Given("^b is (\\d+)$")
+    public void b_is(int arg1) {
+        this.b = arg1;
+    }
+
+    @When("^I add a to b$")
+    public void i_add_a_to_b() {
+        this.c = this.a + this.b;
+    }
+
+    @Then("^result is (\\d+)$")
+    public void result_is(int arg1) {
+        // use manual fail for more stable message format
+        if (this.c != arg1) {
+            Assertions.fail("expecting %d to be equal to %d", this.c, arg1);
+        }
+    }
+
+}
diff --git a/allure-cucumber7-jvm/src/test/resources/allure.properties b/allure-cucumber7-jvm/src/test/resources/allure.properties
new file mode 100644
index 000000000..dbfefee44
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/allure.properties
@@ -0,0 +1,3 @@
+allure.model.indentOutput=true
+allure.results.directory=build/allure-results
+allure.label.epic=#project.description#
diff --git a/allure-cucumber7-jvm/src/test/resources/features/ambigious.feature b/allure-cucumber7-jvm/src/test/resources/features/ambigious.feature
new file mode 100644
index 000000000..921223a39
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/ambigious.feature
@@ -0,0 +1,5 @@
+Feature: Feature with ambigious steps
+
+  Scenario: Simple scenario with ambigious steps
+    When ambigious step present
+    Then something bad should happen
diff --git a/allure-cucumber7-jvm/src/test/resources/features/attachments.feature b/allure-cucumber7-jvm/src/test/resources/features/attachments.feature
new file mode 100644
index 000000000..1585fbe81
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/attachments.feature
@@ -0,0 +1,8 @@
+@attachments
+Feature: Feature with attachments
+
+  Scenario: Simple scenario with a text attachment
+    Given step with scenario write
+
+  Scenario: Simple scenario with an image attachment
+    Given step with scenario embed
\ No newline at end of file
diff --git a/allure-cucumber7-jvm/src/test/resources/features/background.feature b/allure-cucumber7-jvm/src/test/resources/features/background.feature
new file mode 100644
index 000000000..307f10267
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/background.feature
@@ -0,0 +1,9 @@
+Feature: Test Scenarios with backgrounds
+
+  Background:
+    Given cat is sad
+    And cat is murmur
+
+  Scenario: Scenario with background
+    When Pet the cat
+    Then Cat is happy
diff --git a/allure-cucumber7-jvm/src/test/resources/features/broken.feature b/allure-cucumber7-jvm/src/test/resources/features/broken.feature
new file mode 100644
index 000000000..42bd7ba4f
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/broken.feature
@@ -0,0 +1,4 @@
+Feature: Simple feature
+
+  Scenario: Exception during step
+    Given everything is broken
diff --git a/allure-cucumber7-jvm/src/test/resources/features/datatable.feature b/allure-cucumber7-jvm/src/test/resources/features/datatable.feature
new file mode 100644
index 000000000..ea5e94d3b
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/datatable.feature
@@ -0,0 +1,8 @@
+Feature: Test Scenarios with Data Tables
+
+  Scenario: Simple data table
+    Given users are:
+      | name    | login    | email          |
+      | Viktor  | clicman  | clicman@ya.ru  |
+      | Viktor2 | clicman2 | clicman2@ya.ru |
+
diff --git a/allure-cucumber7-jvm/src/test/resources/features/description.feature b/allure-cucumber7-jvm/src/test/resources/features/description.feature
new file mode 100644
index 000000000..935b6731a
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/description.feature
@@ -0,0 +1,17 @@
+Feature: Descriptions feature
+
+This is description for current feature.
+It should appear on each scenario in report
+
+  Scenario: Add a to b (1)
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
+  Scenario: Add a to b (2)
+    Given a is 1
+    And b is 2
+    When I add a to b
+    Then result is 3
+
diff --git a/allure-cucumber7-jvm/src/test/resources/features/examples.feature b/allure-cucumber7-jvm/src/test/resources/features/examples.feature
new file mode 100644
index 000000000..ecba7b79e
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/examples.feature
@@ -0,0 +1,11 @@
+Feature: Test Scenarios with Examples
+
+  Scenario Outline: Scenario with Positive Examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+      | 2 | 4 | 6      |
diff --git a/allure-cucumber7-jvm/src/test/resources/features/failed.feature b/allure-cucumber7-jvm/src/test/resources/features/failed.feature
new file mode 100644
index 000000000..a70f8ec79
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/failed.feature
@@ -0,0 +1,7 @@
+Feature: Simple feature
+
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 123
diff --git a/allure-cucumber7-jvm/src/test/resources/features/hooks.feature b/allure-cucumber7-jvm/src/test/resources/features/hooks.feature
new file mode 100644
index 000000000..aca3f5b1b
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/hooks.feature
@@ -0,0 +1,98 @@
+Feature: Scenarios with hooks
+
+  @WithHooks
+  Scenario: Simple scenario with Before and After hooks
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @BeforeHookWithException
+  Scenario: Simple scenario with Before hook with Exception
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @AfterHookWithException
+  Scenario: Simple scenario with After hook with Exception
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
+
+  @bp @af @bp_sf_af
+  Scenario: Scenario with good before and bad after but failed
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bf @ap @bf_ap
+  Scenario: Scenario with bad before and good after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bf @af @bf_af
+  Scenario: Scenario with bad before and bad after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bp @af @bp_af
+  Scenario: Scenario with bad after
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+
+
+  @bp @ap @bp_sf_ap
+  Scenario: Scenario with good before and good after but failed
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bp @af @bp_su_af
+  Scenario: Step is not implemented with bad after
+    Given hello my friend
+
+
+  @bp @ap @bp_su_ap
+  Scenario: Step is not implemented
+    Given hello my friend
+
+
+  @bp @ap @bp_suf_ap
+  Scenario: Step is not implemented
+    Given hello my friend
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+
+
+  @bp @ap @bp_spu_ap
+  Scenario: Step is not implemented
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 2
+    Given hello my friend
+
+
+  @bp @ap @bp_sfu_ap
+  Scenario: Step is not implemented
+    Given a is 1
+    And b is 1
+    When I add a to b
+    Then result is 3
+    Given hello my friend
diff --git a/allure-cucumber7-jvm/src/test/resources/features/multi-examples.feature b/allure-cucumber7-jvm/src/test/resources/features/multi-examples.feature
new file mode 100644
index 000000000..04fb2cfef
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/multi-examples.feature
@@ -0,0 +1,17 @@
+Feature: Test Scenarios with  multiple Examples
+
+  Scenario Outline: Scenario with Multiple Examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+
+    @ExamplesTag1
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+
+    @ExamplesTag2
+    Examples:
+      | a | b | result |
+      | 2 | 4 | 6      |
\ No newline at end of file
diff --git a/allure-cucumber7-jvm/src/test/resources/features/parallel.feature b/allure-cucumber7-jvm/src/test/resources/features/parallel.feature
new file mode 100644
index 000000000..a99d46839
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/parallel.feature
@@ -0,0 +1,17 @@
+Feature: Parallel execution of pickles
+
+  Scenario Outline: Simple scenario outline with examples
+    Given a is <a>
+    And b is <b>
+    When I add a to b
+    Then result is <result>
+    Examples:
+      | a | b | result |
+      | 1 | 3 | 4      |
+      | 2 | 4 | 6      |
+
+  Scenario: Simple scenario
+    Given a is 7
+    And b is 8
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber7-jvm/src/test/resources/features/pending.feature b/allure-cucumber7-jvm/src/test/resources/features/pending.feature
new file mode 100644
index 000000000..5ad9c3438
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/pending.feature
@@ -0,0 +1,6 @@
+Feature: Simple feature with Pending steps
+
+  Scenario: Step is not implemented
+    Given a is 5
+    When step is yet to be implemented
+    Then b is 10
diff --git a/allure-cucumber7-jvm/src/test/resources/features/scenario_description.feature b/allure-cucumber7-jvm/src/test/resources/features/scenario_description.feature
new file mode 100644
index 000000000..fe49efe31
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/scenario_description.feature
@@ -0,0 +1,19 @@
+Feature: Descriptions feature
+
+This is description for current feature.
+It should appear on each scenario in report
+
+  Scenario: Add a to b (1)
+    scenario description 1
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
+  Scenario: Add a to b (2)
+    scenario description 2
+    Given a is 1
+    And b is 2
+    When I add a to b
+    Then result is 3
+
diff --git a/allure-cucumber7-jvm/src/test/resources/features/simple.feature b/allure-cucumber7-jvm/src/test/resources/features/simple.feature
new file mode 100644
index 000000000..c5b5f2b5f
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/simple.feature
@@ -0,0 +1,7 @@
+Feature: Simple feature
+
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
diff --git a/allure-cucumber7-jvm/src/test/resources/features/tags.feature b/allure-cucumber7-jvm/src/test/resources/features/tags.feature
new file mode 100644
index 000000000..2632623ee
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/tags.feature
@@ -0,0 +1,13 @@
+@FeatureTag
+@tmsLink=OAT-4444
+@flaky
+@issue=BUG-22400
+Feature: Test Simple Scenarios
+
+  @good
+  Scenario: Add a to b
+    Given a is 5
+    And b is 10
+    When I add a to b
+    Then result is 15
+
diff --git a/allure-cucumber7-jvm/src/test/resources/features/undefined.feature b/allure-cucumber7-jvm/src/test/resources/features/undefined.feature
new file mode 100644
index 000000000..39475ff7d
--- /dev/null
+++ b/allure-cucumber7-jvm/src/test/resources/features/undefined.feature
@@ -0,0 +1,6 @@
+Feature: Simple feature with undefined steps
+
+  Scenario: Step is not defined
+    Given  a is 5
+    When step is undefined
+    Then b is 10
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
index a4164acdd..39bbe94f4 100644
--- a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
@@ -22,6 +22,7 @@
 import io.qameta.allure.SeverityLevel;
 import io.qameta.allure.model.FixtureResult;
 import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Parameter;
 import io.qameta.allure.model.Stage;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StatusDetails;
@@ -89,12 +90,18 @@
 })
 public class AllureJunitPlatform implements TestExecutionListener {
 
+    public static final String ALLURE_PARAMETER = "allure.parameter";
+    public static final String ALLURE_PARAMETER_VALUE_KEY = "value";
+    public static final String ALLURE_PARAMETER_MODE_KEY = "mode";
+    public static final String ALLURE_PARAMETER_EXCLUDED_KEY = "excluded";
+
     public static final String ALLURE_FIXTURE = "allure.fixture";
     public static final String PREPARE = "prepare";
     public static final String TEAR_DOWN = "tear_down";
     public static final String EVENT_START = "start";
     public static final String EVENT_STOP = "stop";
     public static final String EVENT_FAILURE = "failure";
+
     public static final String JUNIT_PLATFORM_UNIQUE_ID = "junit.platform.uniqueid";
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunitPlatform.class);
     private static final String STDOUT = "stdout";
@@ -188,40 +195,17 @@ public void executionSkipped(final TestIdentifier testIdentifier,
         );
     }
 
-    @SuppressWarnings({"ReturnCount", "PMD.NcssCount"})
+    @SuppressWarnings({"ReturnCount", "PMD.NcssCount", "CyclomaticComplexity"})
     @Override
     public void reportingEntryPublished(final TestIdentifier testIdentifier,
                                         final ReportEntry entry) {
         final Map<String, String> keyValuePairs = entry.getKeyValuePairs();
         if (keyValuePairs.containsKey(ALLURE_FIXTURE)) {
-            final String type = keyValuePairs.get(ALLURE_FIXTURE);
-            final String event = keyValuePairs.get("event");
-
-            // skip for invalid events
-            if (Objects.isNull(type) || Objects.isNull(event)) {
-                return;
-            }
-
-            switch (event) {
-                case EVENT_START:
-                    final Optional<String> maybeParent = containers.get(testIdentifier);
-                    if (!maybeParent.isPresent()) {
-                        return;
-                    }
-                    final String parentUuid = maybeParent.get();
-                    startFixture(parentUuid, type, keyValuePairs);
-                    return;
-                case EVENT_FAILURE:
-                    failFixture(keyValuePairs);
-                    resetContext(testIdentifier);
-                    return;
-                case EVENT_STOP:
-                    stopFixture(keyValuePairs);
-                    resetContext(testIdentifier);
-                    return;
-                default:
-                    break;
-            }
+            processFixtureEvent(testIdentifier, keyValuePairs);
+            return;
+        }
+        if (keyValuePairs.containsKey(ALLURE_PARAMETER)) {
+            processParameterEvent(keyValuePairs);
             return;
         }
 
@@ -236,6 +220,63 @@ public void reportingEntryPublished(final TestIdentifier testIdentifier,
 
     }
 
+    private void processParameterEvent(final Map<String, String> keyValuePairs) {
+        final String name = keyValuePairs.get(ALLURE_PARAMETER);
+        final String value = keyValuePairs.get(ALLURE_PARAMETER_VALUE_KEY);
+
+        final Parameter parameter = ResultsUtils.createParameter(name, value);
+        if (keyValuePairs.containsKey(ALLURE_PARAMETER_MODE_KEY)) {
+            final String modeString = keyValuePairs.get(ALLURE_PARAMETER_MODE_KEY);
+            Stream.of(Parameter.Mode.values())
+                    .filter(mode -> mode.name().equalsIgnoreCase(modeString))
+                    .findAny()
+                    .ifPresent(parameter::setMode);
+        }
+        if (keyValuePairs.containsKey(ALLURE_PARAMETER_EXCLUDED_KEY)) {
+            final String excludedString = keyValuePairs.get(ALLURE_PARAMETER_EXCLUDED_KEY);
+            Optional.ofNullable(excludedString)
+                    .map(Boolean::parseBoolean)
+                    .ifPresent(parameter::setExcluded);
+        }
+
+        getLifecycle().updateTestCase(tr -> tr.getParameters()
+                .add(parameter)
+        );
+    }
+
+    @SuppressWarnings({"ReturnCount"})
+    private void processFixtureEvent(final TestIdentifier testIdentifier,
+                                     final Map<String, String> keyValuePairs) {
+        final String type = keyValuePairs.get(ALLURE_FIXTURE);
+        final String event = keyValuePairs.get("event");
+
+        // skip for invalid events
+        if (Objects.isNull(type) || Objects.isNull(event)) {
+            return;
+        }
+
+        switch (event) {
+            case EVENT_START:
+                final Optional<String> maybeParent = containers.get(testIdentifier);
+                if (!maybeParent.isPresent()) {
+                    return;
+                }
+                final String parentUuid = maybeParent.get();
+                startFixture(parentUuid, type, keyValuePairs);
+                return;
+            case EVENT_FAILURE:
+                failFixture(keyValuePairs);
+                resetContext(testIdentifier);
+                return;
+            case EVENT_STOP:
+                stopFixture(keyValuePairs);
+                resetContext(testIdentifier);
+                return;
+            default:
+                break;
+        }
+    }
+
     private void resetContext(final TestIdentifier testIdentifier) {
         // in case of fixtures that reported within a test we need to return current
         // test case uuid to allure thread local storage
@@ -362,13 +403,42 @@ private void startTestCase(final TestIdentifier testIdentifier) {
         final Optional<Class<?>> testClass = testSource
                 .flatMap(AllureJunitPlatformUtils::getTestClass);
 
+        final boolean testTemplate = "test-template-invocation"
+                .equals(testIdentifier.getUniqueIdObject().getLastSegment().getType());
+
+        final Optional<TestIdentifier> maybeParent = Optional.of(testPlanStorage)
+                .map(ThreadLocal::get)
+                .flatMap(tp -> tp.getParent(testIdentifier));
+
         final TestResult result = new TestResult()
                 .setUuid(uuid)
-                .setName(testIdentifier.getDisplayName())
+                .setName(testTemplate && maybeParent.isPresent()
+                        ? maybeParent.get().getDisplayName() + " " + testIdentifier.getDisplayName()
+                        : testIdentifier.getDisplayName()
+                )
                 .setLabels(getTags(testIdentifier))
+                .setTestCaseId(testTemplate
+                        ? maybeParent.map(TestIdentifier::getUniqueId)
+                        .orElseGet(testIdentifier::getUniqueId)
+                        : testIdentifier.getUniqueId()
+                )
+                .setTestCaseName(testTemplate
+                        ? maybeParent.map(TestIdentifier::getDisplayName)
+                        .orElseGet(testIdentifier::getDisplayName)
+                        : testIdentifier.getDisplayName())
                 .setHistoryId(getHistoryId(testIdentifier))
                 .setStage(Stage.RUNNING);
 
+        if (testTemplate) {
+            // history id is ignored in Allure TestOps, so we add a hidden parameter
+            // to make sure different results are not considered as retries
+            result.getParameters().add(new Parameter()
+                    .setMode(Parameter.Mode.HIDDEN)
+                    .setName("UniqueId")
+                    .setValue(testIdentifier.getUniqueId())
+            );
+        }
+
         result.getLabels().addAll(getProvidedLabels());
 
         result.getLabels().add(getJUnitPlatformUniqueId(testIdentifier));
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
index 3ee5ed814..4c8ee1121 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
@@ -32,8 +32,10 @@
 import io.qameta.allure.junitplatform.features.OwnerTest;
 import io.qameta.allure.junitplatform.features.ParallelTests;
 import io.qameta.allure.junitplatform.features.ParameterisedTests;
+import io.qameta.allure.junitplatform.features.ParameterisedTestsWithDisplayName;
 import io.qameta.allure.junitplatform.features.PassedTests;
 import io.qameta.allure.junitplatform.features.RepeatedTests;
+import io.qameta.allure.junitplatform.features.ReportEntryParameter;
 import io.qameta.allure.junitplatform.features.SeverityTest;
 import io.qameta.allure.junitplatform.features.SkippedInBeforeAllTests;
 import io.qameta.allure.junitplatform.features.SkippedTests;
@@ -53,6 +55,7 @@
 import io.qameta.allure.model.Attachment;
 import io.qameta.allure.model.Label;
 import io.qameta.allure.model.Link;
+import io.qameta.allure.model.Parameter;
 import io.qameta.allure.model.Stage;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StatusDetails;
@@ -209,9 +212,9 @@ void shouldProcessBrokenInAfterAllTests() {
                         tr -> Optional.of(tr).map(TestResult::getStatusDetails).map(StatusDetails::getMessage).orElse(null))
                 .containsExactlyInAnyOrder(
                         tuple("BrokenInAfterAllTests", Status.BROKEN, "Exception in @AfterAll"),
-                        tuple("[1] value=a", Status.PASSED, null),
-                        tuple("[2] value=b", Status.PASSED, null),
-                        tuple("[3] value=c", Status.PASSED, null),
+                        tuple("parameterisedTest(String) [1] value=a", Status.PASSED, null),
+                        tuple("parameterisedTest(String) [2] value=b", Status.PASSED, null),
+                        tuple("parameterisedTest(String) [3] value=c", Status.PASSED, null),
                         tuple("test1()", Status.PASSED, null),
                         tuple("test2()", Status.PASSED, null)
                 );
@@ -323,7 +326,10 @@ void shouldProcessParametrisedTests() {
                 .hasSize(2)
                 .filteredOn(hasStatus(Status.PASSED))
                 .flatExtracting(TestResult::getName)
-                .containsExactlyInAnyOrder("[1] argument=Hello", "[2] argument=World");
+                .containsExactlyInAnyOrder(
+                        "testWithStringParameter(String) [1] argument=Hello",
+                        "testWithStringParameter(String) [2] argument=World"
+                );
     }
 
     @Test
@@ -773,4 +779,51 @@ void shouldPopulateTestCaseId() {
                 .first()
                 .isEqualTo("[engine:junit-jupiter]/[class:io.qameta.allure.junitplatform.features.JupiterUniqueIdTest]/[method:jupiterTest()]");
     }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldAllowUsageOfDisplayForParameterisedTests() {
+        final AllureResults results = runClasses(ParameterisedTestsWithDisplayName.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(
+                        TestResult::getName
+                )
+                .containsExactlyInAnyOrder(
+                        "Second Test [1] value=a",
+                        "Second Test [2] value=b"
+                );
+    }
+
+    @AllureFeatures.Parameters
+    @Test
+    void shouldProcessAllureParameterReportingEvents() {
+        final AllureResults results = runClasses(ReportEntryParameter.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .filteredOn("name", "simpleParameterEvent(TestReporter)")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .containsExactlyInAnyOrder(
+                        tuple("some parameter name", "some parameter value", null, null)
+                );
+        assertThat(testResults)
+                .filteredOn("name", "multipleParameterEvent(TestReporter)")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .containsExactlyInAnyOrder(
+                        tuple("first name", "first value", null, null),
+                        tuple("second name", "second value", null, null),
+                        tuple("third name", "third value", null, null)
+                );
+        assertThat(testResults)
+                .filteredOn("name", "modeAndExcluded(TestReporter)")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .containsExactlyInAnyOrder(
+                        tuple("hidden excluded", "hidden excluded value", Parameter.Mode.HIDDEN, true),
+                        tuple("default excluded", "default excluded value", Parameter.Mode.DEFAULT, true),
+                        tuple("masked not excluded", "masked not excluded value", Parameter.Mode.MASKED, false)
+                );
+    }
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java
new file mode 100644
index 000000000..dfb83eff8
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParameterisedTestsWithDisplayName.java
@@ -0,0 +1,33 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class ParameterisedTestsWithDisplayName {
+
+    @DisplayName("Second Test")
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void first(String value) {
+    }
+
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java
new file mode 100644
index 000000000..c7dc820d3
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ReportEntryParameter.java
@@ -0,0 +1,93 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.model.Parameter;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestReporter;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_EXCLUDED_KEY;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_MODE_KEY;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_VALUE_KEY;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class ReportEntryParameter {
+
+    @Test
+    void simpleParameterEvent(TestReporter testReporter) {
+        testReporter.publishEntry(buildEvent("some parameter name", "some parameter value"));
+    }
+
+    @Test
+    void multipleParameterEvent(TestReporter testReporter) {
+        testReporter.publishEntry(buildEvent("first name", "first value"));
+        testReporter.publishEntry(buildEvent("second name", "second value"));
+        testReporter.publishEntry(buildEvent("third name", "third value"));
+    }
+
+    @Test
+    void modeAndExcluded(TestReporter testReporter) {
+        testReporter.publishEntry(buildEvent(
+                "hidden excluded",
+                "hidden excluded value",
+                Parameter.Mode.HIDDEN,
+                true
+        ));
+        testReporter.publishEntry(buildEvent(
+                "default excluded",
+                "default excluded value",
+                Parameter.Mode.DEFAULT,
+                true
+        ));
+        testReporter.publishEntry(buildEvent(
+                "masked not excluded",
+                "masked not excluded value",
+                Parameter.Mode.MASKED,
+                false
+        ));
+    }
+
+    private Map<String, String> buildEvent(final String name,
+                                           final String value) {
+        return buildEvent(name, value, null, null);
+    }
+
+    private Map<String, String> buildEvent(final String name,
+                                           final String value,
+                                           final Parameter.Mode mode,
+                                           final Boolean excluded) {
+        final Map<String, String> data = new HashMap<>();
+        data.put(ALLURE_PARAMETER, name);
+        data.put(ALLURE_PARAMETER_VALUE_KEY, value);
+        if (Objects.nonNull(mode)) {
+            data.put(ALLURE_PARAMETER_MODE_KEY, mode.name());
+        }
+        if (Objects.nonNull(excluded)) {
+            data.put(ALLURE_PARAMETER_EXCLUDED_KEY, excluded.toString());
+        }
+
+        return data;
+    }
+
+
+}
diff --git a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java b/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
index 9f2e2b04f..2ac552bd8 100644
--- a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
+++ b/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5.java
@@ -15,20 +15,28 @@
  */
 package io.qameta.allure.junit5;
 
+import io.qameta.allure.Param;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StatusDetails;
+import io.qameta.allure.util.ObjectUtils;
 import io.qameta.allure.util.ResultsUtils;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.InvocationInterceptor;
 import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Stream;
 
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_FIXTURE;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_EXCLUDED_KEY;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_MODE_KEY;
+import static io.qameta.allure.junitplatform.AllureJunitPlatform.ALLURE_PARAMETER_VALUE_KEY;
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.EVENT_FAILURE;
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.EVENT_START;
 import static io.qameta.allure.junitplatform.AllureJunitPlatform.EVENT_STOP;
@@ -41,6 +49,47 @@
 @SuppressWarnings("MultipleStringLiterals")
 public class AllureJunit5 implements InvocationInterceptor {
 
+    @Override
+    public void interceptTestTemplateMethod(final Invocation<Void> invocation,
+                                            final ReflectiveInvocationContext<Method> invocationContext,
+                                            final ExtensionContext extensionContext) throws Throwable {
+        sendParameterEvent(invocationContext, extensionContext);
+        invocation.proceed();
+    }
+
+    private void sendParameterEvent(final ReflectiveInvocationContext<Method> invocationContext,
+                                    final ExtensionContext extensionContext) {
+        final Parameter[] parameters = invocationContext.getExecutable().getParameters();
+        for (int i = 0; i < parameters.length; i++) {
+            final Parameter parameter = parameters[i];
+
+            final Class<?> parameterType = parameter.getType();
+            // Skip default jupiter injectables as TestInfo, TestReporter and TempDirectory
+            if (parameterType.getPackage().getName().startsWith("org.junit.jupiter.api")) {
+                continue;
+            }
+            final Object value = invocationContext.getArguments().get(i);
+            final Map<String, String> map = new HashMap<>();
+            map.put(ALLURE_PARAMETER, parameter.getName());
+            map.put(ALLURE_PARAMETER_VALUE_KEY, ObjectUtils.toString(value));
+
+            Stream.of(parameter.getAnnotationsByType(Param.class))
+                    .findFirst()
+                    .ifPresent(param -> {
+                        Stream.of(param.value(), param.name())
+                                .map(String::trim)
+                                .filter(name -> name.length() > 0)
+                                .findFirst()
+                                .ifPresent(name -> map.put(ALLURE_PARAMETER, name));
+
+                        map.put(ALLURE_PARAMETER_MODE_KEY, param.mode().name());
+                        map.put(ALLURE_PARAMETER_EXCLUDED_KEY, Boolean.toString(param.excluded()));
+                    });
+
+            extensionContext.publishReportEntry(map);
+        }
+    }
+
     @Override
     public void interceptBeforeAllMethod(
             final Invocation<Void> invocation,
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java b/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
index db61285fe..c69eeff77 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
+++ b/allure-junit5/src/test/java/io/qameta/allure/junit5/AllureJunit5Test.java
@@ -24,8 +24,11 @@
 import io.qameta.allure.junit5.features.AllFixtureSupport;
 import io.qameta.allure.junit5.features.BeforeEachFixtureFailureSupport;
 import io.qameta.allure.junit5.features.EachFixtureSupport;
+import io.qameta.allure.junit5.features.ParameterisedTests;
+import io.qameta.allure.junit5.features.SkipOtherInjectables;
 import io.qameta.allure.junitplatform.AllureJunitPlatform;
 import io.qameta.allure.model.FixtureResult;
+import io.qameta.allure.model.Parameter;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StepResult;
 import io.qameta.allure.model.TestResult;
@@ -54,6 +57,84 @@
 @SuppressWarnings("unchecked")
 class AllureJunit5Test {
 
+    @Test
+    void shouldSupportParametersForParameterisedTests() {
+        final AllureResults results = runClasses(ParameterisedTests.class);
+
+        assertThat(results.getTestResults())
+                .filteredOn("name", "first(String) [1] value=a")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("value", "a", null, null)
+                );
+
+        assertThat(results.getTestResults())
+                .filteredOn("name", "first(String) [2] value=b")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("value", "b", null, null)
+                );
+
+    }
+
+    @Test
+    void shouldSupportParamAnnotationForParameters() {
+        final AllureResults results = runClasses(ParameterisedTests.class);
+
+        assertThat(results.getTestResults())
+                .filteredOn("name", "third(String) [1] value=a")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("some value", "a", Parameter.Mode.DEFAULT, false)
+                );
+
+        assertThat(results.getTestResults())
+                .filteredOn("name", "third(String) [2] value=b")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("some value", "b", Parameter.Mode.DEFAULT, false)
+                );
+
+    }
+
+    @Test
+    void shouldSkipReportingOfTestInjectablesTestReporterForRegularTest() {
+        final AllureResults results = runClasses(SkipOtherInjectables.class);
+
+        assertThat(results.getTestResults())
+                .filteredOn("fullName", "io.qameta.allure.junit5.features.SkipOtherInjectables.regularTestWithReporterInjection")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue)
+                .isEmpty();
+    }
+
+    @Test
+    void shouldSkipReportingOfTestInjectablesTestReporterForParameterisedTest() {
+        final AllureResults results = runClasses(SkipOtherInjectables.class);
+
+        assertThat(results.getTestResults())
+                .filteredOn("fullName", "io.qameta.allure.junit5.features.SkipOtherInjectables.testReporterInjection")
+                .filteredOn("name", "testReporterInjection(String, TestReporter) [1] value=a")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("value", "a", null, null)
+                );
+
+        assertThat(results.getTestResults())
+                .filteredOn("fullName", "io.qameta.allure.junit5.features.SkipOtherInjectables.testReporterInjection")
+                .filteredOn("name", "testReporterInjection(String, TestReporter) [2] value=b")
+                .flatExtracting(TestResult::getParameters)
+                .extracting(Parameter::getName, Parameter::getValue, Parameter::getMode, Parameter::getExcluded)
+                .contains(
+                        tuple("value", "b", null, null)
+                );
+    }
+
     @Test
     void shouldSupportBeforeEachFixture() {
         final AllureResults results = runClasses(EachFixtureSupport.class);
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java b/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
new file mode 100644
index 000000000..e1ab37cf2
--- /dev/null
+++ b/allure-junit5/src/test/java/io/qameta/allure/junit5/features/ParameterisedTests.java
@@ -0,0 +1,49 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit5.features;
+
+import io.qameta.allure.Param;
+import org.junit.jupiter.api.TestReporter;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class ParameterisedTests {
+
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void first(String value) {
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void second(String value) {
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void third(@Param("some value") String value) {
+    }
+
+
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void testReporterInjection(String value, TestReporter testReporter) {
+    }
+
+}
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java b/allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
new file mode 100644
index 000000000..4e566370b
--- /dev/null
+++ b/allure-junit5/src/test/java/io/qameta/allure/junit5/features/SkipOtherInjectables.java
@@ -0,0 +1,37 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package io.qameta.allure.junit5.features;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestReporter;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class SkipOtherInjectables {
+
+    @Test
+    void regularTestWithReporterInjection(TestReporter testReporter) {
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"a", "b"})
+    void testReporterInjection(String value, TestReporter testReporter) {
+    }
+
+}
diff --git a/allure-model/src/main/java/io/qameta/allure/model/TestResult.java b/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
index 1c9cbb47e..fdbd569db 100644
--- a/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
+++ b/allure-model/src/main/java/io/qameta/allure/model/TestResult.java
@@ -42,6 +42,7 @@ public class TestResult implements Serializable, ExecutableItem, WithLinks {
     private String uuid;
     private String historyId;
     private String testCaseId;
+    private String testCaseName;
     private String fullName;
     private List<Label> labels = new ArrayList<>();
     private List<Link> links = new ArrayList<>();
@@ -117,6 +118,26 @@ public TestResult setTestCaseId(final String value) {
         return this;
     }
 
+    /**
+     * Gets test case name.
+     *
+     * @return the test case name
+     */
+    public String getTestCaseName() {
+        return testCaseName;
+    }
+
+    /**
+     * Sets test case name.
+     *
+     * @param value the value
+     * @return self for method chaining.
+     */
+    public TestResult setTestCaseName(final String value) {
+        this.testCaseName = value;
+        return this;
+    }
+
     /**
      * Gets full name.
      *
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
index 2e0be5da6..6508d198e 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/AllureEnumDeserializer.java
@@ -24,9 +24,12 @@
 import java.util.stream.Stream;
 
 /**
- * @author charlie (Dmitry Baev).
  * @param <T> the enum's type
+ * @author charlie (Dmitry Baev).
+ * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS}
+ * and {@link com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
+@Deprecated
 /* package-private */ abstract class AllureEnumDeserializer<T extends Enum<T>> extends StdDeserializer<T> {
 
     private final Class<T> type;
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java b/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
index acfade3ad..ad91d2899 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/AllureObjectMapperFactory.java
@@ -18,10 +18,7 @@
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.module.SimpleModule;
-import io.qameta.allure.model.Parameter;
-import io.qameta.allure.model.Stage;
-import io.qameta.allure.model.Status;
+import com.fasterxml.jackson.databind.json.JsonMapper;
 
 /**
  * @author charlie (Dmitry Baev).
@@ -33,14 +30,15 @@ private AllureObjectMapperFactory() {
     }
 
     public static ObjectMapper createMapper() {
-        return new ObjectMapper()
+        return JsonMapper.builder()
                 .enable(MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME)
                 .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS)
+                .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
+                .enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)
                 .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
-                .registerModule(new SimpleModule()
-                        .addDeserializer(Status.class, new StatusDeserializer())
-                        .addDeserializer(Stage.class, new StageDeserializer())
-                        .addDeserializer(Parameter.Mode.class, new ParameterModeDeserializer())
-                );
+                .disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES)
+                .disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)
+                .disable(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS)
+                .build();
     }
 }
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
index 68a68cd84..197a6c6d1 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/ParameterModeDeserializer.java
@@ -19,7 +19,10 @@
 
 /**
  * @author charlie (Dmitry Baev).
+ * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS}
+ * and {@link com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
+@Deprecated
 public class ParameterModeDeserializer extends AllureEnumDeserializer<Parameter.Mode> {
     public ParameterModeDeserializer() {
         super(Parameter.Mode.class);
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
index f8de06408..0bea2076c 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/StageDeserializer.java
@@ -19,7 +19,10 @@
 
 /**
  * @author charlie (Dmitry Baev).
+ * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS}
+ * and {@link com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
+@Deprecated
 public class StageDeserializer extends AllureEnumDeserializer<Stage> {
     public StageDeserializer() {
         super(Stage.class);
diff --git a/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java b/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
index 5b86f6b35..eb499add8 100644
--- a/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
+++ b/allure-reader/src/main/java/io/qameta/allure/reader/StatusDeserializer.java
@@ -19,7 +19,10 @@
 
 /**
  * @author charlie (Dmitry Baev).
+ * @deprecated in favor of {@link com.fasterxml.jackson.databind.MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS}
+ * and {@link com.fasterxml.jackson.databind.DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL}
  */
+@Deprecated
 public class StatusDeserializer extends AllureEnumDeserializer<Status> {
     public StatusDeserializer() {
         super(Status.class);
diff --git a/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java b/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
index c08d960ba..a916012fe 100644
--- a/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
+++ b/allure-rest-assured/src/main/java/io/qameta/allure/restassured/AllureRestAssured.java
@@ -33,6 +33,7 @@
 
 import static io.qameta.allure.attachment.http.HttpRequestAttachment.Builder.create;
 import static io.qameta.allure.attachment.http.HttpResponseAttachment.Builder.create;
+import static java.util.Optional.ofNullable;
 
 /**
  * Allure logger filter for Rest-assured.
@@ -105,10 +106,11 @@ public Response filter(final FilterableRequestSpecification requestSpec,
         );
 
         final Response response = filterContext.next(requestSpec, responseSpec);
-        if (Objects.isNull(responseAttachmentName)) {
-            responseAttachmentName = response.getStatusLine();
-        }
-        final HttpResponseAttachment responseAttachment = create(responseAttachmentName)
+
+        final String attachmentName = ofNullable(responseAttachmentName)
+                .orElse(response.getStatusLine());
+
+        final HttpResponseAttachment responseAttachment = create(attachmentName)
                 .setResponseCode(response.getStatusCode())
                 .setHeaders(toMapConverter(response.getHeaders()))
                 .setBody(prettifier.getPrettifiedBodyIfPossible(response, response.getBody()))
diff --git a/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java b/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
index e92d5d866..d3121ed0f 100644
--- a/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
+++ b/allure-rest-assured/src/test/java/io/qameta/allure/restassured/AllureRestAssuredTest.java
@@ -16,6 +16,7 @@
 package io.qameta.allure.restassured;
 
 import com.github.tomakehurst.wiremock.WireMockServer;
+import com.github.tomakehurst.wiremock.client.ResponseDefinitionBuilder;
 import com.github.tomakehurst.wiremock.client.WireMock;
 import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
 import com.google.common.collect.ImmutableList;
@@ -23,14 +24,19 @@
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.test.AllureResults;
 import io.restassured.RestAssured;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.ArgumentsProvider;
 import org.junit.jupiter.params.provider.ArgumentsSource;
-import java.util.*;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+
 import static io.qameta.allure.test.RunUtils.runWithinTestContext;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
@@ -68,6 +74,41 @@ void shouldCreateAttachment(final List<String> attachmentNames, final AllureRest
                 .isEqualTo(attachmentNames);
     }
 
+    @Test
+    void shouldProperlySetAttachmentNameForSingleFilterInstance() {
+        final AllureRestAssured filter = new AllureRestAssured();
+
+        final ResponseDefinitionBuilder responseBuilderOne = WireMock.aResponse()
+                .withStatus(200)
+                .withBody("some body");
+
+        final ResponseDefinitionBuilder responseBuilderTwo = WireMock.aResponse()
+                .withStatus(400)
+                .withBody("some other body");
+
+        RestAssured.replaceFiltersWith(filter);
+        final AllureResults resultsOne = executeWithStub(responseBuilderOne);
+
+        RestAssured.replaceFiltersWith(filter);
+        final AllureResults resultsTwo = executeWithStub(responseBuilderTwo);
+
+        assertThat(resultsOne.getTestResults()
+                .stream()
+                .map(TestResult::getAttachments)
+                .flatMap(Collection::stream)
+                .map(Attachment::getName))
+                .hasSize(2)
+                .anyMatch(res -> res.equals("HTTP/1.1 200 OK"));
+
+        assertThat(resultsTwo.getTestResults()
+                .stream()
+                .map(TestResult::getAttachments)
+                .flatMap(Collection::stream)
+                .map(Attachment::getName))
+                .hasSize(2)
+                .anyMatch(res -> res.equals("HTTP/1.1 400 Bad Request"));
+    }
+
     @ParameterizedTest
     @ArgumentsSource(AttachmentArgumentProvider.class)
     void shouldCatchAttachmentBody(final List<String> attachmentNames, final AllureRestAssured filter) {
@@ -91,15 +132,20 @@ void shouldCatchAttachmentBody(final List<String> attachmentNames, final AllureR
     }
 
     protected final AllureResults execute() {
+        return executeWithStub(WireMock.aResponse().withBody("some body"));
+    }
+
+    protected final AllureResults executeWithStub(ResponseDefinitionBuilder responseBuilder) {
         final WireMockServer server = new WireMockServer(WireMockConfiguration.options().dynamicPort());
+        final int statusCode = responseBuilder.build().getStatus();
 
         return runWithinTestContext(() -> {
             server.start();
             WireMock.configureFor(server.port());
 
-            WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello")).willReturn(WireMock.aResponse().withBody("some body")));
+            WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello")).willReturn(responseBuilder));
             try {
-                RestAssured.when().get(server.url("/hello")).then().statusCode(200);
+                RestAssured.when().get(server.url("/hello")).then().statusCode(statusCode);
             } finally {
                 server.stop();
                 RestAssured.replaceFiltersWith(ImmutableList.of());
diff --git a/allure-spring-web/build.gradle.kts b/allure-spring-web/build.gradle.kts
index b8f3eac3c..4841fe9d4 100644
--- a/allure-spring-web/build.gradle.kts
+++ b/allure-spring-web/build.gradle.kts
@@ -1,6 +1,6 @@
 description = "Allure Spring Web Integration"
 
-val springWebVersion = "5.3.12"
+val springWebVersion = "5.3.13"
 
 dependencies {
     api(project(":allure-attachments"))
diff --git a/build.gradle.kts b/build.gradle.kts
index 983261822..472a978e3 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -131,7 +131,7 @@ configure(libs) {
     dependencyManagement {
         imports {
             mavenBom("com.fasterxml.jackson:jackson-bom:2.13.0")
-            mavenBom("org.junit:junit-bom:5.8.1")
+            mavenBom("org.junit:junit-bom:5.8.2")
         }
         dependencies {
             dependency("com.github.tomakehurst:wiremock:2.27.2")
@@ -149,9 +149,9 @@ configure(libs) {
             dependency("org.assertj:assertj-core:3.21.0")
             dependency("org.codehaus.groovy:groovy-all:2.5.13")
             dependency("org.freemarker:freemarker:2.3.31")
-            dependency("org.jboss.resteasy:resteasy-client:4.7.2.Final")
+            dependency("org.jboss.resteasy:resteasy-client:4.7.3.Final")
             dependency("org.mock-server:mockserver-netty:5.11.2")
-            dependency("org.mockito:mockito-core:4.0.0")
+            dependency("org.mockito:mockito-core:4.1.0")
             dependencySet("org.slf4j:1.7.30") {
                 entry("slf4j-api")
                 entry("slf4j-nop")
@@ -198,7 +198,7 @@ configure(libs) {
             systemProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug")
             systemProperty("allure.model.indentOutput", "true")
             systemProperty("junit.jupiter.execution.parallel.enabled", true)
-            systemProperty("junit.jupiter.execution.parallel.mode.default", true)
+            systemProperty("junit.jupiter.execution.parallel.mode.default", "same_thread")
             testLogging {
                 listOf(org.gradle.api.tasks.testing.logging.TestLogEvent.FAILED)
             }
diff --git a/gradle.properties b/gradle.properties
index 20b6ae314..1cec2183a 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-version=2.16.1
+version=2.17.0
 
 org.gradle.daemon=true
 org.gradle.parallel=true
diff --git a/gradle/quality-configs/pmd/pmd.xml b/gradle/quality-configs/pmd/pmd.xml
index 181a946aa..ad5ac393c 100644
--- a/gradle/quality-configs/pmd/pmd.xml
+++ b/gradle/quality-configs/pmd/pmd.xml
@@ -144,7 +144,9 @@
 
 
     <!-- Performance (https://pmd.github.io/pmd-6.0.1/pmd_rules_java_performance.html) -->
-    <rule ref="category/java/performance.xml"/>
+    <rule ref="category/java/performance.xml">
+        <exclude name="AvoidInstantiatingObjectsInLoops"/>
+    </rule>
 
 
     <!-- Security (no rules) -->
diff --git a/settings.gradle.kts b/settings.gradle.kts
index c8e819b22..faf5d3422 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -10,6 +10,7 @@ include("allure-cucumber3-jvm")
 include("allure-cucumber4-jvm")
 include("allure-cucumber5-jvm")
 include("allure-cucumber6-jvm")
+include("allure-cucumber7-jvm")
 include("allure-descriptions-javadoc")
 include("allure-hamcrest")
 include("allure-httpclient")
@@ -44,7 +45,7 @@ pluginManagement {
     plugins {
         id("com.diffplug.spotless") version "5.13.0"
         id("com.github.johnrengelman.shadow") version "7.0.0"
-        id("com.gradle.enterprise") version "3.6.2"
+        id("com.gradle.enterprise") version "3.7.2"
         id("io.github.gradle-nexus.publish-plugin") version "1.1.0"
         id("io.qameta.allure-adapter") version "2.9.6"
         id("io.qameta.allure-aggregate-report") version "2.9.6"