diff --git a/Allure.NUnit/Core/AllureExtensions.cs b/Allure.NUnit/Core/AllureExtensions.cs
index 1776efb6..d1b9d3eb 100644
--- a/Allure.NUnit/Core/AllureExtensions.cs
+++ b/Allure.NUnit/Core/AllureExtensions.cs
@@ -3,6 +3,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Allure.Net.Commons;
+using NUnit.Framework.Interfaces;
 using NUnit.Framework.Internal;
 
 namespace NUnit.Allure.Core
@@ -204,6 +205,15 @@ public static async Task<T> WrapInStepAsync<T>(
             }
         }
 
+        internal const string DESELECTED_BY_TESTPLAN_KEY
+            = "DESELECTED_BY_TESTPLAN";
+
+        static internal void Deselect(this ITest test) =>
+            test.Properties.Add(DESELECTED_BY_TESTPLAN_KEY, true);
+
+        static internal bool IsDeselected(this ITest test) =>
+            test.Properties.ContainsKey(DESELECTED_BY_TESTPLAN_KEY);
+
         [Obsolete(
             "Use AllureLifecycle.AddScreenDiff instance method instead to " +
                 "add a screen diff to the current test."
diff --git a/Allure.NUnit/Core/AllureNUnitAttribute.cs b/Allure.NUnit/Core/AllureNUnitAttribute.cs
index 4a67d4ac..9309201b 100644
--- a/Allure.NUnit/Core/AllureNUnitAttribute.cs
+++ b/Allure.NUnit/Core/AllureNUnitAttribute.cs
@@ -35,12 +35,17 @@ public void BeforeTest(ITest test) =>
 
                 if (!test.IsSuite)
                 {
-                    helper.StartTestContainer(); // A container for SetUp/TearDown methods
-                    helper.StartTestCase();
+                    helper.PrepareTestContext();
                 }
             });
 
-        public void AfterTest(ITest test) =>
+        public void AfterTest(ITest test)
+        {
+            if (test.IsDeselected())
+            {
+                return;
+            }
+
             RunHookInRestoredAllureContext(test, () =>
             {
                 if (_allureNUnitHelper.TryGetValue(test.Id, out var helper))
@@ -52,14 +57,17 @@ public void AfterTest(ITest test) =>
                     }
                     else if (IsSuiteWithNoAfterFixtures(test))
                     {
-                        // If a test fixture contains a OneTimeTearDown method
-                        // with the [AllureAfter] attribute, the corresponding
-                        // container is closed in StopContainerAspect instead.
+                        // If a test class has no class-scope after-feature
+                        // (i.e., a method with both [OneTimeTearDown] and
+                        // [AllureAfter]), the class-scope container is closed
+                        // here. Otherwise, it's closed in StopContainerAspect
+                        // instead.
                         helper.StopTestContainer();
                     }
                 }
             });
-
+        }
+        
         public ActionTargets Targets =>
             ActionTargets.Test | ActionTargets.Suite;
 
diff --git a/Allure.NUnit/Core/AllureNUnitHelper.cs b/Allure.NUnit/Core/AllureNUnitHelper.cs
index 9c958792..7e2a6ed9 100644
--- a/Allure.NUnit/Core/AllureNUnitHelper.cs
+++ b/Allure.NUnit/Core/AllureNUnitHelper.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using Allure.Net.Commons;
+using Allure.Net.Commons.TestPlan;
 using Newtonsoft.Json.Linq;
 using NUnit.Allure.Attributes;
 using NUnit.Framework;
@@ -40,73 +42,26 @@ internal void StartTestContainer()
             });
         }
 
-        internal void StartTestCase()
+        internal void PrepareTestContext()
         {
-            var testResult = new TestResult
+            var testResult = this.CreateTestResult();
+            if (IsSelectedByTestPlan(testResult))
             {
-                uuid = string.Concat(
-                    Guid.NewGuid().ToString(),
-                    "-tr-",
-                    _test.Id
-                ),
-                name = _test.Name,
-                historyId = _test.FullName,
-                fullName = _test.FullName,
-                labels = new List<Label>
-                {
-                    Label.Thread(),
-                    Label.Host(),
-                    Label.Package(
-                        GetNamespace(_test.ClassName)
-                    ),
-                    Label.TestMethod(_test.MethodName),
-                    Label.TestClass(
-                        GetClassName(_test.ClassName)
-                    )
-                }
-            };
-            AllureLifecycle.StartTestCase(testResult);
-        }
-
-        static string GetNamespace(string classFullName)
-        {
-            var lastDotIndex = classFullName?.LastIndexOf('.') ?? -1;
-            return lastDotIndex == -1 ? null : classFullName.Substring(
-                0,
-                lastDotIndex
-            );
-        }
-
-        static string GetClassName(string classFullName)
-        {
-            var lastDotIndex = classFullName?.LastIndexOf('.') ?? -1;
-            return lastDotIndex == -1 ? classFullName : classFullName.Substring(
-                lastDotIndex + 1
-            );
-        }
-
-        private TestFixture GetTestFixture(ITest test)
-        {
-            var currentTest = test;
-            var isTestSuite = currentTest.IsSuite;
-            while (isTestSuite != true)
+                this.StartTestContainer(); // A container for SetUp/TearDown methods
+                AllureLifecycle.StartTestCase(testResult);
+            }
+            else
             {
-                currentTest = currentTest.Parent;
-                if (currentTest is ParameterizedMethodSuite)
-                {
-                    currentTest = currentTest.Parent;
-                }
-                isTestSuite = currentTest.IsSuite;
+                this._test.Deselect();
+                Assert.Ignore("Deselected by the testplan.");
             }
