diff --git a/allure-cucumber3-jvm/src/main/java/io/qameta/allure/cucumber3jvm/AllureCucumber3Jvm.java b/allure-cucumber3-jvm/src/main/java/io/qameta/allure/cucumber3jvm/AllureCucumber3Jvm.java
index 4daa67b0a..666c083fe 100644
--- a/allure-cucumber3-jvm/src/main/java/io/qameta/allure/cucumber3jvm/AllureCucumber3Jvm.java
+++ b/allure-cucumber3-jvm/src/main/java/io/qameta/allure/cucumber3jvm/AllureCucumber3Jvm.java
@@ -217,7 +217,6 @@ private String getHistoryId(final TestCase testCase) {
         return Utils.md5(testCaseLocation);
     }
 
-    @SuppressWarnings("ReturnCount")
     private Status translateTestCaseStatus(final Result testCaseResult) {
         switch (testCaseResult.getStatus()) {
             case FAILED:
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java
new file mode 100644
index 000000000..81ffcb5e6
--- /dev/null
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllurePredicates.java
@@ -0,0 +1,30 @@
+package io.qameta.allure.test;
+
+import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Status;
+import io.qameta.allure.model.TestResult;
+
+import java.util.Objects;
+import java.util.function.Predicate;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@SuppressWarnings({"PMD.ClassNamingConventions", "PMD.LinguisticNaming"})
+public final class AllurePredicates {
+
+    private AllurePredicates() {
+        throw new IllegalStateException("Do not instance");
+    }
+
+    public static Predicate<TestResult> hasStatus(final Status status) {
+        return testResult -> status.equals(testResult.getStatus());
+    }
+
+    public static Predicate<TestResult> hasLabel(final String name, final String value) {
+        final Predicate<Label> labelPredicate = label -> Objects.equals(label.getName(), name)
+                && Objects.equals(label.getValue(), value);
+
+        return testResult -> testResult.getLabels().stream().anyMatch(labelPredicate);
+    }
+}
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
index 8047fe49a..06cb33abe 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/AspectUtils.java
@@ -41,7 +41,6 @@ public static Map<String, Object> getParametersMap(final MethodSignature signatu
         return params;
     }
 
-    @SuppressWarnings("ReturnCount")
     public static String objectToString(final Object object) {
         try {
             if (Objects.nonNull(object) && (object instanceof Object[])) {
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
index d9cdf44db..6db7e5979 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/NamingUtils.java
@@ -42,7 +42,6 @@ public static String processNameTemplate(final String template, final Map<String
         return sb.toString();
     }
 
-    @SuppressWarnings("ReturnCount")
     private static Optional<String> processPattern(final String pattern, final Map<String, Object> params) {
         if (pattern.isEmpty()) {
             LOGGER.error("Could not process empty pattern");
diff --git a/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java b/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
index b29cad7fa..8d38e7519 100644
--- a/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
+++ b/allure-java-commons/src/main/java/io/qameta/allure/util/ResultsUtils.java
@@ -58,6 +58,7 @@ public final class ResultsUtils {
     public static final String ISSUE_LINK_TYPE = "issue";
     public static final String TMS_LINK_TYPE = "tms";
 
+    public static final String SUITE_LABEL_NAME = "suite";
     public static final String EPIC_LABEL_NAME = "epic";
     public static final String FEATURE_LABEL_NAME = "feature";
     public static final String STORY_LABEL_NAME = "story";
@@ -66,6 +67,9 @@ public final class ResultsUtils {
     public static final String OWNER_LABEL_NAME = "owner";
     public static final String HOST_LABEL_NAME = "host";
     public static final String THREAD_LABEL_NAME = "thread";
+    public static final String TEST_METHOD_LABEL_NAME = "testMethod";
+    public static final String TEST_CLASS_LABEL_NAME = "testClass";
+    public static final String PACKAGE_LABEL_NAME = "package";
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ResultsUtils.class);
     private static final String ALLURE_DESCRIPTIONS_PACKAGE = "allureDescriptions/";
@@ -77,6 +81,22 @@ private ResultsUtils() {
         throw new IllegalStateException("Do not instance");
     }
 
+    public static Label createSuiteLabel(final String suite) {
+        return new Label().setName(SUITE_LABEL_NAME).setValue(suite);
+    }
+
+    public static Label createTestMethodLabel(final String testMethod) {
+        return new Label().setName(TEST_METHOD_LABEL_NAME).setValue(testMethod);
+    }
+
+    public static Label createTestClassLabel(final String testClass) {
+        return new Label().setName(TEST_CLASS_LABEL_NAME).setValue(testClass);
+    }
+
+    public static Label createPackageLabel(final String packageName) {
+        return new Label().setName(PACKAGE_LABEL_NAME).setValue(packageName);
+    }
+
     public static Label createEpicLabel(final String epic) {
         return new Label().setName(EPIC_LABEL_NAME).setValue(epic);
     }
@@ -301,6 +321,9 @@ public static void processDescription(final ClassLoader classLoader,
 
     private static Optional<String> readResource(final ClassLoader classLoader, final String resourceName) {
         try (InputStream is = classLoader.getResourceAsStream(resourceName)) {
+            if (Objects.isNull(is)) {
+                return Optional.empty();
+            }
             final byte[] bytes = IOUtils.toByteArray(is);
             return Optional.of(new String(bytes, StandardCharsets.UTF_8));
         } catch (IOException e) {
diff --git a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
index 77dd38dfa..bccba70bb 100644
--- a/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
+++ b/allure-jsonunit/src/main/java/io/qameta/allure/jsonunit/JsonPatchListener.java
@@ -38,7 +38,6 @@ public DifferenceContext getContext() {
         return context;
     }
 
-    @SuppressWarnings("ReturnCount")
     private String getPath(final Difference difference) {
         switch (difference.getType()) {
             case DIFFERENT:
diff --git a/allure-junit-platform/build.gradle.kts b/allure-junit-platform/build.gradle.kts
index f18918b11..c2dac50d9 100644
--- a/allure-junit-platform/build.gradle.kts
+++ b/allure-junit-platform/build.gradle.kts
@@ -4,14 +4,17 @@ val agent by configurations.creating
 
 dependencies {
     agent("org.aspectj:aspectjweaver")
-    compile(project(":allure-java-commons"))
     compile("org.junit.jupiter:junit-jupiter-api")
     compile("org.junit.platform:junit-platform-launcher")
-    testCompile(project(":allure-java-commons-test"))
+    compile(project(":allure-java-commons"))
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testCompile("io.github.glytching:junit-extensions")
     testCompile("org.assertj:assertj-core")
     testCompile("org.junit.jupiter:junit-jupiter-api")
     testCompile("org.junit.jupiter:junit-jupiter-params")
     testCompile("org.slf4j:slf4j-simple")
+    testCompile(project(":allure-assertj"))
+    testCompile(project(":allure-java-commons-test"))
     testRuntime("org.junit.jupiter:junit-jupiter-engine")
 }
 
@@ -27,6 +30,7 @@ tasks.named<Jar>("jar") {
 }
 
 tasks.named<Test>("test") {
+    systemProperty("junit.jupiter.execution.parallel.enabled", "false")
     useJUnitPlatform()
     exclude("**/features/*")
     doFirst {
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 ace4fe289..d9766d923 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
@@ -3,51 +3,80 @@
 import io.qameta.allure.Allure;
 import io.qameta.allure.AllureLifecycle;
 import io.qameta.allure.Description;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Owner;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import io.qameta.allure.Story;
 import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
 import io.qameta.allure.model.Stage;
 import io.qameta.allure.model.Status;
+import io.qameta.allure.model.StatusDetails;
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.util.ResultsUtils;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.platform.engine.TestExecutionResult;
+import org.junit.platform.engine.TestTag;
+import org.junit.platform.engine.reporting.ReportEntry;
 import org.junit.platform.engine.support.descriptor.MethodSource;
 import org.junit.platform.launcher.TestExecutionListener;
 import org.junit.platform.launcher.TestIdentifier;
+import org.junit.platform.launcher.TestPlan;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
 import java.math.BigInteger;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static io.qameta.allure.model.Status.FAILED;
 import static io.qameta.allure.model.Status.PASSED;
 import static io.qameta.allure.model.Status.SKIPPED;
-import static io.qameta.allure.util.ResultsUtils.getHostName;
-import static io.qameta.allure.util.ResultsUtils.getThreadName;
+import static io.qameta.allure.util.ResultsUtils.createHostLabel;
+import static io.qameta.allure.util.ResultsUtils.createPackageLabel;
+import static io.qameta.allure.util.ResultsUtils.createSuiteLabel;
+import static io.qameta.allure.util.ResultsUtils.createTestClassLabel;
+import static io.qameta.allure.util.ResultsUtils.createTestMethodLabel;
+import static io.qameta.allure.util.ResultsUtils.createThreadLabel;
+import static io.qameta.allure.util.ResultsUtils.getMd5Digest;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 /**
  * @author ehborisov
  */
+@SuppressWarnings("deprecation")
 public class AllureJunitPlatform implements TestExecutionListener {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunitPlatform.class);
 
-    private static final String TAG = "tag";
-    private static final String SUITE = "suite";
-    private static final String PACKAGE = "package";
-    private static final String THREAD = "thread";
-    private static final String HOST = "host";
-    private static final String CLASS_NAME = "className";
-    private static final String METHOD_NAME = "methodName";
+    private static final String STDOUT = "stdout";
+    private static final String STDERR = "stderr";
+    private static final String TEXT_PLAIN = "text/plain";
+    private static final String TXT_EXTENSION = ".txt";
 
-    private final ThreadLocal<String> tests
-            = InheritableThreadLocal.withInitial(() -> UUID.randomUUID().toString());
+    private final ThreadLocal<TestPlan> testPlanStorage = new InheritableThreadLocal<>();
+
+    private final Map<TestIdentifier, String> testUuids = new ConcurrentHashMap<>();
+
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
     private final AllureLifecycle lifecycle;
 
@@ -63,113 +92,225 @@ public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    @Override
+    public void testPlanExecutionStarted(final TestPlan testPlan) {
+        testPlanStorage.set(testPlan);
+    }
+
+    @Override
+    public void testPlanExecutionFinished(final TestPlan testPlan) {
+        testPlanStorage.remove();
+    }
+
     @Override
     public void executionStarted(final TestIdentifier testIdentifier) {
         if (testIdentifier.isTest()) {
-            final Optional<MethodSource> methodSource = testIdentifier.getSource()
-                    .filter(MethodSource.class::isInstance)
-                    .map(MethodSource.class::cast);
-            final String uuid = tests.get();
-            final TestResult result = new TestResult()
-                    .setUuid(uuid)
-                    .setName(testIdentifier.getDisplayName())
-                    .setLabels(getTags(testIdentifier))
-                    .setHistoryId(getHistoryId(testIdentifier))
-                    .setStage(Stage.RUNNING);
-
-            result.getLabels().add(new Label().setName(THREAD).setValue(getThreadName()));
-            result.getLabels().add(new Label().setName(HOST).setValue(getHostName()));
-
-            methodSource.ifPresent(source -> updateResultFromSource(result, source));
-
-            getLifecycle().scheduleTestCase(result);
-            getLifecycle().startTestCase(uuid);
+            startTestCase(testIdentifier);
         }
     }
 
     @Override
     public void executionSkipped(final TestIdentifier testIdentifier, final String reason) {
         if (testIdentifier.isTest()) {
-            final String uuid = tests.get();
-            final TestResult result = new TestResult()
-                    .setUuid(uuid)
-                    .setName(testIdentifier.getDisplayName())
-                    .setLabels(getTags(testIdentifier))
-                    .setHistoryId(getHistoryId(testIdentifier))
-                    .setStage(Stage.RUNNING);
-
-            result.getLabels().add(new Label().setName(THREAD).setValue(getThreadName()));
-            result.getLabels().add(new Label().setName(HOST).setValue(getHostName()));
-
-            testIdentifier
-                    .getSource()
-                    .filter(MethodSource.class::isInstance)
-                    .map(MethodSource.class::cast)
-                    .ifPresent(source -> updateResultFromSource(result, source));
-
-            getLifecycle().scheduleTestCase(result);
-            getLifecycle().startTestCase(uuid);
-
-            tests.remove();
-            getLifecycle().updateTestCase(uuid, testResult -> {
-                testResult.setStage(Stage.FINISHED);
-                testResult.setStatus(SKIPPED);
-            });
-            getLifecycle().stopTestCase(uuid);
-            getLifecycle().writeTestCase(uuid);
+            startTestCase(testIdentifier);
+            stopTestCase(testIdentifier, SKIPPED, new StatusDetails().setMessage(reason));
+            return;
+        }
+        final TestPlan testPlan = testPlanStorage.get();
+        if (Objects.nonNull(testPlan)) {
+            final Set<TestIdentifier> children = testPlan.getChildren(testIdentifier);
+            if (children.isEmpty()) {
+                // this is probably test template, so we report it as-is
+                startTestCase(testIdentifier);
+                stopTestCase(testIdentifier, SKIPPED, new StatusDetails().setMessage(reason));
+                return;
+            }
+
+            final Set<TestIdentifier> visited = new HashSet<>(Collections.singleton(testIdentifier));
+            children.forEach(child -> executionSkipped(testPlan, child, reason, visited));
+        }
+    }
+
+    private void executionSkipped(final TestPlan testPlan,
+                                  final TestIdentifier testIdentifier,
+                                  final String reason,
+                                  final Set<TestIdentifier> visited) {
+        if (testIdentifier.isTest()) {
+            startTestCase(testIdentifier);
+            stopTestCase(testIdentifier, SKIPPED, new StatusDetails().setMessage(reason));
+            return;
         }
+        final Set<TestIdentifier> children = testPlan.getChildren(testIdentifier);
+        children.stream()
+                .filter(visited::add)
+                .forEach(child -> executionSkipped(testPlan, child, reason, visited));
     }
 
     @Override
     public void executionFinished(final TestIdentifier testIdentifier, final TestExecutionResult testExecutionResult) {
         if (testIdentifier.isTest()) {
-            final String uuid = tests.get();
-            tests.remove();
-            getLifecycle().updateTestCase(uuid, result -> {
-                result.setStage(Stage.FINISHED);
-                switch (testExecutionResult.getStatus()) {
-                    case FAILED:
-                        testExecutionResult.getThrowable().ifPresent(throwable -> {
-                            result.setStatus(getStatus(throwable));
-                            result.setStatusDetails(ResultsUtils.getStatusDetails(throwable).orElse(null));
-                        });
-                        break;
-                    case SUCCESSFUL:
-                        result.setStatus(PASSED);
-                        break;
-                    default:
-                        result.setStatus(SKIPPED);
-                        testExecutionResult.getThrowable().ifPresent(throwable ->
-                                result.setStatusDetails(ResultsUtils.getStatusDetails(throwable).orElse(null))
-                        );
-                        break;
-                }
-            });
-            getLifecycle().stopTestCase(uuid);
-            getLifecycle().writeTestCase(uuid);
+            final Status status = extractStatus(testExecutionResult);
+            final StatusDetails statusDetails = testExecutionResult.getThrowable()
+                    .flatMap(ResultsUtils::getStatusDetails)
+                    .orElse(null);
+            stopTestCase(testIdentifier, status, statusDetails);
         }
     }
 
+    @Override
+    public void reportingEntryPublished(final TestIdentifier testIdentifier, final ReportEntry entry) {
+        final String uuid = getUuid(testIdentifier);
+        if (Objects.isNull(uuid)) {
+            // no known test running at the moment
+            return;
+        }
+
+        final Map<String, String> keyValuePairs = entry.getKeyValuePairs();
+        if (keyValuePairs.containsKey(STDOUT)) {
+            final String content = keyValuePairs.getOrDefault(STDOUT, "");
+            getLifecycle().addAttachment("Stdout", TEXT_PLAIN, TXT_EXTENSION, content.getBytes(UTF_8));
+        }
+        if (keyValuePairs.containsKey(STDERR)) {
+            final String content = keyValuePairs.getOrDefault(STDERR, "");
+            getLifecycle().addAttachment("Stderr", TEXT_PLAIN, TXT_EXTENSION, content.getBytes(UTF_8));
+        }
+
+    }
+
     protected Status getStatus(final Throwable throwable) {
         return ResultsUtils.getStatus(throwable).orElse(FAILED);
     }
 
-    protected void updateResultFromSource(final TestResult result, final MethodSource source) {
-        result.setFullName(String.format(
-                "%s.%s",
-                source.getClassName(),
-                source.getMethodName()
+    private void startTestCase(final TestIdentifier testIdentifier) {
+        final String uuid = createUuid(testIdentifier);
+
+        final Optional<MethodSource> methodSource = testIdentifier.getSource()
+                .filter(MethodSource.class::isInstance)
+                .map(MethodSource.class::cast);
+
+        final Optional<Method> testMethod = methodSource.flatMap(this::getTestMethod);
+        final Optional<Class<?>> testClass = methodSource.flatMap(this::getTestClass);
+
+        final TestResult result = new TestResult()
+                .setUuid(uuid)
+                .setName(testIdentifier.getDisplayName())
+                .setLabels(getTags(testIdentifier))
+                .setHistoryId(getHistoryId(testIdentifier))
+                .setStage(Stage.RUNNING);
+
+        testClass.map(this::getLabels).ifPresent(result.getLabels()::addAll);
+        testMethod.map(this::getLabels).ifPresent(result.getLabels()::addAll);
+
+        testClass.map(this::getLinks).ifPresent(result.getLinks()::addAll);
+        testMethod.map(this::getLinks).ifPresent(result.getLinks()::addAll);
+
+        result.getLabels().add(createHostLabel());
+        result.getLabels().add(createThreadLabel());
+
+        methodSource.ifPresent(source -> {
+            result.setFullName(String.format("%s.%s", source.getClassName(), source.getMethodName()));
+            result.getLabels().add(createPackageLabel(source.getClassName()));
+            result.getLabels().add(createTestClassLabel(source.getClassName()));
+            result.getLabels().add(createTestMethodLabel(source.getMethodName()));
+        });
+
+        testClass.ifPresent(aClass -> {
+            final String suiteName = getDisplayName(aClass).orElse(aClass.getCanonicalName());
+            result.getLabels().add(createSuiteLabel(suiteName));
+        });
+
+        final Optional<String> classDescription = testClass.flatMap(this::getDescription);
+        final Optional<String> methodDescription = testMethod.flatMap(this::getDescription);
+
+        final String description = Stream.of(classDescription, methodDescription)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .collect(Collectors.joining("\n\n"));
+
+        result.setDescription(description);
+
+        testMethod.map(this::getSeverity)
+                .filter(Optional::isPresent)
+                .orElse(testClass.flatMap(this::getSeverity))
+                .map(ResultsUtils::createSeverityLabel)
+                .ifPresent(result.getLabels()::add);
+
+        testMethod.map(this::getOwner)
+                .filter(Optional::isPresent)
+                .orElse(testClass.flatMap(this::getOwner))
+                .map(ResultsUtils::createOwnerLabel)
+                .ifPresent(result.getLabels()::add);
+
+        testMethod.ifPresent(method -> ResultsUtils.processDescription(
+                method.getDeclaringClass().getClassLoader(),
+                method,
+                result
         ));
-        result.setDescription(getDescription(source));
-        result.getLabels().add(new Label().setName(CLASS_NAME).setValue(source.getClassName()));
-        result.getLabels().add(new Label().setName(METHOD_NAME).setValue(source.getMethodName()));
-        result.getLabels().add(new Label().setName(SUITE).setValue(getSuite(source)));
-        result.getLabels().add(new Label().setName(PACKAGE).setValue(source.getClassName()));
+
+        getLifecycle().scheduleTestCase(result);
+        getLifecycle().startTestCase(uuid);
+    }
+
+    private void stopTestCase(final TestIdentifier testIdentifier,
+                              final Status status,
+                              final StatusDetails statusDetails) {
+
+        final String uuid = removeUuid(testIdentifier);
+        getLifecycle().updateTestCase(uuid, result -> {
+            result.setStage(Stage.FINISHED);
+            result.setStatus(status);
+            result.setStatusDetails(statusDetails);
+        });
+        getLifecycle().stopTestCase(uuid);
+        getLifecycle().writeTestCase(uuid);
+    }
+
+    private String createUuid(final TestIdentifier testIdentifier) {
+        final String uuid = UUID.randomUUID().toString();
+        try {
+            lock.writeLock().lock();
+            testUuids.put(testIdentifier, uuid);
+        } finally {
+            lock.writeLock().unlock();
+        }
+        return uuid;
+    }
+
+    private String getUuid(final TestIdentifier testIdentifier) {
+        try {
+            lock.readLock().lock();
+            return testUuids.get(testIdentifier);
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+    private String removeUuid(final TestIdentifier testIdentifier) {
+        try {
+            lock.writeLock().lock();
+            return testUuids.remove(testIdentifier);
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    private Status extractStatus(final TestExecutionResult testExecutionResult) {
+        switch (testExecutionResult.getStatus()) {
+            case FAILED:
+                return testExecutionResult.getThrowable().isPresent()
+                        ? getStatus(testExecutionResult.getThrowable().get())
+                        : FAILED;
+            case SUCCESSFUL:
+                return PASSED;
+            default:
+                return SKIPPED;
+        }
     }
 
     private List<Label> getTags(final TestIdentifier testIdentifier) {
         return testIdentifier.getTags().stream()
-                .map(tag -> new Label().setName(TAG).setValue(tag.getName()))
+                .map(TestTag::getName)
+                .map(ResultsUtils::createTagLabel)
                 .collect(Collectors.toList());
     }
 
@@ -178,42 +319,98 @@ protected String getHistoryId(final TestIdentifier testIdentifier) {
     }
 
     private String md5(final String source) {
-        final byte[] bytes = getMessageDigest().digest(source.getBytes(UTF_8));
+        final byte[] bytes = getMd5Digest().digest(source.getBytes(UTF_8));
         return new BigInteger(1, bytes).toString(16);
     }
 
-    private MessageDigest getMessageDigest() {
-        try {
-            return MessageDigest.getInstance("md5");
-        } catch (NoSuchAlgorithmException e) {
-            throw new IllegalStateException("Could not find md5 hashing algorithm", e);
+    private Optional<SeverityLevel> getSeverity(final AnnotatedElement annotatedElement) {
+        return getAnnotations(annotatedElement, Severity.class)
+                .map(Severity::value)
+                .findAny();
+    }
+
+    private Optional<String> getOwner(final AnnotatedElement annotatedElement) {
+        return getAnnotations(annotatedElement, Owner.class)
+                .map(Owner::value)
+                .findAny();
+    }
+
+    private Optional<String> getDisplayName(final AnnotatedElement annotatedElement) {
+        return getAnnotations(annotatedElement, DisplayName.class)
+                .map(DisplayName::value)
+                .findAny();
+    }
+
+    private Optional<String> getDescription(final AnnotatedElement annotatedElement) {
+        return getAnnotations(annotatedElement, Description.class)
+                .map(Description::value)
+                .findAny();
+    }
+
+    private List<Label> getLabels(final AnnotatedElement annotatedElement) {
+        return Stream.of(
+                getAnnotations(annotatedElement, Epic.class).map(ResultsUtils::createLabel),
+                getAnnotations(annotatedElement, Feature.class).map(ResultsUtils::createLabel),
+                getAnnotations(annotatedElement, Story.class).map(ResultsUtils::createLabel)
+        ).reduce(Stream::concat).orElseGet(Stream::empty).collect(Collectors.toList());
+    }
+
+    private List<Link> getLinks(final AnnotatedElement annotatedElement) {
+        return Stream.of(
+                getAnnotations(annotatedElement, io.qameta.allure.Link.class).map(ResultsUtils::createLink),
+                getAnnotations(annotatedElement, io.qameta.allure.Issue.class).map(ResultsUtils::createLink),
+                getAnnotations(annotatedElement, io.qameta.allure.TmsLink.class).map(ResultsUtils::createLink))
+                .reduce(Stream::concat).orElseGet(Stream::empty).collect(Collectors.toList());
+    }
+
+
+    private <T extends Annotation> Stream<T> getAnnotations(final AnnotatedElement annotatedElement,
+                                                            final Class<T> annotationClass) {
+        final T annotation = annotatedElement.getAnnotation(annotationClass);
+        return Stream.concat(
+                extractRepeatable(annotatedElement, annotationClass).stream(),
+                Objects.isNull(annotation) ? Stream.empty() : Stream.of(annotation)
+        );
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T extends Annotation> List<T> extractRepeatable(final AnnotatedElement annotatedElement,
+                                                             final Class<T> annotationClass) {
+        if (annotationClass.isAnnotationPresent(Repeatable.class)) {
+            final Repeatable repeatable = annotationClass.getAnnotation(Repeatable.class);
+            final Class<? extends Annotation> wrapper = repeatable.value();
+            final Annotation annotation = annotatedElement.getAnnotation(wrapper);
+            if (Objects.nonNull(annotation)) {
+                try {
+                    final Method value = annotation.getClass().getMethod("value");
+                    final Object annotations = value.invoke(annotation);
+                    return Arrays.asList((T[]) annotations);
+                } catch (Exception e) {
+                    throw new IllegalStateException(e);
+                }
+            }
         }
+        return Collections.emptyList();
     }
 
-    private String getSuite(final MethodSource source) {
+    private Optional<Class<?>> getTestClass(final MethodSource source) {
         try {
-            final DisplayName displayNameAnnotation =
-                    Class.forName(source.getClassName()).getAnnotation(DisplayName.class);
-            if (displayNameAnnotation != null && !displayNameAnnotation.value().isEmpty()) {
-                return displayNameAnnotation.value();
-            }
+            return Optional.of(Class.forName(source.getClassName()));
         } catch (ClassNotFoundException e) {
-            LOGGER.trace(e.getMessage(), e);
+            LOGGER.trace("Could not get test class from method source {}", source, e);
         }
-        return source.getClassName();
+        return Optional.empty();
     }
 
-    private String getDescription(final MethodSource source) {
+    private Optional<Method> getTestMethod(final MethodSource source) {
         try {
-            final Description descriptionAnnotation = Class.forName(source.getClassName())
-                    .getDeclaredMethod(source.getMethodName())
-                    .getAnnotation(Description.class);
-            if (descriptionAnnotation != null) {
-                return descriptionAnnotation.value();
-            }
-        } catch (ClassNotFoundException | NoSuchMethodException e) {
-            LOGGER.trace(e.getMessage(), e);
+            final Class<?> aClass = Class.forName(source.getClassName());
+            return Stream.of(aClass.getDeclaredMethods())
+                    .filter(method -> MethodSource.from(method).equals(source))
+                    .findAny();
+        } catch (ClassNotFoundException e) {
+            LOGGER.trace("Could not get test method from method source {}", source, e);
         }
-        return null;
+        return Optional.empty();
     }
 }
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 e3c08f9e1..f103743a7 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
@@ -1,33 +1,54 @@
 package io.qameta.allure.junitplatform;
 
+import io.github.glytching.junit.extension.system.SystemProperty;
+import io.github.glytching.junit.extension.system.SystemPropertyExtension;
 import io.qameta.allure.Allure;
 import io.qameta.allure.AllureLifecycle;
 import io.qameta.allure.Epic;
+import io.qameta.allure.Issue;
+import io.qameta.allure.Step;
 import io.qameta.allure.aspects.AttachmentsAspects;
 import io.qameta.allure.aspects.StepsAspects;
 import io.qameta.allure.junitplatform.features.BrokenTests;
+import io.qameta.allure.junitplatform.features.DescriptionJavadocTest;
+import io.qameta.allure.junitplatform.features.DisabledRepeatedTests;
 import io.qameta.allure.junitplatform.features.DisabledTests;
 import io.qameta.allure.junitplatform.features.DynamicTests;
 import io.qameta.allure.junitplatform.features.FailedTests;
 import io.qameta.allure.junitplatform.features.OneTest;
+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.PassedTests;
+import io.qameta.allure.junitplatform.features.RepeatedTests;
+import io.qameta.allure.junitplatform.features.SeverityTest;
 import io.qameta.allure.junitplatform.features.SkippedTests;
 import io.qameta.allure.junitplatform.features.TaggedTests;
-import io.qameta.allure.junitplatform.features.TestsClassWithDisplayNameAnnotation;
-import io.qameta.allure.junitplatform.features.TestsClassWithoutDisplayNameAnnotation;
-import io.qameta.allure.junitplatform.features.TestsWithDescriptions;
-import io.qameta.allure.junitplatform.features.TestsWithDisplayName;
-import io.qameta.allure.junitplatform.features.TestsWithSteps;
+import io.qameta.allure.junitplatform.features.TestClassDisabled;
+import io.qameta.allure.junitplatform.features.TestClassWithDisplayNameAnnotation;
+import io.qameta.allure.junitplatform.features.TestClassWithoutDisplayNameAnnotation;
+import io.qameta.allure.junitplatform.features.TestWithClassLabels;
+import io.qameta.allure.junitplatform.features.TestWithClassLinks;
+import io.qameta.allure.junitplatform.features.TestWithDescription;
+import io.qameta.allure.junitplatform.features.TestWithDisplayName;
+import io.qameta.allure.junitplatform.features.TestWithMethodLabels;
+import io.qameta.allure.junitplatform.features.TestWithMethodLinks;
+import io.qameta.allure.junitplatform.features.TestWithSteps;
+import io.qameta.allure.junitplatform.features.TestWithSystemErr;
+import io.qameta.allure.junitplatform.features.TestWithSystemOut;
+import io.qameta.allure.model.Attachment;
 import io.qameta.allure.model.Label;
+import io.qameta.allure.model.Link;
 import io.qameta.allure.model.Stage;
 import io.qameta.allure.model.Status;
 import io.qameta.allure.model.StepResult;
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.test.AllureResultsWriterStub;
-import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.parallel.ResourceLock;
 import org.junit.platform.engine.discovery.ClassSelector;
 import org.junit.platform.engine.discovery.DiscoverySelectors;
 import org.junit.platform.launcher.Launcher;
@@ -36,18 +57,37 @@
 import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
 import org.junit.platform.launcher.core.LauncherFactory;
 
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static io.qameta.allure.junitplatform.features.TaggedTests.CLASS_TAG;
 import static io.qameta.allure.junitplatform.features.TaggedTests.METHOD_TAG;
+import static io.qameta.allure.test.AllurePredicates.hasLabel;
+import static io.qameta.allure.test.AllurePredicates.hasStatus;
+import static io.qameta.allure.util.ResultsUtils.FEATURE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.HOST_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.OWNER_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.PACKAGE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.SEVERITY_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.SUITE_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TAG_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TEST_CLASS_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.TEST_METHOD_LABEL_NAME;
+import static io.qameta.allure.util.ResultsUtils.THREAD_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")
+@ExtendWith(SystemPropertyExtension.class)
 @Epic("Allure Junit Platform Integration")
 public class AllureJunitPlatformTest {
 
@@ -81,20 +121,7 @@ void shouldSetExecutionLabels() {
         assertThat(testResults)
                 .flatExtracting(TestResult::getLabels)
                 .extracting(Label::getName)
-                .contains("host", "thread");
-    }
-
-    @Test
-    void shouldSetSourceLabels() {
-        runClasses(OneTest.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .flatExtracting(TestResult::getLabels)
-                .extracting(Label::getName, Label::getValue)
-                .contains(
-                        tuple("methodName", "single"),
-                        tuple("className", "io.qameta.allure.junitplatform.features.OneTest")
-                );
+                .contains(HOST_LABEL_NAME, THREAD_LABEL_NAME);
     }
 
     @Test
@@ -104,7 +131,7 @@ void shouldProcessPassedTests() {
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
                 .hasSize(3)
-                .filteredOn(testResult -> Status.PASSED.equals(testResult.getStatus()))
+                .filteredOn(hasStatus(Status.PASSED))
                 .flatExtracting(TestResult::getName)
                 .containsExactlyInAnyOrder("first()", "second()", "third()");
     }
@@ -168,7 +195,7 @@ void shouldProcessSkippedTests() {
 
     @Test
     void shouldProcessDisplayName() {
-        runClasses(TestsWithDisplayName.class);
+        runClasses(TestWithDisplayName.class);
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -213,7 +240,7 @@ void shouldProcessDynamicTests() {
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
                 .hasSize(3)
-                .filteredOn(testResult -> Status.PASSED.equals(testResult.getStatus()))
+                .filteredOn(hasStatus(Status.PASSED))
                 .flatExtracting(TestResult::getName)
                 .containsExactlyInAnyOrder("testA", "testB", "testC");
     }
@@ -225,14 +252,14 @@ void shouldProcessParametrisedTests() {
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
                 .hasSize(2)
-                .filteredOn(testResult -> Status.PASSED.equals(testResult.getStatus()))
+                .filteredOn(hasStatus(Status.PASSED))
                 .flatExtracting(TestResult::getName)
                 .containsExactlyInAnyOrder("[1] Hello", "[2] World");
     }
 
     @Test
     void shouldAddSteps() {
-        runClasses(TestsWithSteps.class);
+        runClasses(TestWithSteps.class);
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
@@ -246,85 +273,380 @@ void shouldAddSteps() {
 
     }
 
-    @SuppressWarnings("unchecked")
     @Test
     void shouldAddTags() {
         runClasses(TaggedTests.class);
 
         final List<TestResult> testResults = results.getTestResults();
 
-        SoftAssertions softly = new SoftAssertions();
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple(TAG_LABEL_NAME, CLASS_TAG),
+                        tuple(TAG_LABEL_NAME, METHOD_TAG)
+                );
+    }
 
-        softly.assertThat(testResults)
-                .hasSize(1);
+    @Test
+    void shouldProcessDefaultTestClassDisplayName() {
+        runClasses(TestClassWithoutDisplayNameAnnotation.class);
 
-        softly.assertThat(testResults)
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
                 .flatExtracting(TestResult::getLabels)
-                .filteredOn(label -> "tag".equals(label.getName()))
-                .flatExtracting(Label::getValue)
-                .containsExactlyInAnyOrder(CLASS_TAG, METHOD_TAG);
+                .filteredOn("name", SUITE_LABEL_NAME)
+                .extracting(Label::getValue)
+                .contains("io.qameta.allure.junitplatform.features.TestClassWithoutDisplayNameAnnotation");
+    }
 
-        softly.assertAll();
+    @Test
+    void shouldProcessJunit5Description() {
+        runClasses(TestWithDescription.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .flatExtracting(TestResult::getDescription)
+                .contains("Test description");
     }
 
     @Test
-    void shouldProcessTestClassDisplayNameByAnnotation() {
-        runClasses(TestsClassWithDisplayNameAnnotation.class);
+    void shouldProcessDisabledTests() {
+        runClasses(DisabledTests.class);
 
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
-                .hasSize(1);
+                .extracting(TestResult::getStatus)
+                .containsExactly(Status.SKIPPED);
+    }
 
-        final List<Label> testResultLabels = testResults.get(0).getLabels();
-        assertThat(testResultLabels)
-                .filteredOn(label -> "suite".equals(label.getName()))
+    @Test
+    void shouldProcessMethodLabels() {
+        runClasses(TestWithMethodLabels.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
                 .hasSize(1)
-                .flatExtracting(Label::getValue)
-                .contains("Display name of test class");
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getValue)
+                .contains(
+                        "epic1", "epic2", "epic3",
+                        "feature1", "feature2", "feature3",
+                        "story1", "story2", "story3",
+                        "some-owner"
+                );
     }
 
+
     @Test
-    void shouldProcessDefaultTestClassDisplayName() {
-        runClasses(TestsClassWithoutDisplayNameAnnotation.class);
+    void shouldProcessClassLabels() {
+        runClasses(TestWithClassLabels.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(1)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getValue)
+                .contains(
+                        "epic1", "epic2", "epic3",
+                        "feature1", "feature2", "feature3",
+                        "story1", "story2", "story3",
+                        "some-owner"
+                );
+    }
 
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
+    @Test
+    void shouldProcessMethodLinks() {
+        runClasses(TestWithMethodLinks.class);
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
-                .hasSize(1);
+                .hasSize(1)
+                .flatExtracting(TestResult::getLinks)
+                .extracting(Link::getName, Link::getType, Link::getUrl)
+                .contains(
+                        tuple("LINK-1", "custom", "https://example.org/custom/LINK-1"),
+                        tuple("LINK-2", "custom", "https://example.org/link/2"),
+                        tuple("", "custom", "https://example.org/some-custom-link"),
+                        tuple("ISSUE-1", "issue", "https://example.org/issue/ISSUE-1"),
+                        tuple("ISSUE-2", "issue", "https://example.org/issue/ISSUE-2"),
+                        tuple("ISSUE-3", "issue", "https://example.org/issue/ISSUE-3"),
+                        tuple("TMS-1", "tms", "https://example.org/tms/TMS-1"),
+                        tuple("TMS-2", "tms", "https://example.org/tms/TMS-2"),
+                        tuple("TMS-3", "tms", "https://example.org/tms/TMS-3")
+                );
+    }
 
-        final List<Label> testResultLabels = testResults.get(0).getLabels();
-        assertThat(testResultLabels)
-                .filteredOn(label -> "suite".equals(label.getName()))
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SystemProperty(name = "allure.link.issue.pattern", value = "https://example.org/issue/{}")
+    @SystemProperty(name = "allure.link.tms.pattern", value = "https://example.org/tms/{}")
+    @SystemProperty(name = "allure.link.custom.pattern", value = "https://example.org/custom/{}")
+    @Test
+    void shouldProcessClassLinks() {
+        runClasses(TestWithClassLinks.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
                 .hasSize(1)
-                .flatExtracting(Label::getValue)
-                .contains("io.qameta.allure.junitplatform.features.TestsClassWithoutDisplayNameAnnotation");
+                .flatExtracting(TestResult::getLinks)
+                .extracting(Link::getName, Link::getType, Link::getUrl)
+                .contains(
+                        tuple("LINK-1", "custom", "https://example.org/custom/LINK-1"),
+                        tuple("LINK-2", "custom", "https://example.org/link/2"),
+                        tuple("", "custom", "https://example.org/some-custom-link"),
+                        tuple("ISSUE-1", "issue", "https://example.org/issue/ISSUE-1"),
+                        tuple("ISSUE-2", "issue", "https://example.org/issue/ISSUE-2"),
+                        tuple("ISSUE-3", "issue", "https://example.org/issue/ISSUE-3"),
+                        tuple("TMS-1", "tms", "https://example.org/tms/TMS-1"),
+                        tuple("TMS-2", "tms", "https://example.org/tms/TMS-2"),
+                        tuple("TMS-3", "tms", "https://example.org/tms/TMS-3")
+                );
     }
 
+    @Issue("189")
     @Test
-    void shouldProcessJunit5Description() {
-        runClasses(TestsWithDescriptions.class);
+    void shouldProcessDynamicTestLabels() {
+        runClasses(DynamicTests.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(3)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getValue)
+                .contains(
+                        "epic1", "epic2", "epic3",
+                        "feature1", "feature2", "feature3",
+                        "story1", "story2", "story3",
+                        "some-owner"
+                );
+    }
+
+    @Test
+    void shouldCommonLabels() {
+        runClasses(OneTest.class);
 
         final List<TestResult> testResults = results.getTestResults();
+
         assertThat(testResults)
-                .hasSize(1)
-                .flatExtracting(TestResult::getDescription)
-                .contains("Test description");
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple(PACKAGE_LABEL_NAME, "io.qameta.allure.junitplatform.features.OneTest"),
+                        tuple(SUITE_LABEL_NAME, "io.qameta.allure.junitplatform.features.OneTest"),
+                        tuple(TEST_CLASS_LABEL_NAME, "io.qameta.allure.junitplatform.features.OneTest"),
+                        tuple(TEST_METHOD_LABEL_NAME, "single")
+                );
     }
 
+    @Issue("180")
     @Test
-    void shouldProcessDisabledTests() {
-        runClasses(DisabledTests.class);
+    void shouldSetSuiteNameFromDisplayNameAnnotation() {
+        runClasses(TestClassWithDisplayNameAnnotation.class);
 
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .flatExtracting(TestResult::getLabels)
+                .extracting(Label::getName, Label::getValue)
+                .contains(
+                        tuple(SUITE_LABEL_NAME, "Display name of test class")
+                );
+    }
+
+    @Test
+    void shouldSetSeverity() {
+        runClasses(SeverityTest.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .filteredOn("name", "criticalSeverityTest()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", SEVERITY_LABEL_NAME)
+                .extracting(Label::getValue)
+                .containsExactly("critical");
+
+        assertThat(testResults)
+                .filteredOn("name", "defaultSeverityTest()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", SEVERITY_LABEL_NAME)
+                .extracting(Label::getValue)
+                .contains("trivial");
+    }
+
+    @Test
+    void shouldSetOwner() {
+        runClasses(OwnerTest.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .filteredOn("name", "secondOwnerTest()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", OWNER_LABEL_NAME)
+                .extracting(Label::getValue)
+                .containsExactly("second");
+
+        assertThat(testResults)
+                .filteredOn("name", "defaultOwnerTest()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", OWNER_LABEL_NAME)
+                .extracting(Label::getValue)
+                .contains("first");
+    }
+
+    @Disabled("Fails when run using IDEA")
+    @Test
+    void shouldSetJavadocDescription() {
+        runClasses(DescriptionJavadocTest.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getDescriptionHtml)
+                .contains(" Test javadoc description.\n");
+    }
+
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    @SystemProperty(name = "junit.platform.output.capture.stdout", value = "true")
+    @Test
+    void shouldCaptureSystemOut() {
+        runClasses(TestWithSystemOut.class);
+
+        final List<Attachment> attachments = results.getTestResults().stream()
+                .map(TestResult::getAttachments)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .contains(
+                        tuple("Stdout", "text/plain")
+                );
+
+        final Attachment found = attachments.stream()
+                .filter(attachment -> "Stdout".equals(attachment.getName()))
+                .findAny()
+                .get();
+
+
+        final Map<String, byte[]> attachmentFiles = results.getAttachments();
+        assertThat(attachmentFiles)
+                .containsKeys(found.getSource());
+
+        final byte[] bytes = attachmentFiles.get(found.getSource());
+        final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
+
+        assertThat(attachmentContent)
+                .isEqualTo("SYS OUT CONTENT\n");
+
+    }
+
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SuppressWarnings("OptionalGetWithoutIsPresent")
+    @SystemProperty(name = "junit.platform.output.capture.stderr", value = "true")
+    @Test
+    void shouldCaptureSystemErr() {
+        runClasses(TestWithSystemErr.class);
+
+        final List<Attachment> attachments = results.getTestResults().stream()
+                .map(TestResult::getAttachments)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+
+        assertThat(attachments)
+                .extracting(Attachment::getName, Attachment::getType)
+                .contains(
+                        tuple("Stderr", "text/plain")
+                );
+
+        final Attachment found = attachments.stream()
+                .filter(attachment -> "Stderr".equals(attachment.getName()))
+                .findAny()
+                .get();
+
+
+        final Map<String, byte[]> attachmentFiles = results.getAttachments();
+        assertThat(attachmentFiles)
+                .containsKeys(found.getSource());
+
+        final byte[] bytes = attachmentFiles.get(found.getSource());
+        final String attachmentContent = new String(bytes, StandardCharsets.UTF_8);
+
+        assertThat(attachmentContent)
+                .isEqualTo("SYS ERR CONTENT\n");
+
+    }
+
+    @ResourceLock(value = SYSTEM_PROPERTIES, mode = READ_WRITE)
+    @SystemProperty(name = "junit.jupiter.execution.parallel.enabled", value = "true")
+    @Test
+    void shouldRunTestsInParallel() {
+        runClasses(ParallelTests.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+
+        assertThat(testResults)
+                .extracting(TestResult::getName)
+                .containsExactlyInAnyOrder(
+                        "first()",
+                        "second()"
+                );
+    }
+
+    @Test
+    void shouldSupportDisabledTestClasses() {
+        runClasses(TestClassDisabled.class);
+
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .extracting(TestResult::getName)
+                .containsExactlyInAnyOrder(
+                        "First",
+                        "second()",
+                        "third()"
+                );
+
+        assertThat(testResults)
+                .filteredOn("name", "second()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", FEATURE_LABEL_NAME)
+                .extracting(Label::getValue)
+                .containsExactlyInAnyOrder("A");
+
+        assertThat(testResults)
+                .filteredOn("name", "third()")
+                .flatExtracting(TestResult::getLabels)
+                .filteredOn("name", OWNER_LABEL_NAME)
+                .extracting(Label::getValue)
+                .containsExactlyInAnyOrder("me");
+    }
+
+    @Test
+    void shouldSupportRepeatedTests() {
+        runClasses(RepeatedTests.class);
+        final List<TestResult> testResults = results.getTestResults();
+        assertThat(testResults)
+                .hasSize(5)
+                .allMatch(hasStatus(Status.PASSED))
+                .allMatch(hasLabel(OWNER_LABEL_NAME, "me"));
+
+    }
+
+    @Test
+    void shouldSupportDisabledRepeatedTests() {
+        runClasses(DisabledRepeatedTests.class);
         final List<TestResult> testResults = results.getTestResults();
         assertThat(testResults)
                 .hasSize(1)
-                .first()
-                .hasFieldOrPropertyWithValue("status", Status.SKIPPED);
+                .allMatch(hasStatus(Status.SKIPPED))
+                .allMatch(hasLabel(OWNER_LABEL_NAME, "other guy"));
+
     }
 
+    @Step("Run classes {classes}")
     private void runClasses(Class<?>... classes) {
         final ClassSelector[] classSelectors = Stream.of(classes)
                 .map(DiscoverySelectors::selectClass)
                 .toArray(ClassSelector[]::new);
+
         final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
                 .selectors(classSelectors)
                 .build();
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java
new file mode 100644
index 000000000..b2f56fa17
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DescriptionJavadocTest.java
@@ -0,0 +1,18 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Description;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class DescriptionJavadocTest {
+
+    /**
+     * Test javadoc description.
+     */
+    @Description(useJavaDoc = true)
+    @Test
+    void testWithJavadocDescription() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java
new file mode 100644
index 000000000..ce19bbc21
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisabledRepeatedTests.java
@@ -0,0 +1,17 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Owner;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.RepeatedTest;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class DisabledRepeatedTests {
+
+    @Owner("other guy")
+    @Disabled
+    @RepeatedTest(5)
+    void first() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java
new file mode 100644
index 000000000..0d1fbcd22
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DisplayNameOnClassTests.java
@@ -0,0 +1,16 @@
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@DisplayName("Custom suite name")
+public class DisplayNameOnClassTests {
+
+    @Test
+    void single() {
+    }
+
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
index ef4ccad7d..a3c327e1c 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/DynamicTests.java
@@ -1,5 +1,10 @@
 package io.qameta.allure.junitplatform.features;
 
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Owner;
+import io.qameta.allure.Stories;
+import io.qameta.allure.Story;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.TestFactory;
 
@@ -10,8 +15,23 @@
 /**
  * @author charlie (Dmitry Baev).
  */
+@Epic("epic4")
+@Feature("feature4")
+@Story("story4")
 public class DynamicTests {
 
+    @Epic("epic1")
+    @Epic("epic2")
+    @Epic("epic3")
+    @Feature("feature1")
+    @Feature("feature2")
+    @Feature("feature3")
+    @Story("story1")
+    @Stories({
+            @Story("story2"),
+            @Story("story3")
+    })
+    @Owner("some-owner")
     @TestFactory
     Stream<DynamicTest> dynamicTestsFromStream() {
         return Stream.of("A", "B", "C").map(
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java
new file mode 100644
index 000000000..b7b19506f
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/OwnerTest.java
@@ -0,0 +1,20 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Owner;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@Owner("first")
+public class OwnerTest {
+
+    @Owner("second")
+    @Test
+    void secondOwnerTest() {
+    }
+
+    @Test
+    void defaultOwnerTest() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java
new file mode 100644
index 000000000..d91075d25
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/ParallelTests.java
@@ -0,0 +1,24 @@
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.Execution;
+import org.junit.jupiter.api.parallel.ExecutionMode;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@Execution(ExecutionMode.CONCURRENT)
+public class ParallelTests {
+
+    @Test
+    void first() throws InterruptedException {
+        TimeUnit.SECONDS.sleep(1);
+    }
+
+    @Test
+    void second() throws InterruptedException {
+        TimeUnit.SECONDS.sleep(1);
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java
new file mode 100644
index 000000000..0a5f8f3de
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/RepeatedTests.java
@@ -0,0 +1,15 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Owner;
+import org.junit.jupiter.api.RepeatedTest;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class RepeatedTests {
+
+    @Owner("me")
+    @RepeatedTest(5)
+    void first() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java
new file mode 100644
index 000000000..fc73f7141
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/SeverityTest.java
@@ -0,0 +1,21 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@Severity(SeverityLevel.TRIVIAL)
+public class SeverityTest {
+
+    @Severity(SeverityLevel.CRITICAL)
+    @Test
+    void criticalSeverityTest() {
+    }
+
+    @Test
+    void defaultSeverityTest() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java
new file mode 100644
index 000000000..b77a7c067
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassDisabled.java
@@ -0,0 +1,29 @@
+package io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.Feature;
+import io.qameta.allure.Owner;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@Disabled
+public class TestClassDisabled {
+
+    @DisplayName("First")
+    @Test
+    void first() {
+    }
+
+    @Feature("A")
+    @Test
+    void second() {
+    }
+
+    @Owner("me")
+    @Test
+    void third() {
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithDisplayNameAnnotation.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
similarity index 83%
rename from allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithDisplayNameAnnotation.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
index f5bcefd94..573b05bfc 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithDisplayNameAnnotation.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithDisplayNameAnnotation.java
@@ -7,7 +7,7 @@
  * @author a.afrikanov (Andrey Afrikanov).
  */
 @DisplayName("Display name of test class")
-public class TestsClassWithDisplayNameAnnotation {
+public class TestClassWithDisplayNameAnnotation {
 
     @Test
     void test() {
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithoutDisplayNameAnnotation.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
similarity index 76%
rename from allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithoutDisplayNameAnnotation.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
index e1baadfbe..ae2132acd 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsClassWithoutDisplayNameAnnotation.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestClassWithoutDisplayNameAnnotation.java
@@ -5,7 +5,7 @@
 /**
  * @author a.afrikanov (Andrey Afrikanov).
  */
-public class TestsClassWithoutDisplayNameAnnotation {
+public class TestClassWithoutDisplayNameAnnotation {
 
     @Test
     void test() {
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLabels.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
similarity index 85%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLabels.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
index b827e38df..40394f211 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLabels.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLabels.java
@@ -1,4 +1,4 @@
-package io.qameta.allure.junit5.samples;
+package io.qameta.allure.junitplatform.features;
 
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
@@ -25,7 +25,7 @@
 public class TestWithClassLabels {
 
     @Test
-    public void someTest() throws Exception {
+    void someTest() {
     }
 
 }
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLinks.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
similarity index 70%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLinks.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
index 8206d4a31..a5ff4102e 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithClassLinks.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithClassLinks.java
@@ -1,4 +1,4 @@
-package io.qameta.allure.junit5.samples;
+package io.qameta.allure.junitplatform.features;
 
 import io.qameta.allure.Issue;
 import io.qameta.allure.Issues;
@@ -10,8 +10,8 @@
 
 @Link(name = "LINK-1")
 @Links({
-        @Link(name = "LINK-2"),
-        @Link(name = "LINK-3")
+        @Link(name = "LINK-2", url = "https://example.org/link/2"),
+        @Link(url = "https://example.org/some-custom-link")
 })
 @TmsLink("TMS-1")
 @TmsLinks({
@@ -26,7 +26,7 @@
 public class TestWithClassLinks {
 
     @Test
-    public void someTest() throws Exception {
+    void someTest() {
     }
 
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDescriptions.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
similarity index 87%
rename from allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDescriptions.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
index 7ffedf81b..720b015c4 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDescriptions.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDescription.java
@@ -6,7 +6,7 @@
 /**
  * @author a.afrikanov (Andrey Afrikanov).
  */
-public class TestsWithDescriptions {
+public class TestWithDescription {
 
     @Test
     @Description("Test description")
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDisplayName.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
similarity index 88%
rename from allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDisplayName.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
index 1586d27f8..13d2befcc 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithDisplayName.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithDisplayName.java
@@ -6,7 +6,7 @@
 /**
  * @author charlie (Dmitry Baev).
  */
-public class TestsWithDisplayName {
+public class TestWithDisplayName {
 
     @Test
     @DisplayName("Some test with changed name")
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLabels.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
similarity index 86%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLabels.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
index 0969180ac..3395f45f9 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLabels.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLabels.java
@@ -1,4 +1,4 @@
-package io.qameta.allure.junit5.samples;
+package io.qameta.allure.junitplatform.features;
 
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
@@ -25,6 +25,6 @@ public class TestWithMethodLabels {
             @Story("story3")
     })
     @Owner("some-owner")
-    public void someTest() throws Exception {
+    void someTest() {
     }
 }
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLinks.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
similarity index 72%
rename from allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLinks.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
index 3003ce6ab..ef2288486 100644
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/TestWithMethodLinks.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithMethodLinks.java
@@ -1,4 +1,4 @@
-package io.qameta.allure.junit5.samples;
+package io.qameta.allure.junitplatform.features;
 
 import io.qameta.allure.Issue;
 import io.qameta.allure.Issues;
@@ -13,8 +13,8 @@ public class TestWithMethodLinks {
     @Test
     @Link(name = "LINK-1")
     @Links({
-            @Link(name = "LINK-2"),
-            @Link(name = "LINK-3")
+            @Link(name = "LINK-2", url = "https://example.org/link/2"),
+            @Link(url = "https://example.org/some-custom-link")
     })
     @TmsLink("TMS-1")
     @TmsLinks({
@@ -26,7 +26,7 @@ public class TestWithMethodLinks {
             @Issue("ISSUE-2"),
             @Issue("ISSUE-3")
     })
-    public void someTest() throws Exception {
+    void someTest() {
     }
 
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithSteps.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
similarity index 96%
rename from allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithSteps.java
rename to allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
index 0bdb03c84..a680daea6 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithSteps.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSteps.java
@@ -10,7 +10,7 @@
 /**
  * @author charlie (Dmitry Baev).
  */
-public class TestsWithSteps {
+public class TestWithSteps {
 
     @Test
     void testWithSteps() {
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java
new file mode 100644
index 000000000..0360854cf
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemErr.java
@@ -0,0 +1,14 @@
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class TestWithSystemErr {
+
+    @Test
+    void testWithSystemOut() {
+        System.err.println("SYS ERR CONTENT");
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java
new file mode 100644
index 000000000..9fec7546d
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestWithSystemOut.java
@@ -0,0 +1,14 @@
+package io.qameta.allure.junitplatform.features;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class TestWithSystemOut {
+
+    @Test
+    void testWithSystemOut() {
+        System.out.println("SYS OUT CONTENT");
+    }
+}
diff --git a/allure-junit5/build.gradle.kts b/allure-junit5/build.gradle.kts
index 70e7c74c2..15a31a0de 100644
--- a/allure-junit5/build.gradle.kts
+++ b/allure-junit5/build.gradle.kts
@@ -4,15 +4,7 @@ val agent by configurations.creating
 
 dependencies {
     agent("org.aspectj:aspectjweaver")
-    compile("org.junit.jupiter:junit-jupiter-engine")
-    compile(project(":allure-java-commons"))
     compile(project(":allure-junit-platform"))
-    testCompile("org.assertj:assertj-core")
-    testCompile("org.junit.jupiter:junit-jupiter-api")
-    testCompile("org.junit.jupiter:junit-jupiter-params")
-    testCompile("org.slf4j:slf4j-simple")
-    testCompile(project(":allure-java-commons-test"))
-    testRuntime("org.junit.jupiter:junit-jupiter-engine")
 }
 
 tasks.named<Jar>("jar") {
diff --git a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5AnnotationProcessor.java b/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5AnnotationProcessor.java
index 78f6181d0..1be082fa0 100644
--- a/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5AnnotationProcessor.java
+++ b/allure-junit5/src/main/java/io/qameta/allure/junit5/AllureJunit5AnnotationProcessor.java
@@ -1,115 +1,18 @@
 package io.qameta.allure.junit5;
 
-import io.qameta.allure.Allure;
-import io.qameta.allure.AllureLifecycle;
-import io.qameta.allure.Epic;
-import io.qameta.allure.Feature;
-import io.qameta.allure.Owner;
-import io.qameta.allure.Severity;
-import io.qameta.allure.Story;
-import io.qameta.allure.model.Label;
-import io.qameta.allure.model.Link;
-import io.qameta.allure.util.ResultsUtils;
 import org.junit.jupiter.api.extension.BeforeTestExecutionCallback;
 import org.junit.jupiter.api.extension.ExtensionContext;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Repeatable;
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
 /**
  * Allure Junit5 annotation processor.
+ *
+ * @deprecated use Allure JUnit platform integration instead
  */
+@Deprecated
 public class AllureJunit5AnnotationProcessor implements BeforeTestExecutionCallback {
 
-    private static AllureLifecycle lifecycle;
-
     @Override
-    public void beforeTestExecution(final ExtensionContext context) throws Exception {
-        getLifecycle().getCurrentTestCase().ifPresent(uuid -> {
-            getLifecycle().updateTestCase(uuid, testResult -> {
-                context.getTestClass().ifPresent(testClass -> {
-                    testResult.getLabels().addAll(getLabels(testClass));
-                    testResult.getLinks().addAll(getLinks(testClass));
-                });
-                context.getTestMethod().ifPresent(testMethod -> {
-                    testResult.getLabels().addAll(getLabels(testMethod));
-                    testResult.getLinks().addAll(getLinks(testMethod));
-                });
-            });
-        });
-    }
-
-    private List<Label> getLabels(final AnnotatedElement annotatedElement) {
-        return Stream.of(
-                getAnnotations(annotatedElement, Epic.class).map(ResultsUtils::createLabel),
-                getAnnotations(annotatedElement, Feature.class).map(ResultsUtils::createLabel),
-                getAnnotations(annotatedElement, Story.class).map(ResultsUtils::createLabel),
-                getAnnotations(annotatedElement, Severity.class).map(ResultsUtils::createLabel),
-                getAnnotations(annotatedElement, Owner.class).map(ResultsUtils::createLabel)
-        ).reduce(Stream::concat).orElseGet(Stream::empty).collect(Collectors.toList());
-    }
-
-    private List<Link> getLinks(final AnnotatedElement annotatedElement) {
-        return Stream.of(
-                getAnnotations(annotatedElement, io.qameta.allure.Link.class).map(ResultsUtils::createLink),
-                getAnnotations(annotatedElement, io.qameta.allure.Issue.class).map(ResultsUtils::createLink),
-                getAnnotations(annotatedElement, io.qameta.allure.TmsLink.class).map(ResultsUtils::createLink))
-                .reduce(Stream::concat).orElseGet(Stream::empty).collect(Collectors.toList());
-    }
-
-
-    private <T extends Annotation> Stream<T> getAnnotations(final AnnotatedElement annotatedElement,
-                                                            final Class<T> annotationClass) {
-        final T annotation = annotatedElement.getAnnotation(annotationClass);
-        return Stream.concat(
-                extractRepeatable(annotatedElement, annotationClass).stream(),
-                Objects.isNull(annotation) ? Stream.empty() : Stream.of(annotation)
-        );
+    public void beforeTestExecution(final ExtensionContext context) {
+        //do nothing
     }
-
-    @SuppressWarnings("unchecked")
-    private <T extends Annotation> List<T> extractRepeatable(final AnnotatedElement annotatedElement,
-                                                             final Class<T> annotationClass) {
-        if (annotationClass.isAnnotationPresent(Repeatable.class)) {
-            final Repeatable repeatable = annotationClass.getAnnotation(Repeatable.class);
-            final Class<? extends Annotation> wrapper = repeatable.value();
-            final Annotation annotation = annotatedElement.getAnnotation(wrapper);
-            if (Objects.nonNull(annotation)) {
-                try {
-                    final Method value = annotation.getClass().getMethod("value");
-                    final Object annotations = value.invoke(annotation);
-                    return Arrays.asList((T[]) annotations);
-                } catch (Exception e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-        }
-        return Collections.emptyList();
-    }
-
-
-    /**
-     * For tests only.
-     *
-     * @param allure allure lifecycle to set.
-     */
-    public static void setLifecycle(final AllureLifecycle allure) {
-        lifecycle = allure;
-    }
-
-    public static AllureLifecycle getLifecycle() {
-        if (Objects.isNull(lifecycle)) {
-            lifecycle = Allure.getLifecycle();
-        }
-        return lifecycle;
-    }
-
 }
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/AnnotationsTest.java b/allure-junit5/src/test/java/io/qameta/allure/junit5/AnnotationsTest.java
deleted file mode 100644
index f65bb2230..000000000
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/AnnotationsTest.java
+++ /dev/null
@@ -1,138 +0,0 @@
-package io.qameta.allure.junit5;
-
-import io.qameta.allure.AllureLifecycle;
-import io.qameta.allure.junit5.samples.DynamicTests;
-import io.qameta.allure.junit5.samples.TestWithClassLabels;
-import io.qameta.allure.junit5.samples.TestWithClassLinks;
-import io.qameta.allure.junit5.samples.TestWithMethodLabels;
-import io.qameta.allure.junit5.samples.TestWithMethodLinks;
-import io.qameta.allure.junitplatform.AllureJunitPlatform;
-import io.qameta.allure.model.Label;
-import io.qameta.allure.model.Link;
-import io.qameta.allure.model.TestResult;
-import io.qameta.allure.test.AllureResultsWriterStub;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.platform.engine.discovery.ClassSelector;
-import org.junit.platform.engine.discovery.DiscoverySelectors;
-import org.junit.platform.launcher.Launcher;
-import org.junit.platform.launcher.LauncherDiscoveryRequest;
-import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
-import org.junit.platform.launcher.core.LauncherFactory;
-
-import java.util.List;
-import java.util.stream.Stream;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class AnnotationsTest {
-
-    private AllureResultsWriterStub results = new AllureResultsWriterStub();
-
-    private AllureLifecycle lifecycle = new AllureLifecycle(results);
-
-    @BeforeEach
-    void setProperties() {
-        System.setProperty("junit.jupiter.extensions.autodetection.enabled", "true");
-    }
-
-    @Test
-    void shouldProcessMethodLabels() {
-        runClasses(TestWithMethodLabels.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .hasSize(1)
-                .flatExtracting(TestResult::getLabels)
-                .extracting(Label::getValue)
-                .contains(
-                        "epic1", "epic2", "epic3",
-                        "feature1", "feature2", "feature3",
-                        "story1", "story2", "story3",
-                        "some-owner"
-                );
-    }
-
-
-    @Test
-    void shouldProcessClassLabels() {
-        runClasses(TestWithClassLabels.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .hasSize(1)
-                .flatExtracting(TestResult::getLabels)
-                .extracting(Label::getValue)
-                .contains(
-                        "epic1", "epic2", "epic3",
-                        "feature1", "feature2", "feature3",
-                        "story1", "story2", "story3",
-                        "some-owner"
-                );
-    }
-
-    @Test
-    void shouldProcessMethodLinks() {
-        runClasses(TestWithMethodLinks.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .hasSize(1)
-                .flatExtracting(TestResult::getLinks)
-                .extracting(Link::getName)
-                .contains(
-                        "LINK-1", "LINK-2", "LINK-3",
-                        "ISSUE-1", "ISSUE-2", "ISSUE-3",
-                        "TMS-1", "TMS-2", "TMS-3"
-                );
-    }
-
-    @Test
-    void shouldProcessClassLinks() {
-        runClasses(TestWithClassLinks.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .hasSize(1)
-                .flatExtracting(TestResult::getLinks)
-                .extracting(Link::getName)
-                .contains(
-                        "LINK-1", "LINK-2", "LINK-3",
-                        "ISSUE-1", "ISSUE-2", "ISSUE-3",
-                        "TMS-1", "TMS-2", "TMS-3"
-                );
-    }
-
-    @Test
-    @Disabled("not implemented")
-    void shouldProcessDynamicTestLabels() {
-        runClasses(DynamicTests.class);
-        final List<TestResult> testResults = results.getTestResults();
-        assertThat(testResults)
-                .hasSize(3)
-                .flatExtracting(TestResult::getLabels)
-                .extracting(Label::getValue)
-                .contains(
-                        "epic1", "epic2", "epic3",
-                        "feature1", "feature2", "feature3",
-                        "story1", "story2", "story3",
-                        "some-owner"
-                );
-    }
-
-    @BeforeEach
-    void clearProperties() {
-        System.setProperty("junit.jupiter.extensions.autodetection.enabled", "false");
-    }
-
-    private void runClasses(Class<?>... classes) {
-        final ClassSelector[] classSelectors = Stream.of(classes)
-                .map(DiscoverySelectors::selectClass)
-                .toArray(ClassSelector[]::new);
-        final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
-                .selectors(classSelectors)
-                .build();
-
-        AllureJunit5AnnotationProcessor.setLifecycle(lifecycle);
-        final Launcher launcher = LauncherFactory.create();
-        launcher.execute(request, new AllureJunitPlatform(lifecycle));
-    }
-
-}
diff --git a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/DynamicTests.java b/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/DynamicTests.java
deleted file mode 100644
index 0c1b44ff1..000000000
--- a/allure-junit5/src/test/java/io/qameta/allure/junit5/samples/DynamicTests.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package io.qameta.allure.junit5.samples;
-
-import io.qameta.allure.Epic;
-import io.qameta.allure.Feature;
-import io.qameta.allure.Owner;
-import io.qameta.allure.Stories;
-import io.qameta.allure.Story;
-import org.junit.jupiter.api.DynamicTest;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestFactory;
-
-import java.util.stream.Stream;
-
-import static org.junit.jupiter.api.DynamicTest.dynamicTest;
-
-/**
- * @author charlie (Dmitry Baev).
- */
-public class DynamicTests {
-
-    @TestFactory
-    @Test
-    @Epic("epic1")
-    @Epic("epic2")
-    @Epic("epic3")
-    @Feature("feature1")
-    @Feature("feature2")
-    @Feature("feature3")
-    @Story("story1")
-    @Stories({
-            @Story("story2"),
-            @Story("story3")
-    })
-    @Owner("some-owner")
-    Stream<DynamicTest> dynamicTestsFromStream() {
-        return Stream.of("A", "B", "C").map(str -> dynamicTest("test" + str, () -> {
-        }));
-    }
-
-}
diff --git a/gradle/quality-configs/checkstyle/checkstyle.xml b/gradle/quality-configs/checkstyle/checkstyle.xml
index 6f2adf161..507c4e845 100644
--- a/gradle/quality-configs/checkstyle/checkstyle.xml
+++ b/gradle/quality-configs/checkstyle/checkstyle.xml
@@ -62,7 +62,7 @@
         <module name="ArrayTrailingComma"/>
         <!--<module name="AvoidInlineConditionals"/>-->
         <module name="CovariantEquals"/>
-        <module name="DeclarationOrder"/>
+        <!--<module name="DeclarationOrder"/>-->
         <module name="DefaultComesLast"/>
         <module name="EmptyStatement"/>
         <module name="EqualsAvoidNull"/>
@@ -101,8 +101,8 @@
         <module name="ParameterAssignment"/>  <!-- more strict version is FinalParameters -->
         <!--<module name="RequireThis"/>-->
         <module name="ReturnCount">
-            <property name="max" value="2"/>
-            <property name="maxForVoid" value="1"/>
+            <property name="max" value="5"/>
+            <property name="maxForVoid" value="3"/>
         </module>
         <module name="SimplifyBooleanExpression"/>
         <module name="SimplifyBooleanReturn"/>