无需单元测试框架，如何基于自有测试框架使用Specflow实现Gherkin风格物理系统测试？

Great question—this is definitely a niche use case, but SpecFlow does offer ways to make this work without building a full custom source generator from scratch. Here's how to adapt it to your workflow:

1. Leverage SpecFlow's Custom Test Generator #

SpecFlow's default behavior generates code tailored for xUnit/NUnit/MSTest, but it lets you replace the test generation logic entirely. This is the key to decoupling it from unit testing frameworks.

You'll need to:

• Create a class that implements ITestGenerator (or inherit from the default TestGenerator to override specific parts)
• Configure SpecFlow to use this custom generator via your specflow.json or build-time configuration

The goal here is to generate test classes that fit your custom framework's requirements—for example, classes that implement an ICustomTestCase interface your framework recognizes, or methods that directly report results to your framework's API instead of using unit test attributes like [Fact] or [Test].

2. Write Gherkin and Step Definitions as Usual #

Keep your existing workflow for writing feature files and step bindings:

• Gherkin Feature File:

  Feature: Valve Operation Tests
    Scenario: Opening the valve triggers sensor threshold
      Given that the machine is in base state
      When we open the valve
      Then the valve sensor should have value higher than 450
  

• Step Definitions:
  Keep using SpecFlow's [Given], [When], [Then] attributes to bind your Gherkin steps to code—this is how SpecFlow maps plain text to your system interactions. Your existing step code works perfectly here:

  [Binding]
  public class ValveStepDefinitions
  {
      private readonly Machine _machine = new Machine();
      public List<ValueResult> testResults = new();
  
      [Given("that the machine is in base state")]
      public void MachineInBaseState() { 
          _machine.GoToBaseState(); 
      } 
  
      [When("we open the valve")]
      public void OpenValve() { 
          _machine.SetValve(true); 
      } 
  
      [Then("the valve sensor should have value higher than (\\d+)")]
      public void CheckValveSensorPosition(int valueToCheckAgainst) { 
          testResults.Add(new ValueResult(
              value: _machine.GetSensorValue(),
              min: valueToCheckAgainst,
              max: double.NaN
          )); 
      }
  }
  

3. Customize the Generated Test Code #

Your custom generator will output code that executes the step sequence and integrates with your framework. For example, instead of generating a unit test method with [Fact], you might generate something like:

public class ValveOperationTests : ICustomTestCase
{
    private readonly ValveStepDefinitions _steps = new();

    public void Execute()
    {
        // Execute the bound steps in order
        _steps.MachineInBaseState();
        _steps.OpenValve();
        _steps.CheckValveSensorPosition(450);
        
        // Submit results to your custom framework
        CustomTestFramework.ReportResults(_steps.testResults);
    }
}

This class implements an interface your GUI-based framework can scan for and execute, with no ties to unit testing libraries.

4. Integrate into Your Build Pipeline #

Use the SpecFlow.Tools.MsBuild.Generation NuGet package to trigger code generation during your project build. Configure your build to use your custom generator instead of the default one—you can do this by adding a custom GeneratorPlugin to your solution or modifying the MSBuild properties in your project file.

This way, every time you build, SpecFlow parses your Gherkin files, binds them to your step definitions, and generates framework-compatible test classes automatically.

Why This Beats a Custom Source Generator #

This approach reuses all of SpecFlow's hard work: Gherkin parsing, step binding matching, and scenario validation. You only need to tweak the final code output, which saves you from building a full Gherkin parser and binding system from scratch.

内容的提问来源于stack exchange，提问作者Foitn