-
-            return (TestFixture) currentTest;
         }
 
         internal void StopTestCase()
         {
-            UpdateTestDataFromAttributes();
+            UpdateTestDataFromNUnitProperties();
             AddConsoleOutputAttachment();
-            
+
             for (var i = 0; i < _test.Arguments.Length; i++)
             {
                 AllureLifecycle.UpdateTestCase(
@@ -129,7 +84,7 @@ internal void StopTestCase()
                 {
                     message = string.IsNullOrWhiteSpace(
                         TestContext.CurrentContext.Result.Message
-                    ) ? TestContext.CurrentContext.Test.Name 
+                    ) ? TestContext.CurrentContext.Test.Name
                         : TestContext.CurrentContext.Result.Message,
                     trace = TestContext.CurrentContext.Result.StackTrace
                 }
@@ -195,7 +150,89 @@ public static Status GetNUnitStatus()
             return Status.passed;
         }
 
-        private void UpdateTestDataFromAttributes()
+        TestResult CreateTestResult()
+        {
+            var testResult = new TestResult
+            {
+                uuid = string.Concat(
+                    Guid.NewGuid().ToString(),
+                    "-tr-",
+                    _test.Id
+                ),
+                name = _test.Name,
+                historyId = _test.FullName,
+                fullName = _test.FullName,
+                labels = new List<Label>
+                {
+                    Label.Thread(),
+                    Label.Host(),
+                    Label.Package(
+                        GetNamespace(_test.ClassName)
+                    ),
+                    Label.TestMethod(_test.MethodName),
+                    Label.TestClass(
+                        GetClassName(_test.ClassName)
+                    )
+                }
+            };
+            this.UpdateTestDataFromAllureAttributes(testResult);
+            return testResult;
+        }
+
+        void UpdateTestDataFromAllureAttributes(TestResult testResult)
+        {
+            foreach (var attribute in this.IterateAllAllureAttribites())
+            {
+                attribute.UpdateTestResult(testResult);
+            }
+        }
+
+        static bool IsSelectedByTestPlan(TestResult testResult) =>
+            AllureLifecycle.TestPlan.IsSelected(testResult);
+
+        IEnumerable<AllureTestCaseAttribute> IterateAllAllureAttribites() =>
+            this._test.Method
+                .GetCustomAttributes<AllureTestCaseAttribute>(true)
+                .Concat(
+                    this.GetTestFixture(this._test)
+                        .GetCustomAttributes<AllureTestCaseAttribute>(true)
+                );
+
+        static string GetNamespace(string classFullName)
+        {
+            var lastDotIndex = classFullName?.LastIndexOf('.') ?? -1;
+            return lastDotIndex == -1 ? null : classFullName.Substring(
+                0,
+                lastDotIndex
+            );
+        }
+
+        static string GetClassName(string classFullName)
+        {
+            var lastDotIndex = classFullName?.LastIndexOf('.') ?? -1;
+            return lastDotIndex == -1 ? classFullName : classFullName.Substring(
+                lastDotIndex + 1
+            );
+        }
+
+        private TestFixture GetTestFixture(ITest test)
+        {
+            var currentTest = test;
+            var isTestSuite = currentTest.IsSuite;
+            while (isTestSuite != true)
+            {
+                currentTest = currentTest.Parent;
+                if (currentTest is ParameterizedMethodSuite)
+                {
+                    currentTest = currentTest.Parent;
+                }
+                isTestSuite = currentTest.IsSuite;
+            }
+
+            return (TestFixture) currentTest;
+        }
+
+        private void UpdateTestDataFromNUnitProperties()
         {
             foreach (var p in GetTestProperties(PropertyNames.Description))
             {
@@ -217,20 +254,6 @@ private void UpdateTestDataFromAttributes()
                     x => x.labels.Add(Label.Tag(p))
                 );
             }
-
-            var attributes = _test.Method
-                .GetCustomAttributes<AllureTestCaseAttribute>(true)
-                .ToList();
-            attributes.AddRange(
-                GetTestFixture(_test)
-                    .GetCustomAttributes<AllureTestCaseAttribute>(true)
-                    .ToList()
-            );
-
-            attributes.ForEach(a =>
-            {
-                AllureLifecycle.UpdateTestCase(a.UpdateTestResult);
-            });
         }
 
         private void AddConsoleOutputAttachment()
@@ -280,7 +303,9 @@ public void WrapInStep(Action action, string stepName = "")
         }
 
         private string ContainerId => $"tc-{_test.Id}";
-        
+
+        [Obsolete("Not intended as a part of the public API")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SaveOneTimeResultToContext()
         {
             var currentResult = TestExecutionContext
@@ -314,7 +339,9 @@ public void SaveOneTimeResultToContext()
             );
             testFixture.Properties.Set("OneTimeSetUpResult", fixtureResult);
         }
