feat: combine SnapshotTests and SamplesTests

test/Mediator.SourceGenerator.Roslyn38.Tests/SnapshotTests.cs

@@ -1,7 +1,8 @@
+namespace Mediator.SourceGenerator.Tests;
+
 using System.Threading.Tasks;
 using VerifyXunit;
-
-namespace Mediator.SourceGenerator.Tests;
+using Verifier = CSharpSourceGeneratorVerifier<MediatorGenerator>;
 
 [UsesVerify]
 public sealed class SnapshotTests
@@ -11,6 +12,7 @@ public async Task Test_SimpleConsole()
     {
         var source = await Fixture.SourceFromResourceFile("SimpleConsoleProgram.cs");
 
+        await Verifier.VerifySolution(source);
         await Fixture.VerifyGenerator(source);
     }
 
@@ -19,6 +21,7 @@ public async Task Test_SimpleEndToEnd()
     {
         var source = await Fixture.SourceFromResourceFile("SimpleEndToEndProgram.cs");
 
+        await Verifier.VerifySolution(source);
         await Fixture.VerifyGenerator(source);
     }
 
@@ -27,6 +30,7 @@ public async Task Test_SimpleStreaming()
     {
         var source = await Fixture.SourceFromResourceFile("SimpleStreamingProgram.cs");
 
+        await Verifier.VerifySolution(source);
         await Fixture.VerifyGenerator(source);
     }
 
@@ -35,6 +39,7 @@ public async Task Test_Multiple_AddMediator_Calls()
     {
         var source = await Fixture.SourceFromResourceFile("MultipleAddMediatorCalls.cs");
 
+        await Verifier.VerifySolution(source);
         await Fixture.VerifyGenerator(source);
     }
 }

test/Mediator.SourceGenerator.Roslyn38.Tests/SourceGenVerifier.cs

@@ -2,14 +2,26 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
 using Microsoft.CodeAnalysis.Testing.Verifiers;
 using System;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Threading.Tasks;
 
 public static class CSharpSourceGeneratorVerifier<TSourceGenerator> where TSourceGenerator : ISourceGenerator, new()
 {
-    public class Test : CSharpSourceGeneratorTest<TSourceGenerator, XUnitVerifier>
+    public static Task VerifySolution(string source)
+    {
+        var test = new Test
+        {
+            TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck,
+            TestState = { Sources = { source }, },
+        };
+        return test.RunAsync();
+    }
+
+    private class Test : CSharpSourceGeneratorTest<TSourceGenerator, XUnitVerifier>
     {
         public Test()
         {

test/Mediator.SourceGenerator.Roslyn40.Tests/Mediator.SourceGenerator.Roslyn40.Tests.csproj

@@ -28,6 +28,7 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Build.Locator" Version="1.4.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing.XUnit" Version="1.1.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="4.0.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />

test/Mediator.SourceGenerator.Roslyn40.Tests/SourceGenVerifier.cs

@@ -0,0 +1,95 @@
+using Mediator.SourceGenerator.Tests;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+
+public static class CSharpSourceGeneratorVerifier<TSourceGenerator>
+    where TSourceGenerator : IIncrementalGenerator, new()
+{
+    public static Task VerifySolution(string source)
+    {
+        var test = new Test
+        {
+            TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck,
+            TestState = { Sources = { source }, },
+        };
+        return test.RunAsync();
+    }
+
+    private class Test : CSharpSourceGeneratorTest<EmptySourceGeneratorProvider, XUnitVerifier>
+    {
+        public Test()
+        {
+            var refs = Fixture.AssemblyReferencesForCodegen.Select(a => a.Location).ToImmutableArray();
+
+            var metadataRefs = refs.Select(l => MetadataReference.CreateFromFile(l)).ToImmutableArray();
+
+            this.ReferenceAssemblies = Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.Net.Net60.WithAssemblies(
+                refs
+            );
+
+            this.SolutionTransforms.Add(
+                (sln, projectId) =>
+                {
+                    var compilationOptions = ((CSharpCompilationOptions)sln.GetProject(projectId)!.CompilationOptions!)
+                        .WithOutputKind(OutputKind.ConsoleApplication)
+                        .WithUsings(
+                            "System",
+                            "System.Collections.Generic",
+                            "System.IO",
+                            "System.Linq",
+                            "System.Net.Http",
+                            "System.Threading",
+                            "System.Threading.Tasks"
+                        );
+
+                    sln = sln.AddMetadataReferences(projectId, metadataRefs)
+                        .WithProjectCompilationOptions(projectId, compilationOptions);
+                    return sln;
+                }
+            );
+        }
+
+        public TSourceGenerator SourceGenerator => (TSourceGenerator)GetSourceGenerators().Single();
+
+        protected override IEnumerable<ISourceGenerator> GetSourceGenerators() =>
+            new ISourceGenerator[] { new TSourceGenerator().AsSourceGenerator() };
+
+        protected override CompilationOptions CreateCompilationOptions()
+        {
+            var compilationOptions = base.CreateCompilationOptions();
+            return compilationOptions
+                .WithSpecificDiagnosticOptions(
+                    compilationOptions.SpecificDiagnosticOptions.SetItems(GetNullableWarningsFromCompiler())
+                )
+                .WithOutputKind(OutputKind.ConsoleApplication);
+        }
+
+        public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.Latest;
+
+        private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler()
+        {
+            string[] args = { "/warnaserror:nullable" };
+            var commandLineArguments = CSharpCommandLineParser.Default.Parse(
+                args,
+                baseDirectory: Environment.CurrentDirectory,
+                sdkDirectory: Environment.CurrentDirectory
+            );
+            var nullableWarnings = commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;
+
+            return nullableWarnings;
+        }
+
+        protected override ParseOptions CreateParseOptions()
+        {
+            return ((CSharpParseOptions)base.CreateParseOptions()).WithLanguageVersion(LanguageVersion);
+        }
+    }
+}