✅ A project with a single scenario should compile successfully in all supported languages and build systems(description: "C# with dotnet build", language: "C#", buildCommand: "dotnet build", exampleTags: [])
✅ A project with a single scenario should compile successfully in all supported languages and build systems(description: "C# with dotnet msbuild", language: "C#", buildCommand: "dotnet msbuild", exampleTags: [])
✅ A project with a single scenario should compile successfully in all supported languages and build systems(description: "VB.NET with dotnet build", language: "VB.NET", buildCommand: "dotnet build", exampleTags: [])
✅ A project with a single scenario should compile successfully in all supported languages and build systems(description: "VB.NET with dotnet msuild", language: "VB.NET", buildCommand: "dotnet msbuild", exampleTags: [])

✅ Use dotnet build for compiling
✅ Use dotnet msbuild for compiling

✅ Different scenarios should have their own ScenarioContext injected
✅ FeatureContext can be accessed from Steps base class
✅ ScenarioContext can be accessed from Steps base class
✅ Should be able to inject FeatureContext
✅ Should be able to inject ScenarioContext
✅ StepContext can be accessed from Steps base class
✅ StepContext can be accessed from the ScenarioContext
✅ The obsolete ScenarioContext.Current can be accessed from a non-parallel execution
✅ The same FeatureContext should be inject in the scenarios of the same feature
✅ The same ScenarioContext should be inject in the same scenario

✅ Check Feature description is not empty
✅ Check Feature description is null if empty

✅ Binding class can depend on a single context
✅ Binding class can depend on multiple contexts
✅ Context classes are recreated for every scenario
✅ Context classes are shared across binding classes
✅ Context classes can depend on other context classes recursively
✅ Disposable dependencies should be disposed after scenario execution

✅ Inject FeatureContext into a Feature hook(hook: "AfterFeature", exampleTags: [])
✅ Inject FeatureContext into a Feature hook(hook: "BeforeFeature", exampleTags: [])
✅ Inject ScenarioContext into a Scenario hook(hook: "AfterScenario", exampleTags: [])
✅ Inject ScenarioContext into a Scenario hook(hook: "BeforeScenario", exampleTags: [])

✅ Scenario arguments are empty for regular scenario
✅ Scenario arguments for outlined scenario

✅ Check Scenario description is not empty
✅ Check Scenario description is null if empty

✅ Accessing tags of a scenario inside a rule
✅ Accessing tags of a scenario outline
✅ Accessing tags of a simple scenario

✅ Should wait for aync step methods to complete before continuing to next step
✅ Step method should recieve exception from async method call

✅ Building the same project multiple times without changes should be possible
✅ Should be able to execute a simple failing scenario
✅ Should be able to execute a simple passing scenario
✅ Should be able to execute a simple pending scenario

✅ The binding culture can be specified to be different than the scenario culture
✅ The default culture is used for bindings if not specified
✅ The scenario language is used for bindings if not specified

✅ Generation configuration in reqnroll.json
✅ Runtime configuration in reqnroll.json

✅ Cucumber expresions and Regular expressions are mixed in the same project
✅ Cucumber expresions are used for Step Definitions
✅ Custom parameter types definied with [StepArgumentTransformation] can be used with specified name
✅ Custom parameter types definied with [StepArgumentTransformation] can be used with type name

✅ Step parameters in the step definitions have to be declared before the multiline text and table parameters
✅ Steps can be defined with multiline text argument
✅ Steps can be defined with table argument
✅ Steps can be defined without argument

✅ Generated classes from test files can be compiled(language: "C#", exampleTags: [])
✅ Generated classes from test files can be compiled(language: "VB.Net", exampleTags: [])
✅ Scenarios in the test file can be executed
✅ Test files can be generated(language: "C#", exampleTags: [])
✅ Test files can be generated(language: "VB.Net", exampleTags: [])

