More flexible helpers for tests

Author: distantcam

src/AutoCtor.Tests/ExampleTests.cs

@@ -1,9 +1,6 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
-
-#if ROSLYN_4_4
 using Microsoft.CodeAnalysis.CSharp;
-#endif
 
 namespace AutoCtor.Tests;
 
@@ -13,11 +10,12 @@ public class ExampleTests
     [MemberData(nameof(GetExamples))]
     public async Task ExamplesGeneratedCode(CodeFileTheoryData theoryData)
     {
-        var compilation = await Helpers.Compile<AutoConstructAttribute>(theoryData.Codes,
-            langPreview: theoryData.LangPreview,
-            preprocessorSymbols: s_preprocessorSymbols);
-        var generator = new AutoConstructSourceGenerator().AsSourceGenerator();
-        var driver = Helpers.CreateDriver(theoryData.Options, theoryData.LangPreview, generator)
+        var builder = CreateCompilation(theoryData);
+        var compilation = await builder.Build(nameof(ExampleTests));
+        var driver = new GeneratorDriverBuilder()
+            .AddGenerator(new AutoConstructSourceGenerator())
+            .WithAnalyzerOptions(theoryData.Options)
+            .Build(builder.ParseOptions)
             .RunGenerators(compilation);
 
         await Verify(driver)
@@ -29,11 +27,12 @@ await Verify(driver)
     [MemberData(nameof(GetExamples))]
     public async Task CodeCompilesProperly(CodeFileTheoryData theoryData)
     {
-        var compilation = await Helpers.Compile<AutoConstructAttribute>(theoryData.Codes,
-            langPreview: theoryData.LangPreview,
-            preprocessorSymbols: s_preprocessorSymbols);
-        var generator = new AutoConstructSourceGenerator().AsSourceGenerator();
-        Helpers.CreateDriver(theoryData.Options, theoryData.LangPreview, generator)
+        var builder = CreateCompilation(theoryData);
+        var compilation = await builder.Build(nameof(ExampleTests));
+        new GeneratorDriverBuilder()
+            .AddGenerator(new AutoConstructSourceGenerator())
+            .WithAnalyzerOptions(theoryData.Options)
+            .Build(builder.ParseOptions)
             .RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _);
 
         Assert.Empty(outputCompilation.GetDiagnostics().Where(d => !theoryData.IgnoredCompileDiagnostics.Contains(d.Id)));
@@ -44,22 +43,27 @@ public async Task CodeCompilesProperly(CodeFileTheoryData theoryData)
     [MemberData(nameof(GetExamples))]
     public async Task EnsureRunsAreCachedCorrectly(CodeFileTheoryData theoryData)
     {
-        var compilation = await Helpers.Compile<AutoConstructAttribute>(theoryData.Codes,
-            langPreview: theoryData.LangPreview,
-            preprocessorSymbols: s_preprocessorSymbols);
-        var generator = new AutoConstructSourceGenerator().AsSourceGenerator();
+        var builder = CreateCompilation(theoryData);
+        var compilation = await builder.Build(nameof(ExampleTests));
+
+        var driver = new GeneratorDriverBuilder()
+            .AddGenerator(new AutoConstructSourceGenerator())
+            .WithAnalyzerOptions(theoryData.Options)
+            .Build(builder.ParseOptions);
 
-        var driver = Helpers.CreateDriver(theoryData.Options, theoryData.LangPreview, generator);
         driver = driver.RunGenerators(compilation);
         var firstResult = driver.GetRunResult();
+
+        // Change the compilation
         compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText("// dummy",
             CSharpParseOptions.Default.WithLanguageVersion(theoryData.LangPreview
                 ? LanguageVersion.Preview
                 : LanguageVersion.Latest)));
+
         driver = driver.RunGenerators(compilation);
         var secondResult = driver.GetRunResult();
 
-        Helpers.AssertRunsEqual(firstResult, secondResult,
+        AssertRunsEqual(firstResult, secondResult,
             AutoConstructSourceGenerator.TrackingNames.AllTrackers);
     }
 #endif
@@ -84,6 +88,22 @@ public async Task EnsureRunsAreCachedCorrectly(CodeFileTheoryData theoryData)
 #endif
     ];
 