-        
+
+        [Obsolete("Not intended as a part of the public API")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void AddOneTimeSetupResult()
         {
             var testFixture = GetTestFixture(
diff --git a/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanProviderTests.cs b/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanProviderTests.cs
new file mode 100644
index 00000000..bf4a8fe6
--- /dev/null
+++ b/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanProviderTests.cs
@@ -0,0 +1,120 @@
+using Allure.Net.Commons.TestPlan;
+using NUnit.Framework;
+using System;
+using System.IO;
+using System.Text;
+
+namespace Allure.Net.Commons.Tests.SelectiveRunTests
+{
+    class TestPlanProviderTests
+    {
+        private string testPlanPath;
+
+        [SetUp]
+        public void SetUp()
+        {
+            this.testPlanPath = Path.GetTempFileName();
+            File.WriteAllText(
+                this.testPlanPath,
+                "{\"tests\": [{\"id\": \"100\"}]}",
+                Encoding.UTF8
+            );
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (File.Exists(this.testPlanPath))
+            {
+                File.Delete(this.testPlanPath);
+            }
+            Environment.SetEnvironmentVariable("ALLURE_TESTPLAN_PATH", null);
+            Environment.SetEnvironmentVariable("AS_TESTPLAN_PATH", null);
+        }
+
+        [Test]
+        public void TestPlanCreatedFromFileByNewEnvName()
+        {
+            Environment.SetEnvironmentVariable(
+                "ALLURE_TESTPLAN_PATH",
+                this.testPlanPath
+            );
+
+            var testplan = AllureTestPlan.FromEnvironment();
+
+            Assert.That(
+                testplan.Tests,
+                Is.EqualTo(
+                    new[] { new AllureTestPlanItem() { Id = "100" } }
+                )
+            );
+        }
+
+        [Test]
+        public void TestPlanCreatedFromFileByOldEnvName()
+        {
+            Environment.SetEnvironmentVariable(
+                "AS_TESTPLAN_PATH",
+                this.testPlanPath
+            );
+
+            var testplan = AllureTestPlan.FromEnvironment();
+
+            Assert.That(
+                testplan.Tests,
+                Is.EqualTo(
+                    new[] { new AllureTestPlanItem() { Id = "100" } }
+                )
+            );
+        }
+
+        [Test]
+        public void DefaultTestPlanCreatedIfNoEnvVarDefined()
+        {
+            Assert.That(
+                AllureTestPlan.FromEnvironment(),
+                Is.SameAs(
+                    AllureTestPlan.DEFAULT_TESTPLAN
+                )
+            );
+        }
+
+        [Test]
+        public void DefaultTestPlanCreatedIfFIleDoesntExist()
+        {
+            Environment.SetEnvironmentVariable(
+                "ALLURE_TESTPLAN_PATH",
+                Guid.NewGuid().ToString()
+            );
+
+            Assert.That(
+                AllureTestPlan.FromEnvironment(),
+                Is.SameAs(
+                    AllureTestPlan.DEFAULT_TESTPLAN
+                )
+            );
+        }
+
+        [Test]
+        public void IfBothEnvVarsPresentNewIsPreferred()
+        {
+            Environment.SetEnvironmentVariable(
+                "AS_TESTPLAN_PATH",
+                Guid.NewGuid().ToString()
+            );
+            Environment.SetEnvironmentVariable(
+                "ALLURE_TESTPLAN_PATH",
+                this.testPlanPath
+            );
+
+            var testplan = AllureTestPlan.FromEnvironment();
+
+            Assert.That(
+                testplan.Tests,
+                Is.EqualTo(
+                    new[] { new AllureTestPlanItem() { Id = "100" } }
+                )
+            );
+        }
+    }
+}
diff --git a/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanTests.cs b/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanTests.cs
new file mode 100644
index 00000000..c12dfc11
--- /dev/null
+++ b/Allure.Net.Commons.Tests/SelectiveRunTests/TestPlanTests.cs
@@ -0,0 +1,272 @@
+using Allure.Net.Commons.TestPlan;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+#nullable enable
+
+namespace Allure.Net.Commons.Tests.SelectiveRunTests
+{
+    class TestPlanTests
+    {
+        [TestCase("null")]
+        [TestCase("{}")]
+        [TestCase("{\"tests\": []}")]
+        public void EmptyTestPlanEnablesAllTests(string json)
+        {
+            var testPlan = AllureTestPlan.FromJson(json);
+
+            Assert.That(testPlan, Is.Not.Null);
+            Assert.That(
+                testPlan.IsSelected("", null),
+                Is.True
+            );
+        }
+
+        [TestCase(null, false)]
+        [TestCase("100", true)]
+        [TestCase("101", false)]
+        public void TestPlanWithIdEntry(
+            string allureIdOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson = "{\"tests\": [{\"id\": \"100\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    "",
+                    allureIdOfTestCase
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("a", true)]
+        [TestCase("A", false)]
+        [TestCase("aa", false)]
+        public void TestPlanWithSelectorEntry(
+            string fullNameOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"selector\": \"a\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    fullNameOfTestCase,
+                    null
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("a", "100", true)]
+        [TestCase("b", "100", true)]
+        [TestCase("a", "101", true)]
+        [TestCase("a", null, true)]
+        [TestCase("b", "101", false)]
+        [TestCase("b", null, false)]
+        public void TestPlanWithIdAndSelectorEntry(
+            string fullNameOfTestCase,
+            string allureIdOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"selector\": \"a\", \"id\": \"100\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    fullNameOfTestCase,
+                    allureIdOfTestCase
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("100", true)]
+        [TestCase("101", true)]
+        [TestCase("102", false)]
+        public void TestPlanWithMultipleIdEntries(
+            string allureIdOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"id\": \"100\"}, {\"id\": \"101\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    "",
+                    allureIdOfTestCase
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("a", true)]
+        [TestCase("b", true)]
+        [TestCase("c", false)]
+        public void TestPlanWithMultipleSelectorEntries(
+            string fullNameOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"selector\": \"a\"}, {\"selector\": \"b\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    fullNameOfTestCase,
+                    null
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("a", "100", true)]
+        [TestCase("b", "100", true)]
+        [TestCase("a", "101", true)]
+        [TestCase("a", null, true)]
+        [TestCase("b", "101", false)]
+        [TestCase("b", null, false)]
+        public void TestPlanWithMultipleDifferentEntries(
+            string fullNameOfTestCase,
+            string allureIdOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"id\": \"100\"}, {\"selector\": \"a\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    fullNameOfTestCase,
+                    allureIdOfTestCase
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [TestCase("a", null, true)]
+        [TestCase("a", "100", true)]
+        [TestCase("a", "101", true)]
+        [TestCase("a", "102", true)]
+        [TestCase("b", null, true)]
+        [TestCase("b", "100", true)]
+        [TestCase("b", "101", true)]
+        [TestCase("b", "102", true)]
+        [TestCase("c", null, false)]
+        [TestCase("c", "100", true)]
+        [TestCase("c", "101", true)]
+        [TestCase("c", "102", false)]
+        public void TestPlanWithMultipleFullEntries(
+            string fullNameOfTestCase,
+            string allureIdOfTestCase,
+            bool expectedMatch
+        )
+        {
+            var testPlanJson =
+                "{\"tests\": [{\"selector\": \"a\", \"id\": \"100\"}, {\"selector\": \"b\", \"id\": \"101\"}]}";
+            var testPlan = AllureTestPlan.FromJson(testPlanJson);
+
+            Assert.That(
+                testPlan.IsSelected(
+                    fullNameOfTestCase,
+                    allureIdOfTestCase
+                ),
+                Is.EqualTo(expectedMatch)
+            );
+        }
+
+        [Test]
+        public void TestResultMatchShorthandTest(
+            [Values(
+                "[]",
+                "[{\"id\": \"100\"}]",
+                "[{\"selector\": \"a\"}]",
+                "[{\"selector\": \"a\", \"id\": \"100\"}]",
+                "[{\"id\": \"100\"}, {\"id\": \"101\"}]",
+                "[{\"selector\": \"a\"}, {\"selector\": \"b\"}]",
+                "[{\"id\": \"100\"}, {\"selector\": \"a\"}]",
+                "[{\"selector\": \"a\", \"id\": \"100\"}, {\"selector\": \"b\", \"id\": \"101\"}]"
+            )] string testPlanItemsJson,
+            [Values("a", "b", "c")] string fullNameOfTestCase,
+            [Values("100", "101", "102")] string allureIdOfTestCase
+        )
+        {
+            var testResult = new TestResult
+            {
+                fullName = fullNameOfTestCase,
+                labels = allureIdOfTestCase is null ? new() : new()
+                {
+                    new() { name = "ALLURE_ID", value = allureIdOfTestCase }
+                }
+            };
+            var testPlan = AllureTestPlan.FromJson(
+                $"{{\"tests\": {testPlanItemsJson}}}"
+            );
+
+            Assert.That(
+                testPlan.IsSelected(testResult),
+                Is.EqualTo(
+                    testPlan.IsSelected(fullNameOfTestCase, allureIdOfTestCase)
+                )
+            );
+        }
+
+        [TestCase(new string[] { }, null)]
+        [TestCase(new[] { "ALLURE_ID", "100" }, "100")]
+        [TestCase(new[] { "l1", "v1" }, null)]
+        [TestCase(new[] { "AS_ID", "100" }, "100")]
+        [TestCase(new[] { "allure_id", "100" }, "100")]
+        [TestCase(new[] { "as_id", "100" }, "100")]
+        [TestCase(new[]
+        {
+            "l", "v",
+            "ALLURE_ID", "100"
+        }, "100")]
+        [TestCase(new[]
+        {
+            "l", "v",
+            "AS_ID", "100"
+        }, "100")]
+        [TestCase(new[]
+        {
+            "allure_id", "100",
+            "ALLURE_ID", "101",
+            "AS_ID", "102"
+        }, "100")]
+        [TestCase(new[]
+        {
+            "AS_ID", "100",
+            "ALLURE_ID", "101"
+        }, "101")]
+        public void GetAllureIdTest(string[] labels, string? expectedAllureId)
+        {
+            Assert.That(
+                AllureTestPlan.GetAllureId(
+                    CreateLabels(labels)
+                ),
+                Is.EqualTo(expectedAllureId)
+            );
+        }
+
+        static IEnumerable<Label> CreateLabels(params string[] labels) =>
+            Enumerable.Range(0, labels.Length / 2).Select(
+                i => new Label()
+                {
+                    name = labels[2 * i],
+                    value = labels[2 * i + 1]
+                }
+            );
+    }
+}
diff --git a/Allure.Net.Commons/AllureConstants.cs b/Allure.Net.Commons/AllureConstants.cs
index 33e959be..28fa9321 100644
--- a/Allure.Net.Commons/AllureConstants.cs
+++ b/Allure.Net.Commons/AllureConstants.cs
@@ -10,5 +10,11 @@ public sealed class AllureConstants
         public const string TEST_RESULT_CONTAINER_FILE_SUFFIX = "-container.json";
         public static string TEST_RUN_FILE_SUFFIX = "-testrun.json";
         public const string ATTACHMENT_FILE_SUFFIX = "-attachment";
+
+        public const string OLD_ALLURE_ID_LABEL_NAME = "AS_ID";
+        public const string NEW_ALLURE_ID_LABEL_NAME = "ALLURE_ID";
+
+        public const string OLD_ALLURE_TESTPLAN_ENV_NAME = "AS_TESTPLAN_PATH";
+        public const string NEW_ALLURE_TESTPLAN_ENV_NAME = "ALLURE_TESTPLAN_PATH";
     }
 }
\ No newline at end of file
diff --git a/Allure.Net.Commons/AllureLifecycle.cs b/Allure.Net.Commons/AllureLifecycle.cs
index f2f41514..151e4e0a 100644
--- a/Allure.Net.Commons/AllureLifecycle.cs
+++ b/Allure.Net.Commons/AllureLifecycle.cs
@@ -7,6 +7,7 @@
 using System.Threading;
 using Allure.Net.Commons.Configuration;
 using Allure.Net.Commons.Storage;
+using Allure.Net.Commons.TestPlan;
 using Allure.Net.Commons.Writer;
 using HeyRed.Mime;
 using Newtonsoft.Json.Linq;
@@ -39,6 +40,8 @@ public class AllureLifecycle
     readonly AllureStorage storage;
     readonly AsyncLocal<AllureContext> context = new();
 
+    readonly Lazy<AllureTestPlan> lazyTestPlan;
+
     readonly IAllureResultsWriter writer;
 
     /// <summary>
@@ -57,30 +60,46 @@ public AllureContext Context
         private set => this.context.Value = value;
     }
 
+    /// <summary>
+    /// The current testplan. If no testplan was specified, the default one is
+    /// used that doesn't filter any test.
+    /// </summary>
+    public AllureTestPlan TestPlan { get => this.lazyTestPlan.Value; }
+
     internal AllureLifecycle() : this(GetConfiguration())
     {
     }
 
     internal AllureLifecycle(
         Func<AllureConfiguration, IAllureResultsWriter> writerFactory
-    ) : this(GetConfiguration(), writerFactory)
+    ) : this(
+        GetConfiguration(),
+        writerFactory,
+        AllureTestPlan.FromEnvironment
+    )
     {
     }
 
