separate typeinfo and testclass interfaces to avoid hack

gasparnagy · gasparnagy · commit 9ff9a4c3ed36 · 2018-05-25T09:14:45.000+02:00
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Framework/SpecFlowTestDiscoverer.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Framework/SpecFlowTestDiscoverer.cs
@@ -10,7 +10,7 @@ namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.Framework
     public class SpecFlowTestDiscoverer : XunitTestFrameworkDiscoverer
     {
         public SpecFlowTestDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) :
-            base(CreateSpecFlowProjectAssemblyInfo(assemblyInfo), sourceProvider, diagnosticMessageSink)
+            base(CreateSpecFlowProjectAssemblyInfo(assemblyInfo), sourceProvider, diagnosticMessageSink, collectionFactory)
         {
         }
 
@@ -21,18 +21,21 @@ private static SpecFlowProjectAssemblyInfo CreateSpecFlowProjectAssemblyInfo(IAs
             return new SpecFlowProjectAssemblyInfo(assemblyInfo);
         }
 
-        private bool IsSpecFlowTest(object test)
+        private bool IsSpecFlowTypeInfo(ITypeInfo typeInfo)
         {
-            return test is SpecFlowFeatureTestClass;
+            return typeInfo is SpecFlowFeatureTypeInfo;
+        }
+
+        private bool IsSpecFlowTest(ITestClass testClass)
+        {
+            return testClass is SpecFlowFeatureTestClass;
         }
 
         protected override ITestClass CreateTestClass(ITypeInfo typeInfo)
         {
-            if (IsSpecFlowTest(typeInfo))
+            if (IsSpecFlowTypeInfo(typeInfo))
             {
-                //TODO: return (ITestClass)new SpecFlowTestClass(this.TestCollectionFactory.Get(typeInfo), typeInfo);
-                ((SpecFlowFeatureTestClass)typeInfo).Hack_SetTestCollection(this.TestCollectionFactory.Get(typeInfo));
-                return (ITestClass) typeInfo;
+                return new SpecFlowFeatureTestClass(TestCollectionFactory.Get(typeInfo), typeInfo);
             }
             return base.CreateTestClass(typeInfo);
         }