+    private static CompilationBuilder CreateCompilation(CodeFileTheoryData theoryData)
+    {
+        var builder = new CompilationBuilder()
+            .AddNetCoreReference()
+            .AddAssemblyReference<AutoConstructAttribute>()
+            .WithPreprocessorSymbols(s_preprocessorSymbols)
+            .AddCodes(theoryData.Codes);
+
+        if (theoryData.LangPreview)
+        {
+            builder = builder.WithLanguageVersion(LanguageVersion.Preview);
+        }
+
+        return builder;
+    }
+
     private static DirectoryInfo? BaseDir { get; } = new DirectoryInfo(Environment.CurrentDirectory)?.Parent?.Parent;
 
     private static IEnumerable<string> GetExamplesFiles(string path) => Directory.GetFiles(Path.Combine(BaseDir?.FullName ?? "", path), "*.cs").Where(e => !e.Contains(".g."));
@@ -107,13 +127,13 @@ public static TheoryData<CodeFileTheoryData> GetExamples()
         {
             data.Add(new CodeFileTheoryData(guardExample) with
             {
-                Options = [new("build_property.AutoCtorGuards", "true")]
+                Options = new() { { "build_property.AutoCtorGuards", "true" } }
             });
         }
 
         foreach (var langExample in GetExamplesFiles("LangExamples"))
         {
-            var verifiedName = "Verified_" + s_preprocessorSymbols.Last().Substring(7);
+            var verifiedName = string.Concat("Verified_", s_preprocessorSymbols.Last().AsSpan(7));
             data.Add(new CodeFileTheoryData(langExample) with
             {
                 VerifiedDirectory = Path.Combine(Path.GetDirectoryName(langExample) ?? "", verifiedName),
@@ -123,4 +143,88 @@ public static TheoryData<CodeFileTheoryData> GetExamples()
 
         return data;
     }
+
+#if ROSLYN_4
+    private static void AssertRunsEqual(
+        GeneratorDriverRunResult runResult1,
+        GeneratorDriverRunResult runResult2,
+        IEnumerable<string> trackingNames)
+    {
+        // We're given all the tracking names, but not all the
+        // stages will necessarily execute, so extract all the
+        // output steps, and filter to ones we know about
+        var trackedSteps1 = GetTrackedSteps(runResult1, trackingNames);
+        var trackedSteps2 = GetTrackedSteps(runResult2, trackingNames);
+
+        // Both runs should have the same tracked steps
+        Assert.NotEmpty(trackedSteps1);
+        Assert.Equal(trackedSteps1.Count, trackedSteps2.Count);
+        Assert.Equal(trackedSteps1.Keys, trackedSteps2.Keys);
+
+        // Get the IncrementalGeneratorRunStep collection for each run
+        foreach (var (trackingName, runSteps1) in trackedSteps1)
+        {
+            // Assert that both runs produced the same outputs
+            var runSteps2 = trackedSteps2[trackingName];
+            AssertStepsEqual(runSteps1, runSteps2, trackingName);
+        }
+
+        return;
+
+        // Local function that extracts the tracked steps
+        static Dictionary<string, ImmutableArray<IncrementalGeneratorRunStep>> GetTrackedSteps(
+            GeneratorDriverRunResult runResult, IEnumerable<string> trackingNames)
+            => runResult
+                    .Results[0] // We're only running a single generator, so this is safe
+                    .TrackedSteps // Get the pipeline outputs
+                    .Where(step => trackingNames.Contains(step.Key)) // filter to known steps
+                    .ToDictionary(x => x.Key, x => x.Value); // Convert to a dictionary
+    }
+
+    private static void AssertStepsEqual(
+        ImmutableArray<IncrementalGeneratorRunStep> runSteps1,
+        ImmutableArray<IncrementalGeneratorRunStep> runSteps2,
+        string stepName)
+    {
+        Assert.Equal(runSteps1.Length, runSteps2.Length);
+
+        for (var i = 0; i < runSteps1.Length; i++)
+        {
+            var runStep1 = runSteps1[i];
+            var runStep2 = runSteps2[i];
+
+            // The outputs should be equal between different runs
+            var outputs1 = runStep1.Outputs.Select(x => x.Value);
+            var outputs2 = runStep2.Outputs.Select(x => x.Value);
+
+            WithMessage(() => Assert.Equal(outputs1, outputs2),
+                $"because step {stepName} should produce cacheable outputs");
+
+            // Therefore, on the second run the results should always be cached or unchanged!
+            // - Unchanged is when the _input_ has changed, but the output hasn't
+            // - Cached is when the the input has not changed, so the cached output is used
+            IEnumerable<IncrementalStepRunReason> acceptableReasons =
+                [IncrementalStepRunReason.Cached, IncrementalStepRunReason.Unchanged];
+            foreach (var step in runStep2.Outputs)
+            {
+                Assert.Contains(step.Reason, acceptableReasons);
+            }
+        }
+    }
+
+    private static void WithMessage(Action action, string message)
+    {
+        try
+        {
+            action();
+        }
+        catch (Exception ex)
+        {
+            throw new AssertMessageException(message, ex);
+        }
+    }
+
+    [Serializable]
+    public class AssertMessageException(string message, Exception inner) : Exception(message, inner);
+#endif
 }

src/AutoCtor.Tests/GeneratedAttributeTests.cs

@@ -1,15 +1,17 @@
-using Microsoft.CodeAnalysis;
-
-namespace AutoCtor.Tests;
+namespace AutoCtor.Tests;
 
 public class GeneratedAttributeTests
 {
     [Fact]
     public async Task AttributeGeneratedCode()
     {
-        var compilation = await Helpers.Compile<AutoConstructAttribute>([], preprocessorSymbols: ["AUTOCTOR_EMBED_ATTRIBUTES"]);
-        var generator = new AttributeSourceGenerator().AsSourceGenerator();
-        var driver = Helpers.CreateDriver(generator)
+        var builder = new CompilationBuilder()
+            .AddNetCoreReference()
+            .WithPreprocessorSymbols(["AUTOCTOR_EMBED_ATTRIBUTES"]);
+        var compilation = await builder.Build(nameof(GeneratedAttributeTests));
+        var driver = new GeneratorDriverBuilder()
+            .AddGenerator(new AttributeSourceGenerator())
+            .Build(builder.ParseOptions)
             .RunGenerators(compilation);
 
         await Verify(driver).UseDirectory("Verified");
@@ -18,9 +20,13 @@ public async Task AttributeGeneratedCode()
     [Fact]
     public async Task AttributeCompilesProperly()
     {
-        var compilation = await Helpers.Compile<AutoConstructAttribute>([], preprocessorSymbols: ["AUTOCTOR_EMBED_ATTRIBUTES"]);
-        var generator = new AttributeSourceGenerator().AsSourceGenerator();
-        Helpers.CreateDriver(generator)
+        var builder = new CompilationBuilder()
+            .AddNetCoreReference()
+            .WithPreprocessorSymbols(["AUTOCTOR_EMBED_ATTRIBUTES"]);
+        var compilation = await builder.Build(nameof(GeneratedAttributeTests));
+        var driver = new GeneratorDriverBuilder()
+            .AddGenerator(new AttributeSourceGenerator())
+            .Build(builder.ParseOptions)
             .RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var diagnostics);
 
         Assert.Empty(diagnostics);

src/AutoCtor.Tests/Issue73.cs

@@ -8,9 +8,12 @@ public class Issue73
     [Fact]
     public async Task VerifyGeneratedCode()
     {
-        var compilation = await Compile();
-        var generator = new AutoConstructSourceGenerator().AsSourceGenerator();
-        var driver = Helpers.CreateDriver(generator).RunGenerators(compilation);
+        var common = Common();
+        var compilation = await Compile(common);
+        var driver = new GeneratorDriverBuilder()
+            .AddGenerator(new AutoConstructSourceGenerator())
+            .Build(common.ParseOptions)
+            .RunGenerators(compilation);
 
         await Verify(driver).UseDirectory("Verified");
     }
@@ -20,16 +23,25 @@ public async Task CodeCompilesWithoutErrors()
     {
         string[] ignoredWarnings = ["CS0414"]; // Ignore unused fields
 
-        var compilation = await Compile();
-        var generator = new AutoConstructSourceGenerator().AsSourceGenerator();
-        Helpers.CreateDriver(generator)
+        var common = Common();
+        var compilation = await Compile(common);
+        new GeneratorDriverBuilder()
+            .AddGenerator(new AutoConstructSourceGenerator())
+            .Build(common.ParseOptions)
             .RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var diagnostics);
 
         Assert.Empty(diagnostics);
         Assert.Empty(outputCompilation.GetDiagnostics().Where(d => !ignoredWarnings.Contains(d.Id)));
     }
 
-    private static async Task<CSharpCompilation> Compile()
+    private static CompilationBuilder Common()
+    {
+        return new CompilationBuilder()
+            .AddNetCoreReference()
+            .AddAssemblyReference<AutoConstructAttribute>();
+    }
+
+    private static async Task<CSharpCompilation> Compile(CompilationBuilder common)
     {
         var projectACode = @"
 namespace A
@@ -51,10 +63,14 @@ public abstract class BaseClass<T, U, V>
 public sealed partial class TheClass : BaseClass<object, int, string>{}
 }
 ";
+        var projectA = await common
+            .AddCode(projectACode)
+            .Build("ProjectA");
 
-        var projectA = await Helpers.Compile<AutoConstructAttribute>([projectACode], assemblyName: "ProjectA");
-        var projectB = await Helpers.Compile<AutoConstructAttribute>([projectBCode], assemblyName: "ProjectB",
-            extraReferences: [projectA.ToMetadataReference()]);
+        var projectB = await common
+            .AddCompilationReference(projectA)
+            .AddCode(projectBCode)
+            .Build("ProjectB");
 
         return projectB;
     }

src/AutoCtor.Tests/Utilities/CodeFileTheoryData.cs

@@ -8,7 +8,7 @@ public record CodeFileTheoryData : IXunitSerializable
     public required string[] Codes { get; set; }
     public required string VerifiedDirectory { get; set; }
 
-    public (string, string)[] Options { get; set; } = [];
+    public Dictionary<string, string> Options { get; set; } = [];
     public bool LangPreview { get; set; }
     public string[] IgnoredCompileDiagnostics { get; set; } = [];
 
@@ -32,8 +32,7 @@ public void Deserialize(IXunitSerializationInfo info)
             ?? throw new Exception($"Missing {nameof(VerifiedDirectory)} in theory serialization");
         Options = info.GetValue<string[]>(nameof(Options))?
             .Select(o => o.Split('|'))
-            .Select(o => (o[0], o[1]))
-            .ToArray()
+            .ToDictionary(o => o[0], o => o[1])
             ?? throw new Exception($"Missing {nameof(Options)} in theory serialization");
         LangPreview = info.GetValue<bool>(nameof(LangPreview));
         IgnoredCompileDiagnostics = info.GetValue<string[]>(nameof(IgnoredCompileDiagnostics))
@@ -45,7 +44,7 @@ public void Serialize(IXunitSerializationInfo info)
         info.AddValue(nameof(Name), Name);
         info.AddValue(nameof(Codes), Codes);
         info.AddValue(nameof(VerifiedDirectory), VerifiedDirectory);
-        info.AddValue(nameof(Options), Options.Select(o => $"{o.Item1}|{o.Item2}").ToArray());
+        info.AddValue(nameof(Options), Options.Select(o => $"{o.Key}|{o.Value}").ToArray());
         info.AddValue(nameof(LangPreview), LangPreview);
         info.AddValue(nameof(IgnoredCompileDiagnostics), IgnoredCompileDiagnostics);
     }