-    internal AllureLifecycle(JObject config)
-        : this(config, c => new FileSystemResultsWriter(c))
+    internal AllureLifecycle(JObject config) : this(
+        config,
+        c => new FileSystemResultsWriter(c),
+        AllureTestPlan.FromEnvironment
+    )
     {
+
     }
 
     internal AllureLifecycle(
         JObject config,
-        Func<AllureConfiguration, IAllureResultsWriter> writerFactory
+        Func<AllureConfiguration, IAllureResultsWriter> writerFactory,
+        Func<AllureTestPlan> testPlanFactory
     )
     {
         JsonConfiguration = config.ToString();
         AllureConfiguration = AllureConfiguration.ReadFromJObject(config);
         writer = writerFactory(AllureConfiguration);
         storage = new AllureStorage();
+        lazyTestPlan = new(testPlanFactory);
     }
 
     public string JsonConfiguration { get; private set; }
diff --git a/Allure.Net.Commons/TestPlan/AllureTestPlan.cs b/Allure.Net.Commons/TestPlan/AllureTestPlan.cs
new file mode 100644
index 00000000..623a6f38
--- /dev/null
+++ b/Allure.Net.Commons/TestPlan/AllureTestPlan.cs
@@ -0,0 +1,140 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+#nullable enable
+
+namespace Allure.Net.Commons.TestPlan;
+
+/// <summary>
+/// Used by integrations to enable selective run of tests.
+/// </summary>
+public class AllureTestPlan
+{
+    /// <summary>
+    /// Testplan entries that denote tests included in the run.
+    /// </summary>
+    public List<AllureTestPlanItem> Tests
+    {
+        get => this.tests;
+        set
+        {
+            this.tests = value ?? new();
+            this.RecreateFilters();
+        }
+    }
+
+    /// <summary>
+    /// Used by integrations to check if a test is selected by the testplan.
+    /// </summary>
+    /// <param name="fullName">A fullName of the test.</param>
+    /// <param name="allureId">
+    /// An identifier of the test case (if any).
+    /// Use <see cref="GetAllureId"/> to get it from the test result.
+    /// </param>
+    /// <returns>true if the test should be executed. false otherwise.</returns>
+    public bool IsSelected(string fullName, string? allureId) =>
+        this.IsDefaultTestplanMatch()
+            || this.IsFullNameMatch(fullName)
+            || this.IsAllureIdMatch(allureId);
+
+    /// <summary>
+    /// A shorthand for <see cref="IsSelected(string, string?)"/> with the
+    /// fullName and the allure id taken from the provided test result.
+    /// </summary>
+    public bool IsSelected(TestResult testResult) =>
+        this.IsSelected(
+            testResult.fullName,
+            GetAllureId(testResult.labels)
+        );
+
+    /// <summary>
+    /// Creates the testplan from a JSON string.
+    /// </summary>
+    public static AllureTestPlan FromJson(string jsonContent) =>
+        JsonConvert.DeserializeObject<AllureTestPlan>(
+            jsonContent,
+            new JsonSerializerSettings()
+            {
+                ObjectCreationHandling = ObjectCreationHandling.Replace,
+            }
+        ) ?? DEFAULT_TESTPLAN;
+
+    /// <summary>
+    /// Creates the testplan from the file pointed by the environment variable.
+    /// </summary>
+    /// <exception cref="NotImplementedException"></exception>
+    public static AllureTestPlan FromEnvironment()
+    {
+        var testPlanPath = ResolveTestPlanPath();
+        return GetTestPlanByPath(testPlanPath);
+    }
+
+    /// <summary>
+    /// Finds an Allure id in a sequence of labels. If no id exists, returns
+    /// null.
+    /// </summary>
+    public static string? GetAllureId(IEnumerable<Label> labels) =>
+        FindLabel(labels, AllureConstants.NEW_ALLURE_ID_LABEL_NAME)
+            ?? FindLabel(labels, AllureConstants.OLD_ALLURE_ID_LABEL_NAME);
+
+    /// <summary>
+    /// A testplan that doesn't filter any test.
+    /// </summary>
+    public static readonly AllureTestPlan DEFAULT_TESTPLAN = new();
+
+    static string? ResolveTestPlanPath() =>
+        new[]
+        {
+            AllureConstants.NEW_ALLURE_TESTPLAN_ENV_NAME,
+            AllureConstants.OLD_ALLURE_TESTPLAN_ENV_NAME
+        }.Select(Environment.GetEnvironmentVariable).Where(
+            ev => !string.IsNullOrWhiteSpace(ev)
+        ).FirstOrDefault();
+
+    static AllureTestPlan GetTestPlanByPath(string? testPlanPath) =>
+        testPlanPath is null || !File.Exists(testPlanPath)
+            ? DEFAULT_TESTPLAN
+            : ReadTestPlanFromFile(testPlanPath);
+
+    static AllureTestPlan ReadTestPlanFromFile(string testPlanPath) =>
+        FromJson(
+            File.ReadAllText(testPlanPath, Encoding.UTF8)
+        );
+
+    static string? FindLabel(IEnumerable<Label> labels, string labelName) =>
+        labels.FirstOrDefault(
+            l => labelName.Equals(l.name, StringComparison.OrdinalIgnoreCase)
+        )?.value;
+
+    List<AllureTestPlanItem> tests = new();
+    HashSet<string> allIds = new();
+    HashSet<string> allSelectors = new();
+
+    void RecreateFilters()
+    {
+        this.allIds = new HashSet<string>(
+            from entry in this.tests
+            where entry.Id is not null
+            select entry.Id,
+            StringComparer.Ordinal
+        );
+        this.allSelectors = new HashSet<string>(
+            from entry in this.tests
+            where entry.Selector is not null
+            select entry.Selector,
+            StringComparer.Ordinal
+        );
+    }
+
+    bool IsDefaultTestplanMatch() => !this.tests.Any();
+
+    bool IsAllureIdMatch(string? allureId) =>
+        allureId is not null && this.allIds.Contains(allureId);
+
+    bool IsFullNameMatch(string fullName) =>
+        this.allSelectors.Contains(fullName);
+}
diff --git a/Allure.Net.Commons/TestPlan/AllureTestPlanItem.cs b/Allure.Net.Commons/TestPlan/AllureTestPlanItem.cs
new file mode 100644
index 00000000..70adc1fb
--- /dev/null
+++ b/Allure.Net.Commons/TestPlan/AllureTestPlanItem.cs
@@ -0,0 +1,10 @@
+#nullable enable
+
+namespace Allure.Net.Commons.TestPlan;
+
+public record class AllureTestPlanItem
+{
+    public string? Id { get; set; }
+
+    public string? Selector { get; set; }
+}
diff --git a/Allure.XUnit/AllureMessageSink.cs b/Allure.XUnit/AllureMessageSink.cs
index 90d3b5c2..f84050ab 100644
--- a/Allure.XUnit/AllureMessageSink.cs
+++ b/Allure.XUnit/AllureMessageSink.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Allure.Net.Commons;
+using Allure.Net.Commons.TestPlan;
 using Allure.Xunit;
 using Xunit;
 using Xunit.Abstractions;