✅ Steps can defined in an external .NET (e.g. c# or VB.NET) project
✅ Steps can defined in an external F# project

✅ Should be able to ignore all Scenarios and Scenario Outlines in a feature
✅ Should be able to ignore all Scenarios in a feature

✅ Should be able to ignore a scenario
✅ Should be able to ignore a scenario outline

✅ Before/After TestRun hook should only be executed once(event: "AfterTestRun", exampleTags: [])
✅ Before/After TestRun hook should only be executed once(event: "BeforeTestRun", exampleTags: [])
✅ Current context cannot be used in multi-threaded execution(context: "FeatureContext", exampleTags: [])
✅ Current context cannot be used in multi-threaded execution(context: "ScenarioContext", exampleTags: [])
✅ Current context cannot be used in multi-threaded execution(context: "ScenarioStepContext", exampleTags: [])
✅ Precondition: Tests run parallel
✅ Tests should be processed parallel without failure

✅ Obsolete step should cause different behaviors based on configuration(obsoleteBehavior: "Error", succeededCount: "0", failedCount: "1", pendingCount: "0", exampleTags: [])
✅ Obsolete step should cause different behaviors based on configuration(obsoleteBehavior: "None", succeededCount: "1", failedCount: "0", pendingCount: "0", exampleTags: [])
✅ Obsolete step should cause different behaviors based on configuration(obsoleteBehavior: "Pending", succeededCount: "0", failedCount: "0", pendingCount: "1", exampleTags: [])
✅ Obsolete step should cause different behaviors based on configuration(obsoleteBehavior: "Warn", succeededCount: "1", failedCount: "0", pendingCount: "0", exampleTags: [])
✅ Obsolete step should have default warning message
✅ Obsolete step should use Obsolete Attribute message if present

✅ Should be able to execute backgrounds from multiple Rules
✅ Should be able to execute scenarios in Rules that have backgrounds

✅ Should handle scenario outlines(case: "Normal testing", rowTest: "disabled", exampleTags: [])
✅ Should handle scenario outlines(case: "Row testing", rowTest: "enabled", exampleTags: [])
✅ Should support defining scenario outlines with the Scenario keyword

✅ More scope matches have higher precedency
✅ No ambiguouity if the same method matches with multiple scopes
✅ Scoped matches have higher precedency
✅ Scopes can be conbined with AND
✅ Scopes can be conbined with OR
✅ Scoping step definitions of a binding class
✅ Scoping step definitions to features
✅ Scoping step definitions to scenarios
✅ Scoping step definitions to tags

✅ Multi-line text arguments can be converted
✅ Should be able to convert step arguments to simple .NET types
✅ Should be able to convert steps arguments to arbritrary class instances
✅ Should be able to convert when multiple converters are returning the same target type: non string and Table
✅ Should be able to convert when multiple converters are returning the same target type: string and Table

✅ F# method name can be used as a regex(case: "basic regex ops", method: "``I do something .* important``()", exampleTags: [])
✅ F# method name can be used as a regex(case: "non-regex method name", method: "When_I_do_something_really_important()", exampleTags: [])
✅ F# method name can be used as a regex(case: "parameter", method: "``I do something (.*) important``(howMuch: string)", exampleTags: [])
✅ F# method name can be used as a regex(case: "simple", method: "``I do something really important``()", exampleTags: [])
✅ Keyword prefix can be omitted
✅ Non-English keywords(case: "English prefix", keyword: "Angenommen", methodPrefix: "Given_", exampleTags: [])
✅ Non-English keywords(case: "Mixed keyword variants", keyword: "Gegeben sei", methodPrefix: "Angenommen_", exampleTags: [])
✅ Non-English keywords(case: "Multiple word licalized prefix", keyword: "Gegeben sei", methodPrefix: "Gegeben_sei_", exampleTags: [])
✅ Non-English keywords(case: "No prefix", keyword: "Angenommen", methodPrefix: "", exampleTags: [])
✅ Non-English keywords(case: "Single word licalized prefix", keyword: "Angenommen", methodPrefix: "Angenommen_", exampleTags: [])
✅ Parameterless steps
✅ Pascal case methods(case: "embedded param", method: "WhenIDoSomethingHOWMUCHImportant", exampleTags: [])
✅ Pascal case methods(case: "param with underscore", method: "WhenIDoSomething_HOWMUCH_Important", exampleTags: [])
✅ Steps with parameters referred by index
✅ Steps with parameters(case: "apostrophed", parameter: "'Joe'", exampleTags: [])
✅ Steps with parameters(case: "quoted", parameter: "\"Joe\"", exampleTags: [])
✅ Steps with parameters(case: "simple", parameter: "Joe", exampleTags: [])
✅ Supports all attributes(attribute: "Given", step: "Given", exampleTags: [])
✅ Supports all attributes(attribute: "StepDefinition", step: "Given", exampleTags: [])
✅ Supports all attributes(attribute: "Then", step: "Then", exampleTags: [])
✅ Supports all attributes(attribute: "When", step: "When", exampleTags: [])
✅ Supports punctuation

✅ Examples can be ignored
✅ Examples can be tagged
✅ Scenario Outline Examples can be tagged

✅ Preserves step keywords in trace
✅ ReflectionTypeLoaderException in a static constructor
✅ ReflectionTypeLoaderException in a step binding

✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "AfterFeature", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "AfterScenario", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "AfterScenarioBlock", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "AfterStep", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "BeforeFeature", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "BeforeScenario", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "BeforeScenarioBlock", count: "0", exampleTags: [])
✅ For ignored Features no Feature Hooks (and no Scenario hooks) are called(event: "BeforeStep", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "AfterScenario", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "AfterScenarioBlock", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "AfterStep", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "BeforeScenario", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "BeforeScenarioBlock", count: "0", exampleTags: [])
✅ For ignored Scenarios no Scenario Hooks are called(event: "BeforeStep", count: "0", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "After", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "AfterFeature", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "AfterScenario", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "AfterScenarioBlock", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "AfterStep", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "AfterTestRun", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "Before", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "BeforeFeature", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "BeforeScenario", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "BeforeScenarioBlock", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "BeforeStep", exampleTags: [])
✅ Hooks should be executed if they take longer (>100ms)(event: "BeforeTestRun", exampleTags: [])
✅ Should execute Reqnroll events(event: "After", exampleTags: [])
✅ Should execute Reqnroll events(event: "AfterFeature", exampleTags: [])
✅ Should execute Reqnroll events(event: "AfterScenario", exampleTags: [])
✅ Should execute Reqnroll events(event: "AfterScenarioBlock", exampleTags: [])
✅ Should execute Reqnroll events(event: "AfterStep", exampleTags: [])
✅ Should execute Reqnroll events(event: "AfterTestRun", exampleTags: [])
✅ Should execute Reqnroll events(event: "Before", exampleTags: [])
✅ Should execute Reqnroll events(event: "BeforeFeature", exampleTags: [])
✅ Should execute Reqnroll events(event: "BeforeScenario", exampleTags: [])
✅ Should execute Reqnroll events(event: "BeforeScenarioBlock", exampleTags: [])
✅ Should execute Reqnroll events(event: "BeforeStep", exampleTags: [])
✅ Should execute Reqnroll events(event: "BeforeTestRun", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "After", count: "3", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "AfterFeature", count: "2", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "AfterScenario", count: "3", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "AfterScenarioBlock", count: "9", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "AfterStep", count: "18", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "AfterTestRun", count: "1", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "Before", count: "3", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "BeforeFeature", count: "2", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "BeforeScenario", count: "3", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "BeforeScenarioBlock", count: "9", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "BeforeStep", count: "18", exampleTags: [])
✅ Should execute the hooks according to their semantics(event: "BeforeTestRun", count: "1", exampleTags: [])

✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "After", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "AfterFeature", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "AfterScenario", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "AfterScenarioBlock", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "AfterStep", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "Before", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "BeforeFeature", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "BeforeScenario", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "BeforeScenarioBlock", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "BeforeStep", exampleTags: [])
✅ Should execute 'Before*' Reqnroll events in the correct order, ie lowest numbers first(eventType: "BeforeTestRun", exampleTags: [])

✅ Should set the TestExecution status to TestError when a BeforeScenario hook throw
✅ Steps should be executed as skipped after a BeforeScenario hook throws
✅ Subsequent AfterScenario hooks are not executed after an error
✅ Subsequent BeforeScenario hooks are not executed after an error

✅ Should be able to access FeatureContext in BeforeFeature/AfterFeature hooks as parameter
✅ Should be able to access ScenarioContext in BeforeScenario/AfterScenario hooks as parameter
✅ Should be able to access thread level and global services in BeforeTestRun/AfterTestRun hooks as parameter

✅ One hook is called once
✅ One hook scoped on HookAttribute with two tags are executed once
✅ One hook with two tags and [Scope] scoping are executed once
✅ Two hooks for different events are called once each
✅ Two hooks for the same event are called once each
✅ Two hooks for the same event with same name but in different classes are called once each

✅ Two projects with the same unit test provider(buildTool: "dotnet build", exampleTags: [])
✅ Two projects with the same unit test provider(buildTool: "dotnet msbuild", exampleTags: [])

✅ Should be able to execute a simple passing scenario

✅ GH2571

✅ GH1052

✅ Build Error when using the SingleFileGenerator and Reqnroll.Tools.MSBuild.Generator

✅ Should be able to deploy files
✅ Should be able to deploy files to specific folder

✅ Should be able to access TestContext in BeforeTestRun/AfterTestRun hooks
✅ Should be able to access TestContext in Steps