@@ -43,11 +46,11 @@ protected override bool FindTestsForType(ITestClass testClass, bool includeSourc
             if (!IsSpecFlowTest(testClass))
                 return base.FindTestsForType(testClass, includeSourceInformation, messageBus, discoveryOptions);
 
-            var featureTestClass = (SpecFlowFeatureTestClass)testClass;
-            var gherkinDocument = featureTestClass.GetDocument();
+            var featureTestClass = ((SpecFlowFeatureTestClass)testClass);
+            var gherkinDocument = featureTestClass.FeatureTypeInfo.GetDocument();
             if (gherkinDocument?.SpecFlowFeature != null)
             {
-                featureTestClass.FeatureName = gherkinDocument.SpecFlowFeature.Name;
+                featureTestClass.FeatureTypeInfo.FeatureName = gherkinDocument.SpecFlowFeature.Name;
                 var featureTags = gherkinDocument.SpecFlowFeature.Tags.GetTags().ToArray();
                 foreach (var scenarioDefinition in gherkinDocument.SpecFlowFeature.ScenarioDefinitions.Where(sd => !(sd is Background)))
                 {
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Framework/SpecFlowTestFramework.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Framework/SpecFlowTestFramework.cs
@@ -2,6 +2,7 @@
 using Xunit.Abstractions;
 using Xunit.Sdk;
 
+// ReSharper disable once CheckNamespace
 namespace SpecFlow.xUnitAdapter.SpecFlowPlugin
 {
     public class SpecFlowTestFramework : XunitTestFramework
@@ -10,14 +11,10 @@ public SpecFlowTestFramework(IMessageSink diagnosticMessageSink) : base(diagnost
         {
         }
 
+        // we only override the discoverer, we can use the built-in executor as it is anyway delegates the actual exectution to the test cases (ScenarioTestCase)
         protected override ITestFrameworkDiscoverer CreateDiscoverer(IAssemblyInfo assemblyInfo)
         {
             return new SpecFlowTestDiscoverer(assemblyInfo, SourceInformationProvider, DiagnosticMessageSink);
         }
-
-        //protected override ITestFrameworkExecutor CreateExecutor(AssemblyName assemblyName)
-        //{
-        //    return new SpecFlowTestFrameworkExecutor(assemblyName, SourceInformationProvider, DiagnosticMessageSink);
-        //}
     }
-}
+}
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Runners/ScenarioTestCaseRunner.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/Runners/ScenarioTestCaseRunner.cs
@@ -30,7 +30,7 @@ public void FeatureSetup(GherkinDocument gherkinDocument)
             Debug.Assert(gherkinDocument.Feature != null);
             var feature = gherkinDocument.Feature;
 
-            var assembly = Assembly.LoadFrom(TestCase.FeatureFile.SpecFlowProject.AssemblyPath);
+            var assembly = Assembly.LoadFrom(TestCase.FeatureTypeInfo.SpecFlowProject.AssemblyPath);
             testRunner = TestRunnerManager.GetTestRunner(assembly);
             var featureInfo = new FeatureInfo(GetFeatureCulture(feature.Language), feature.Name, feature.Description, ProgrammingLanguage.CSharp, feature.Tags.GetTags().ToArray());
             testRunner.OnFeatureStart(featureInfo);
@@ -79,7 +79,7 @@ protected override async Task<RunSummary> RunTestAsync()
             var summary = new RunSummary() { Total = 1 };
             string output = "";
 
-            var gherkinDocument = await this.TestCase.FeatureFile.GetDocumentAsync();
+            var gherkinDocument = await this.TestCase.FeatureTypeInfo.GetDocumentAsync();
 
 
             Scenario scenario = null;
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/SpecFlow.xUnitAdapter.SpecFlowPlugin.csproj b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/SpecFlow.xUnitAdapter.SpecFlowPlugin.csproj
@@ -79,8 +79,9 @@
   <ItemGroup>
     <Compile Include="Runners\XUnitTraceListener.cs" />
     <Compile Include="TestArtifacts\SpecFlowFeatureTestClass.cs" />
-    <Compile Include="TestArtifacts\EmbeddedFeatureFileTestClass.cs" />
-    <Compile Include="TestArtifacts\FeatureFileTestClass.cs" />
+    <Compile Include="TestArtifacts\SpecFlowFeatureTypeInfo.cs" />
+    <Compile Include="TestArtifacts\EmbeddedFeatureTypeInfo.cs" />
+    <Compile Include="TestArtifacts\FeatureFileTypeInfo.cs" />
     <Compile Include="Runners\ScenarioTestCaseRunner.cs" />
     <Compile Include="TestArtifacts\SpecFlowGenericFixtureType.cs" />
     <Compile Include="SpecFlowParserHelper.cs" />
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/EmbeddedFeatureTypeInfo.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/EmbeddedFeatureTypeInfo.cs
@@ -5,14 +5,13 @@
 
 namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts
 {
-    public class EmbeddedFeatureFileTestClass : SpecFlowFeatureTestClass
+    public class EmbeddedFeatureTypeInfo : SpecFlowFeatureTypeInfo
     {
-        public EmbeddedFeatureFileTestClass()
-            : base()
+        public EmbeddedFeatureTypeInfo()
         {
         }
 
-        public EmbeddedFeatureFileTestClass(SpecFlowProjectAssemblyInfo specFlowProject, string resourceName)
+        public EmbeddedFeatureTypeInfo(SpecFlowProjectAssemblyInfo specFlowProject, string resourceName)
             : base(specFlowProject, resourceName)
         {
         }
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/FeatureFileTypeInfo.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/FeatureFileTypeInfo.cs
@@ -5,13 +5,13 @@
 
 namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts
 {
-    public class FeatureFileTestClass : SpecFlowFeatureTestClass
+    public class FeatureFileTypeInfo : SpecFlowFeatureTypeInfo
     {
-        public FeatureFileTestClass()
+        public FeatureFileTypeInfo()
         {
         }
 
-        public FeatureFileTestClass(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)
+        public FeatureFileTypeInfo(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)
             : base(specFlowProject, relativePath)
         {
         }
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/ScenarioTestCase.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/ScenarioTestCase.cs
@@ -14,11 +14,12 @@ namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts
 {
     public class ScenarioTestCase : LongLivedMarshalByRefObject, ITestMethod, IXunitTestCase, IReflectionMethodInfo
     {
-        public SpecFlowFeatureTestClass FeatureFile { get; private set; }
+        public SpecFlowFeatureTestClass FeatureTestClass { get; private set; }
+        public SpecFlowFeatureTypeInfo FeatureTypeInfo => FeatureTestClass.FeatureTypeInfo;
         public string Name { get; private set; }
 
         public string DisplayName => GetDisplayName();
-        public string UniqueID => $"{FeatureFile.RelativePath};{Name};{ExampleId}";
+        public string UniqueID => $"{FeatureTypeInfo.RelativePath};{Name};{ExampleId}";
 
         public ISourceInformation SourceInformation { get; set; }
         public string SkipReason { get; set; }
@@ -29,7 +30,7 @@ public class ScenarioTestCase : LongLivedMarshalByRefObject, ITestMethod, IXunit
         public bool IsScenarioOutline => !string.IsNullOrEmpty(ExampleId);
 
         object[] ITestCase.TestMethodArguments => ScenarioOutlineParameters?.Cast<object>().ToArray();
-        public ITestClass TestClass => FeatureFile;
+        public ITestClass TestClass => FeatureTestClass;
         public ITestMethod TestMethod => this;
         public IMethodInfo Method => this;
 
@@ -40,9 +41,9 @@ public ScenarioTestCase()
 
         private ScenarioTestCase(SpecFlowFeatureTestClass featureTestClass, ScenarioDefinition scenario, string[] featureTags, Location location)
         {
-            FeatureFile = featureTestClass;
+            FeatureTestClass = featureTestClass;
             Name = scenario.Name;
-            SourceInformation = new SourceInformation { FileName = featureTestClass.FeatureFilePath, LineNumber = location?.Line };
+            SourceInformation = new SourceInformation { FileName = FeatureTypeInfo.FeatureFilePath, LineNumber = location?.Line };
             Traits = new Dictionary<string, List<string>>();
             Traits.Add("Category", featureTags.Concat(((IHasTags)scenario).Tags.GetTags()).ToList());
         }
@@ -70,14 +71,14 @@ private string GetDisplayName()
 
         public void Deserialize(IXunitSerializationInfo data)
         {
-            FeatureFile = data.GetValue<SpecFlowFeatureTestClass>("FeatureFile");
+            FeatureTestClass = data.GetValue<SpecFlowFeatureTestClass>("FeatureTestClass");
             Name = data.GetValue<string>("Name");
             ExampleId = data.GetValue<string>("ExampleId");
         }
 
         public void Serialize(IXunitSerializationInfo data)
         {
-            data.AddValue("FeatureFile", FeatureFile);
+            data.AddValue("FeatureTestClass", FeatureTestClass);
             data.AddValue("Name", Name);
             data.AddValue("ExampleId", ExampleId);
         }
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowFeatureTestClass.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowFeatureTestClass.cs
@@ -1,84 +1,48 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using TechTalk.SpecFlow.Parser;
+﻿using System;
 using Xunit;
 using Xunit.Abstractions;
-using Xunit.Sdk;
 
 namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts
 {
-    public abstract class SpecFlowFeatureTestClass : LongLivedMarshalByRefObject, ITypeInfo, IReflectionTypeInfo, ITestClass
+    public class SpecFlowFeatureTestClass : LongLivedMarshalByRefObject, ITestClass
     {
-        public string FeatureName { get; set; }
-        public string RelativePath { get; private set; }
-        public SpecFlowProjectAssemblyInfo SpecFlowProject { get; private set; }
-
-        public virtual string FeatureFilePath { get; protected set; }
-
-        IAssemblyInfo ITypeInfo.Assembly => SpecFlowProject;
-        string ITypeInfo.Name => (FeatureName ?? RelativePath).Replace(".", "");
-        Type IReflectionTypeInfo.Type { get { return typeof(SpecFlowGenericFixtureType); } }
-
-        public ITypeInfo Class => this;
+        public ITypeInfo Class { get; private set; }
         public ITestCollection TestCollection { get; private set; }
 
-        #region ITypeInfo default implementation
-        IEnumerable<IAttributeInfo> ITypeInfo.GetCustomAttributes(string assemblyQualifiedAttributeTypeName) => Enumerable.Empty<IAttributeInfo>();
-        IEnumerable<ITypeInfo> ITypeInfo.GetGenericArguments() => Enumerable.Empty<ITypeInfo>();
-        IMethodInfo ITypeInfo.GetMethod(string methodName, bool includePrivateMethod) => null;
-        IEnumerable<IMethodInfo> ITypeInfo.GetMethods(bool includePrivateMethods) => Enumerable.Empty<IMethodInfo>();
-        ITypeInfo ITypeInfo.BaseType => null;
-        IEnumerable<ITypeInfo> ITypeInfo.Interfaces => Enumerable.Empty<ITypeInfo>();
-        bool ITypeInfo.IsAbstract => false;
-        bool ITypeInfo.IsGenericParameter => false;
-        bool ITypeInfo.IsGenericType => false;
-        bool ITypeInfo.IsSealed => false;
-        bool ITypeInfo.IsValueType => false;
-        #endregion
-
-        protected SpecFlowFeatureTestClass() { }
+        public SpecFlowFeatureTypeInfo FeatureTypeInfo => (SpecFlowFeatureTypeInfo)Class;
 
-        protected SpecFlowFeatureTestClass(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)
+        [Obsolete("Called by the de-serializer; should only be called by deriving classes for de-serialization purposes")]
+        public SpecFlowFeatureTestClass()
         {
-            SpecFlowProject = specFlowProject;
-            RelativePath = relativePath;
         }
 
-        internal void Hack_SetTestCollection(ITestCollection testCollection)
+        public SpecFlowFeatureTestClass(ITestCollection testCollection, ITypeInfo typeInfo)
         {
-            TestCollection = testCollection;
-        }
-
-        protected ISpecFlowSourceMapper SpecFlowSourceMapper { get; } = new SpecFlowSourceMapperV1();
+            if (!(typeInfo is SpecFlowFeatureTypeInfo))
+                throw new ArgumentException($"Must me an instance of {nameof(SpecFlowFeatureTypeInfo)}", "typeInfo");
 
-        public virtual void Deserialize(IXunitSerializationInfo data)
-        {
-            SpecFlowProject = data.GetValue<SpecFlowProjectAssemblyInfo>("SpecFlowProject");
-            RelativePath = data.GetValue<string>("RelativePath");
-            TestCollection = data.GetValue<ITestCollection>("TestCollection");
+            TestCollection = testCollection;
+            Class = typeInfo;
         }
 
-        public virtual void Serialize(IXunitSerializationInfo data)
+        public void Serialize(IXunitSerializationInfo info)
         {
-            data.AddValue("SpecFlowProject", SpecFlowProject);
-            data.AddValue("RelativePath", RelativePath);
-            data.AddValue("TestCollection", TestCollection);
+            info.AddValue("TestCollection", TestCollection);
+            info.AddValue("SpecFlowProject", FeatureTypeInfo.SpecFlowProject);
+            info.AddValue("RelativePath", FeatureTypeInfo.RelativePath);
+            info.AddValue("TypeInfoKind", Class.GetType().Name);
         }
 
-        protected SpecFlowDocument ParseDocument(string content, string path, SpecFlowGherkinParser parser)
+        public void Deserialize(IXunitSerializationInfo info)
         {
-            var sourceMap = this.SpecFlowSourceMapper.ReadSourceMap(content);
-
-            this.FeatureFilePath = sourceMap?.SourcePath ?? path;
-
-            return parser.Parse(new StringReader(content), this.FeatureFilePath);
+            TestCollection = info.GetValue<ITestCollection>("TestCollection");
+            var specFlowProject = info.GetValue<SpecFlowProjectAssemblyInfo>("SpecFlowProject");
+            var relativePath = info.GetValue<string>("RelativePath");
+            var typeInfoKind = info.GetValue<string>("TypeInfoKind");
+            if (typeInfoKind == nameof(FeatureFileTypeInfo))
+                Class = new FeatureFileTypeInfo(specFlowProject, relativePath);
+            else if (typeInfoKind == nameof(EmbeddedFeatureTypeInfo))
+                Class = new EmbeddedFeatureTypeInfo(specFlowProject, relativePath);
         }
-
-        public abstract SpecFlowDocument GetDocument();
-
-        public abstract Task<SpecFlowDocument> GetDocumentAsync();
     }
 }
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowFeatureTypeInfo.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowFeatureTypeInfo.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using TechTalk.SpecFlow.Parser;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts
+{
+    public abstract class SpecFlowFeatureTypeInfo : LongLivedMarshalByRefObject, ITypeInfo, IReflectionTypeInfo
+    {
+        public string FeatureName { get; set; }
+        public string RelativePath { get; }
+        public SpecFlowProjectAssemblyInfo SpecFlowProject { get; }
+
+        public virtual string FeatureFilePath { get; protected set; }
+
+        IAssemblyInfo ITypeInfo.Assembly => SpecFlowProject;
+        string ITypeInfo.Name => (FeatureName ?? RelativePath).Replace(".", "");
+        Type IReflectionTypeInfo.Type => typeof(SpecFlowGenericFixtureType);
+
+        #region ITypeInfo default implementation
+        IEnumerable<IAttributeInfo> ITypeInfo.GetCustomAttributes(string assemblyQualifiedAttributeTypeName) => Enumerable.Empty<IAttributeInfo>();
+        IEnumerable<ITypeInfo> ITypeInfo.GetGenericArguments() => Enumerable.Empty<ITypeInfo>();
+        IMethodInfo ITypeInfo.GetMethod(string methodName, bool includePrivateMethod) => null;
+        IEnumerable<IMethodInfo> ITypeInfo.GetMethods(bool includePrivateMethods) => Enumerable.Empty<IMethodInfo>();
+        ITypeInfo ITypeInfo.BaseType => null;
+        IEnumerable<ITypeInfo> ITypeInfo.Interfaces => Enumerable.Empty<ITypeInfo>();
+        bool ITypeInfo.IsAbstract => false;
+        bool ITypeInfo.IsGenericParameter => false;
+        bool ITypeInfo.IsGenericType => false;
+        bool ITypeInfo.IsSealed => false;
+        bool ITypeInfo.IsValueType => false;
+        #endregion
+
+        protected SpecFlowFeatureTypeInfo() { }
+
+        protected SpecFlowFeatureTypeInfo(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)
+        {
+            SpecFlowProject = specFlowProject;
+            RelativePath = relativePath;
+        }
+
+        protected ISpecFlowSourceMapper SpecFlowSourceMapper { get; } = new SpecFlowSourceMapperV1();
+
+        protected SpecFlowDocument ParseDocument(string content, string path, SpecFlowGherkinParser parser)
+        {
+            var sourceMap = this.SpecFlowSourceMapper.ReadSourceMap(content);
+
+            this.FeatureFilePath = sourceMap?.SourcePath ?? path;
+
+            return parser.Parse(new StringReader(content), this.FeatureFilePath);
+        }
+
+        public abstract SpecFlowDocument GetDocument();
+
+        public abstract Task<SpecFlowDocument> GetDocumentAsync();
+    }
+}
diff --git a/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowProjectAssemblyInfo.cs b/src/SpecFlow.xUnitAdapter.SpecFlowPlugin/TestArtifacts/SpecFlowProjectAssemblyInfo.cs
@@ -43,15 +43,15 @@ public IEnumerable<ITypeInfo> GetTypes(bool includePrivateTypes)
             foreach (var resourceName in assembly.GetManifestResourceNames().Where(x => x.EndsWith(".feature")))
             {
                 Console.WriteLine($"      {resourceName}");
-                yield return new EmbeddedFeatureFileTestClass(this, resourceName);
+                yield return new EmbeddedFeatureTypeInfo(this, resourceName);
             }
 
             Console.WriteLine($"    Discovering feature files from folder {FeatureFilesFolder}");
             foreach (var featureFilePath in Directory.GetFiles(FeatureFilesFolder, "*.feature", SearchOption.AllDirectories))
             {
                 var relativePath = featureFilePath.Substring(FeatureFilesFolder.Length).TrimStart(Path.DirectorySeparatorChar);
                 Console.WriteLine($"      {relativePath}");
-                yield return new FeatureFileTestClass(this, relativePath);
+                yield return new FeatureFileTypeInfo(this, relativePath);
             }
 
             // discovering "standard" xunit tests to allow incremental transition from the generated style to the new style

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.Framework`
`10`	`10`	`public class SpecFlowTestDiscoverer : XunitTestFrameworkDiscoverer`
`11`	`11`	`{`
`12`	`12`	`public SpecFlowTestDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) :`
`13`		`- base(CreateSpecFlowProjectAssemblyInfo(assemblyInfo), sourceProvider, diagnosticMessageSink)`
	`13`	`+ base(CreateSpecFlowProjectAssemblyInfo(assemblyInfo), sourceProvider, diagnosticMessageSink, collectionFactory)`
`14`	`14`	`{`
`15`	`15`	`}`
`16`	`16`
`@@ -21,18 +21,21 @@ private static SpecFlowProjectAssemblyInfo CreateSpecFlowProjectAssemblyInfo(IAs`
`21`	`21`	`return new SpecFlowProjectAssemblyInfo(assemblyInfo);`
`22`	`22`	`}`
`23`	`23`
`24`		`- private bool IsSpecFlowTest(object test)`
	`24`	`+ private bool IsSpecFlowTypeInfo(ITypeInfo typeInfo)`
`25`	`25`	`{`
`26`		`- return test is SpecFlowFeatureTestClass;`
	`26`	`+ return typeInfo is SpecFlowFeatureTypeInfo;`
	`27`	`+ }`
	`28`	`+`
	`29`	`+ private bool IsSpecFlowTest(ITestClass testClass)`
	`30`	`+ {`
	`31`	`+ return testClass is SpecFlowFeatureTestClass;`
`27`	`32`	`}`
`28`	`33`
`29`	`34`	`protected override ITestClass CreateTestClass(ITypeInfo typeInfo)`
`30`	`35`	`{`
`31`		`- if (IsSpecFlowTest(typeInfo))`
	`36`	`+ if (IsSpecFlowTypeInfo(typeInfo))`
`32`	`37`	`{`
`33`		`- //TODO: return (ITestClass)new SpecFlowTestClass(this.TestCollectionFactory.Get(typeInfo), typeInfo);`
`34`		`- ((SpecFlowFeatureTestClass)typeInfo).Hack_SetTestCollection(this.TestCollectionFactory.Get(typeInfo));`
`35`		`- return (ITestClass) typeInfo;`
	`38`	`+ return new SpecFlowFeatureTestClass(TestCollectionFactory.Get(typeInfo), typeInfo);`
`36`	`39`	`}`
`37`	`40`	`return base.CreateTestClass(typeInfo);`
`38`	`41`	`}`
`@@ -43,11 +46,11 @@ protected override bool FindTestsForType(ITestClass testClass, bool includeSourc`
`43`	`46`	`if (!IsSpecFlowTest(testClass))`
`44`	`47`	`return base.FindTestsForType(testClass, includeSourceInformation, messageBus, discoveryOptions);`
`45`	`48`
`46`		`- var featureTestClass = (SpecFlowFeatureTestClass)testClass;`
`47`		`- var gherkinDocument = featureTestClass.GetDocument();`
	`49`	`+ var featureTestClass = ((SpecFlowFeatureTestClass)testClass);`
	`50`	`+ var gherkinDocument = featureTestClass.FeatureTypeInfo.GetDocument();`
`48`	`51`	`if (gherkinDocument?.SpecFlowFeature != null)`
`49`	`52`	`{`
`50`		`- featureTestClass.FeatureName = gherkinDocument.SpecFlowFeature.Name;`
	`53`	`+ featureTestClass.FeatureTypeInfo.FeatureName = gherkinDocument.SpecFlowFeature.Name;`
`51`	`54`	`var featureTags = gherkinDocument.SpecFlowFeature.Tags.GetTags().ToArray();`
`52`	`55`	`foreach (var scenarioDefinition in gherkinDocument.SpecFlowFeature.ScenarioDefinitions.Where(sd => !(sd is Background)))`
`53`	`56`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using Xunit.Abstractions;`
`3`	`3`	`using Xunit.Sdk;`
`4`	`4`
	`5`	`+// ReSharper disable once CheckNamespace`
`5`	`6`	`namespace SpecFlow.xUnitAdapter.SpecFlowPlugin`
`6`	`7`	`{`
`7`	`8`	`public class SpecFlowTestFramework : XunitTestFramework`
`@@ -10,14 +11,10 @@ public SpecFlowTestFramework(IMessageSink diagnosticMessageSink) : base(diagnost`
`10`	`11`	`{`
`11`	`12`	`}`
`12`	`13`
	`14`	`+ // we only override the discoverer, we can use the built-in executor as it is anyway delegates the actual exectution to the test cases (ScenarioTestCase)`
`13`	`15`	`protected override ITestFrameworkDiscoverer CreateDiscoverer(IAssemblyInfo assemblyInfo)`
`14`	`16`	`{`
`15`	`17`	`return new SpecFlowTestDiscoverer(assemblyInfo, SourceInformationProvider, DiagnosticMessageSink);`
`16`	`18`	`}`
`17`		`-`
`18`		`- //protected override ITestFrameworkExecutor CreateExecutor(AssemblyName assemblyName)`
`19`		`- //{`
`20`		`- // return new SpecFlowTestFrameworkExecutor(assemblyName, SourceInformationProvider, DiagnosticMessageSink);`
`21`		`- //}`
`22`	`19`	`}`
`23`		`-}`
	`20`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -5,14 +5,13 @@`
`5`	`5`
`6`	`6`	`namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts`
`7`	`7`	`{`
`8`		`- public class EmbeddedFeatureFileTestClass : SpecFlowFeatureTestClass`
	`8`	`+ public class EmbeddedFeatureTypeInfo : SpecFlowFeatureTypeInfo`
`9`	`9`	`{`
`10`		`- public EmbeddedFeatureFileTestClass()`
`11`		`- : base()`
	`10`	`+ public EmbeddedFeatureTypeInfo()`
`12`	`11`	`{`
`13`	`12`	`}`
`14`	`13`
`15`		`- public EmbeddedFeatureFileTestClass(SpecFlowProjectAssemblyInfo specFlowProject, string resourceName)`
	`14`	`+ public EmbeddedFeatureTypeInfo(SpecFlowProjectAssemblyInfo specFlowProject, string resourceName)`
`16`	`15`	`: base(specFlowProject, resourceName)`
`17`	`16`	`{`
`18`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`
`6`	`6`	`namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts`
`7`	`7`	`{`
`8`		`- public class FeatureFileTestClass : SpecFlowFeatureTestClass`
	`8`	`+ public class FeatureFileTypeInfo : SpecFlowFeatureTypeInfo`
`9`	`9`	`{`
`10`		`- public FeatureFileTestClass()`
	`10`	`+ public FeatureFileTypeInfo()`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`		`- public FeatureFileTestClass(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)`
	`14`	`+ public FeatureFileTypeInfo(SpecFlowProjectAssemblyInfo specFlowProject, string relativePath)`
`15`	`15`	`: base(specFlowProject, relativePath)`
`16`	`16`	`{`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,12 @@ namespace SpecFlow.xUnitAdapter.SpecFlowPlugin.TestArtifacts`
`14`	`14`	`{`
`15`	`15`	`public class ScenarioTestCase : LongLivedMarshalByRefObject, ITestMethod, IXunitTestCase, IReflectionMethodInfo`
`16`	`16`	`{`
`17`		`- public SpecFlowFeatureTestClass FeatureFile { get; private set; }`
	`17`	`+ public SpecFlowFeatureTestClass FeatureTestClass { get; private set; }`
	`18`	`+ public SpecFlowFeatureTypeInfo FeatureTypeInfo => FeatureTestClass.FeatureTypeInfo;`
`18`	`19`	`public string Name { get; private set; }`
`19`	`20`
`20`	`21`	`public string DisplayName => GetDisplayName();`
`21`		`- public string UniqueID => $"{FeatureFile.RelativePath};{Name};{ExampleId}";`
	`22`	`+ public string UniqueID => $"{FeatureTypeInfo.RelativePath};{Name};{ExampleId}";`
`22`	`23`
`23`	`24`	`public ISourceInformation SourceInformation { get; set; }`
`24`	`25`	`public string SkipReason { get; set; }`
`@@ -29,7 +30,7 @@ public class ScenarioTestCase : LongLivedMarshalByRefObject, ITestMethod, IXunit`
`29`	`30`	`public bool IsScenarioOutline => !string.IsNullOrEmpty(ExampleId);`
`30`	`31`
`31`	`32`	`object[] ITestCase.TestMethodArguments => ScenarioOutlineParameters?.Cast<object>().ToArray();`
`32`		`- public ITestClass TestClass => FeatureFile;`
	`33`	`+ public ITestClass TestClass => FeatureTestClass;`
`33`	`34`	`public ITestMethod TestMethod => this;`
`34`	`35`	`public IMethodInfo Method => this;`
`35`	`36`
`@@ -40,9 +41,9 @@ public ScenarioTestCase()`
`40`	`41`
`41`	`42`	`private ScenarioTestCase(SpecFlowFeatureTestClass featureTestClass, ScenarioDefinition scenario, string[] featureTags, Location location)`
`42`	`43`	`{`
`43`		`- FeatureFile = featureTestClass;`
	`44`	`+ FeatureTestClass = featureTestClass;`
`44`	`45`	`Name = scenario.Name;`
`45`		`- SourceInformation = new SourceInformation { FileName = featureTestClass.FeatureFilePath, LineNumber = location?.Line };`
	`46`	`+ SourceInformation = new SourceInformation { FileName = FeatureTypeInfo.FeatureFilePath, LineNumber = location?.Line };`
`46`	`47`	`Traits = new Dictionary<string, List<string>>();`
`47`	`48`	`Traits.Add("Category", featureTags.Concat(((IHasTags)scenario).Tags.GetTags()).ToList());`
`48`	`49`	`}`
`@@ -70,14 +71,14 @@ private string GetDisplayName()`
`70`	`71`
`71`	`72`	`public void Deserialize(IXunitSerializationInfo data)`
`72`	`73`	`{`
`73`		`- FeatureFile = data.GetValue<SpecFlowFeatureTestClass>("FeatureFile");`
	`74`	`+ FeatureTestClass = data.GetValue<SpecFlowFeatureTestClass>("FeatureTestClass");`
`74`	`75`	`Name = data.GetValue<string>("Name");`
`75`	`76`	`ExampleId = data.GetValue<string>("ExampleId");`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`public void Serialize(IXunitSerializationInfo data)`
`79`	`80`	`{`
`80`		`- data.AddValue("FeatureFile", FeatureFile);`
	`81`	`+ data.AddValue("FeatureTestClass", FeatureTestClass);`
`81`	`82`	`data.AddValue("Name", Name);`
`82`	`83`	`data.AddValue("ExampleId", ExampleId);`
`83`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,15 @@ public IEnumerable<ITypeInfo> GetTypes(bool includePrivateTypes)`
`43`	`43`	`foreach (var resourceName in assembly.GetManifestResourceNames().Where(x => x.EndsWith(".feature")))`
`44`	`44`	`{`
`45`	`45`	`Console.WriteLine($" {resourceName}");`
`46`		`- yield return new EmbeddedFeatureFileTestClass(this, resourceName);`
	`46`	`+ yield return new EmbeddedFeatureTypeInfo(this, resourceName);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`Console.WriteLine($" Discovering feature files from folder {FeatureFilesFolder}");`
`50`	`50`	`foreach (var featureFilePath in Directory.GetFiles(FeatureFilesFolder, "*.feature", SearchOption.AllDirectories))`
`51`	`51`	`{`
`52`	`52`	`var relativePath = featureFilePath.Substring(FeatureFilesFolder.Length).TrimStart(Path.DirectorySeparatorChar);`
`53`	`53`	`Console.WriteLine($" {relativePath}");`
`54`		`- yield return new FeatureFileTestClass(this, relativePath);`
	`54`	`+ yield return new FeatureFileTypeInfo(this, relativePath);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`// discovering "standard" xunit tests to allow incremental transition from the generated style to the new style`