@@ -14,6 +15,16 @@ namespace Allure.XUnit
     public class AllureMessageSink :
         DefaultRunnerReporterWithTypesMessageHandler
     {
+        static AllureTestPlan TestPlan
+        {
+            get => AllureLifecycle.Instance.TestPlan;
+        }
+
+        static AllureContext AllureContext
+        {
+            get => AllureLifecycle.Instance.Context;
+        }
+
         readonly ConcurrentDictionary<ITest, AllureXunitTestData>
             allureTestData = new();
 
@@ -40,6 +51,16 @@ MessageHandlerArgs<ITestAssemblyExecutionStarting> args
             args.Message.ExecutionOptions.SetSynchronousMessageReporting(true);
         }
 
+        internal bool SelectByTestPlan(ITest test)
+        {
+            var associatedData = this.GetOrCreateTestData(test);
+            var testResult = AllureXunitHelper.CreateTestResultByTest(test);
+            var isSelected = TestPlan.IsSelected(testResult);
+            associatedData.TestResult = testResult;
+            associatedData.IsSelected = isSelected;
+            return isSelected;
+        }
+
         internal void OnTestArgumentsCreated(ITest test, object[] arguments) =>
             this.GetOrCreateTestData(test).Arguments = arguments;
 
@@ -47,17 +68,24 @@ void OnTestStarting(MessageHandlerArgs<ITestStarting> args)
         {
             var message = args.Message;
             var test = message.Test;
+            var testData = this.GetOrCreateTestData(test);
 
-            if (IsStaticTestMethod(message))
+            if (testData.IsSelected)
             {
-                AllureXunitHelper.StartStaticAllureTestCase(test);
-                this.CaptureTestContext(test);
-            }
-            else
-            {
-                AllureXunitHelper.StartNewAllureContainer(
-                    message.TestClass.Class.Name
-                );
+                if (IsStaticTestMethod(message))
+                {
+                    AllureXunitHelper.StartAllureTestCase(
+                        test,
+                        testData.TestResult
+                    );
+                    this.CaptureTestContext(test);
+                }
+                else
+                {
+                    AllureXunitHelper.StartNewAllureContainer(
+                        message.TestClass.Class.Name
+                    );
+                }
             }
         }
 
@@ -67,9 +95,11 @@ MessageHandlerArgs<ITestClassConstructionFinished> args
         {
             var message = args.Message;
             var test = message.Test;
+            
             if (!IsStaticTestMethod(message))
             {
-                AllureXunitHelper.StartAllureTestCase(test);
+                var testResult = this.GetOrCreateTestData(test).TestResult;
+                AllureXunitHelper.StartAllureTestCase(test, testResult);
                 this.CaptureTestContext(test);
             }
         }
@@ -90,31 +120,41 @@ void OnTestSkipped(MessageHandlerArgs<ITestSkipped> args)
         {
             var message = args.Message;
             var test = message.Test;
-            this.UpdateTestContext(test, () =>
+            var testData = this.GetOrCreateTestData(test);
+            if (testData.IsSelected)
             {
-                if (!AllureLifecycle.Instance.Context.HasTest)
+                this.UpdateTestContext(test, () =>
                 {
-                    AllureXunitHelper.StartAllureTestCase(test);
-                }
-                AllureXunitHelper.ApplyTestSkip(message);
-            });
+                    if (!AllureContext.HasTest)
+                    {
+                        AllureXunitHelper.StartAllureTestCase(
+                            test,
+                            testData.TestResult
+                        );
+                    }
+                    AllureXunitHelper.ApplyTestSkip(message);
+                });
+            }
         }
 
         void OnTestFinished(MessageHandlerArgs<ITestFinished> args)
         {
             var message = args.Message;
             var test = args.Message.Test;
-            var arguments = this.allureTestData[test].Arguments;
+            var testData = this.GetOrCreateTestData(test);
 
-            this.RunInTestContext(test, () =>
+            if (testData.IsSelected)
             {
-                this.AddAllureParameters(test, arguments);
-                AllureXunitHelper.ReportCurrentTestCase();
-                if (!IsStaticTestMethod(message))
+                this.RunInTestContext(test, () =>
                 {
-                    AllureXunitHelper.ReportCurrentTestContainer();
-                }
-            });
+                    this.AddAllureParameters(test, testData.Arguments);
+                    AllureXunitHelper.ReportCurrentTestCase();
+                    if (!IsStaticTestMethod(message))
+                    {
+                        AllureXunitHelper.ReportCurrentTestContainer();
+                    }
+                });
+            }
 
             this.allureTestData.Remove(test, out _);
         }
@@ -129,7 +169,7 @@ AllureXunitTestData GetOrCreateTestData(ITest test)
             return data;
         }
 
-        void AddAllureParameters(ITest test, object[] arguments)
+        void AddAllureParameters(ITest test, object[]? arguments)
         {
             var testCase = test.TestCase;
             var parameters = testCase.TestMethod.Method.GetParameters();
@@ -148,7 +188,7 @@ void AddAllureParameters(ITest test, object[] arguments)
 
         void CaptureTestContext(ITest test) =>
             this.GetOrCreateTestData(test).Context =
-                AllureLifecycle.Instance.Context;
+                AllureContext;
 
         AllureContext RunInTestContext(ITest test, Action action) =>
             AllureLifecycle.Instance.RunInContext(
diff --git a/Allure.XUnit/AllureXunitHelper.cs b/Allure.XUnit/AllureXunitHelper.cs
index 98d3a3fa..3b22b13c 100644
--- a/Allure.XUnit/AllureXunitHelper.cs
+++ b/Allure.XUnit/AllureXunitHelper.cs
@@ -60,19 +60,13 @@ string className
             return container;
         }
 
-        internal static TestResult StartStaticAllureTestCase(ITest test)
-        {
-            var testResult = CreateTestResultByTest(test);
-            AllureLifecycle.Instance.StartTestCase(testResult);
-            return testResult;
-        }
-
-        internal static TestResult StartAllureTestCase(ITest test)
-        {
-            var testResult = CreateTestResultByTest(test);
-            AllureLifecycle.Instance.StartTestCase(testResult);
-            return testResult;
-        }
+        internal static void StartAllureTestCase(
+            ITest test,
+            TestResult? testResult
+        ) =>
+            AllureLifecycle.Instance.StartTestCase(
+                testResult ?? CreateTestResultByTest(test)
+            );
 
         internal static void ApplyTestFailure(IFailureInformation failure)
         {
@@ -149,20 +143,9 @@ internal static void ReportCurrentTestContainer()
             AllureLifecycle.Instance.WriteTestContainer();
         }
 
-        internal static void ReportSkippedTestCase(ITestCase testCase)
-        {
-            var testResult = CreateTestResultByTestCase(testCase);
-            ApplyTestSkip(testResult, testCase.SkipReason);
-            AllureLifecycle.Instance.StartTestCase(testResult);
-            ReportCurrentTestCase();
-        }
-
-        static TestResult CreateTestResultByTest(ITest test) =>
+        internal static TestResult CreateTestResultByTest(ITest test) =>
             CreateTestResult(test.TestCase, test.DisplayName);
 
-        static TestResult CreateTestResultByTestCase(ITestCase testCase) =>
-            CreateTestResult(testCase, testCase.DisplayName);
-
         static TestResult CreateTestResult(
             ITestCase testCase,
             string displayName
@@ -421,6 +404,9 @@ public static void StartTestCase(ITestCaseMessage testCaseMessage)
             );
         }
 
+        static TestResult CreateTestResultByTestCase(ITestCase testCase) =>
+            CreateTestResult(testCase, testCase.DisplayName);
+
         [Obsolete(OBS_MSG_UNINTENDED_PUBLIC)]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public static void MarkTestCaseAsFailedOrBroken(ITestFailed testFailed)
diff --git a/Allure.XUnit/AllureXunitPatcher.cs b/Allure.XUnit/AllureXunitPatcher.cs
index cd370fb2..7bc25e89 100644
--- a/Allure.XUnit/AllureXunitPatcher.cs
+++ b/Allure.XUnit/AllureXunitPatcher.cs
@@ -13,6 +13,19 @@ static class AllureXunitPatcher
         static bool isPatched = false;
         static IRunnerLogger logger;
 
+        static AllureMessageSink CurrentSink
+        {
+            get
+            {
+                var sink = AllureMessageSink.CurrentSink;
+                if (sink is null)
+                {
+                    logger.LogWarning("Unable to get current message sink.");
+                }
+                return sink;
+            }
+        }
+
         public static void PatchXunit(IRunnerLogger runnerLogger)
         {
             if (isPatched)
@@ -39,9 +52,13 @@ static void PatchXunitTestRunnerCtors(Harmony patcher)
                 {
                     patcher.Patch(
                         ctor,
+                        prefix: new HarmonyMethod(
+                            typeof(AllureXunitPatcher),
+                            nameof(OnTestRunnerCreating)
+                        ),
                         postfix: new HarmonyMethod(
                             typeof(AllureXunitPatcher),
-                            nameof(AllureXunitPatcher.OnTestRunnerCreated)
+                            nameof(OnTestRunnerCreated)
                         )
                     );
                     wasPatched = true;
@@ -72,26 +89,18 @@ static void PatchXunitTestRunnerCtors(Harmony patcher)
             }
         }
 
-        static void OnTestRunnerCreated(
-            ITest test,
-            object[] testMethodArguments
-        )
+        static void OnTestRunnerCreating(ITest test, ref string skipReason)
         {
-            if (AllureMessageSink.CurrentSink is null)
-            {
-                logger.LogWarning(
-                    "Unable to get current message sink from the test " +
-                        "runner's hook of the {0} test",
-                    test.DisplayName
-                );
-            }
-            else
+            if (!CurrentSink.SelectByTestPlan(test))
             {
-                AllureMessageSink.CurrentSink.OnTestArgumentsCreated(
-                    test,
-                    testMethodArguments
-                );
+                skipReason = "Deselected by the testplan.";
             }
         }
+
+        static void OnTestRunnerCreated(
+            ITest test,
+            object[] testMethodArguments
+        ) =>
+            CurrentSink.OnTestArgumentsCreated(test, testMethodArguments);
     }
 }
\ No newline at end of file
diff --git a/Allure.XUnit/AllureXunitTestData.cs b/Allure.XUnit/AllureXunitTestData.cs
index f8512b5f..2a0d3b18 100644
--- a/Allure.XUnit/AllureXunitTestData.cs
+++ b/Allure.XUnit/AllureXunitTestData.cs
@@ -1,10 +1,14 @@
 using Allure.Net.Commons;
 
+#nullable enable
+
 namespace Allure.XUnit
 {
     class AllureXunitTestData
     {
-        public AllureContext Context { get; set; }
-        public object[] Arguments { get; set; }
+        public AllureContext? Context { get; set; }
+        public object[]? Arguments { get; set; }
+        public TestResult? TestResult { get; set; }
+        public bool IsSelected { get; set; } = true;
     }
 }
\ No newline at end of file