From d17c2aa82d7336208efcffa8406a7a7e95b2131d Mon Sep 17 00:00:00 2001 From: James McMahon Date: Sat, 14 Nov 2026 22:18:27 +0000 Subject: [PATCH 1/2] Migrate Roslyn integration tests to Microsoft testing framework --- .../Packaging/PackageAssemblyContext.cs | 21 + .../Packaging/PackageConsumerWorkspace.cs | 60 ++ .../Packaging/PackageDeliveryFixture.cs | 40 + .../PackageInteroperabilityFixture.cs | 40 + .../Packaging/PackageInteroperabilityTests.cs | 250 ++++++ .../Packaging/PackagedGeneratorTests.cs | 404 ++-------- .../Packaging/SymbolPackageFixture.cs | 38 + .../Packaging/SymbolPackageTests.cs | 30 +- .../Analyzers/AnalyzerTestCompilation.cs | 35 - .../DimensionMismatchAnalyzerTests.cs | 254 +++++-- .../QuantityEncodingAnalyzerTests.cs | 125 ++- .../QuantityAliasCodeFixProviderTests.cs | 177 +++-- .../DimensionalQuantities.Roslyn.Tests.csproj | 5 + .../Framework/QuantityAnalyzerTest.cs | 17 + .../Framework/QuantityCodeFixTest.cs | 26 + .../Framework/QuantityGeneratorTest.cs | 29 + .../Framework/QuantitySourceReference.cs | 17 + .../Framework/QuantityTestEnvironment.cs | 16 + .../Generators/CoreConversionBoundaryTests.cs | 61 +- .../FractionalPrefixEmitterTests.cs | 33 + .../Generators/GenerationDiagnosticTests.cs | 454 ++++++++--- .../Generators/QuantityGeneratorTests.cs | 709 ++++++++++++------ .../Generators/UnitProviderGenerationTests.cs | 185 +++-- 23 files changed, 2009 insertions(+), 1017 deletions(-) create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageAssemblyContext.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageConsumerWorkspace.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityAnalyzerTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityGeneratorTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantitySourceReference.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityTestEnvironment.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageAssemblyContext.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageAssemblyContext.cs new file mode 100644 index 0000000..3677394 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageAssemblyContext.cs @@ -0,0 +1,21 @@ +using System.Reflection; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +internal sealed class PackageAssemblyContext : System.Runtime.Loader.AssemblyLoadContext, IDisposable +{ + private readonly string _directory; + + public PackageAssemblyContext(string directory) : base(isCollectible: true) + { + _directory = directory; + } + + protected override Assembly? Load(AssemblyName assemblyName) + { + string path = Path.Combine(_directory, assemblyName.Name + ".dll"); + return File.Exists(path) ? LoadFromAssemblyPath(path) : null; + } + + public void Dispose() => Unload(); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageConsumerWorkspace.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageConsumerWorkspace.cs new file mode 100644 index 0000000..3a3cce8 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageConsumerWorkspace.cs @@ -0,0 +1,60 @@ +using Microsoft.Build.Utilities.ProjectCreation; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +internal sealed class PackageConsumerWorkspace : IDisposable +{ + public string Directory { get; } + + public PackageConsumerWorkspace(string directory) + { + Directory = directory; + } + + public void Build(ProjectCreator project) + { + project.TryBuild(restore: true, out bool built, out BuildOutput output); + using (output) + { + if (!built) + { + throw new InvalidOperationException(output.GetConsoleLog()); + } + } + } + + public void Pack(ProjectCreator project, string name, PackageRepository repository, out Package package) + { + project.TryBuild(restore: true, target: "Pack", out bool built, out BuildOutput output); + using (output) + { + if (!built) + { + throw new InvalidOperationException(output.GetConsoleLog()); + } + } + package = PackageTestSupport.AddPackedPackage(repository, new FileInfo(Path.Combine(Directory, name, "packages", $"{name}.1.0.0.nupkg"))); + } + + public string OutputDirectory(string project) => Path.Combine(Directory, project, "bin", "Debug", "netstandard2.0"); + + public ProjectCreator CreateProject(string name, string source, params Package[] packages) + { + string directory = Path.Combine(Directory, name); + System.IO.Directory.CreateDirectory(directory); + File.WriteAllText(Path.Combine(directory, name + ".cs"), source); + ProjectCreator creator = ProjectCreator.Templates.SdkCsproj(path: Path.Combine(directory, name + ".csproj"), targetFramework: "netstandard2.0") + .Property("LangVersion", "preview") + .Property("WarningsAsErrors", "CS8032;CS8785;AD0001") + .Property("Version", "1.0.0") + .Property("PackageOutputPath", Path.Combine(directory, "packages")) + .Property("CopyLocalLockFileAssemblies", "true"); + foreach (Package package in packages) + { + creator.ItemPackageReference(package); + } + return creator.Save(); + } + + public void Dispose() => System.IO.Directory.Delete(Directory, recursive: true); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs new file mode 100644 index 0000000..1a04198 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs @@ -0,0 +1,40 @@ +using Microsoft.Build.Locator; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +public sealed class PackageDeliveryFixture : IDisposable +{ + private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-delivery-").FullName; + private readonly Dictionary _packages = new(); + + static PackageDeliveryFixture() + { + // MSBuild must be located before any Microsoft.Build type is loaded. + if (!MSBuildLocator.IsRegistered) + { + MSBuildLocator.RegisterDefaults(); + } + } + + public PackageDeliveryFixture() + { + string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); + foreach (string projectName in new[] + { + "DimensionalQuantities", + "DimensionalQuantities.Extensions.Metric", + "DimensionalQuantities.Extensions.Imperial", + "DimensionalQuantities.Extensions.Nautical", + "DimensionalQuantities.Extensions.CgsEmag", + }) + { + _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); + } + } + + internal FileInfo GetPackage(string projectName) => _packages[projectName]; + + internal PackageConsumerWorkspace CreateWorkspace() => new(Directory.CreateDirectory(Path.Combine(_scratch, Guid.NewGuid().ToString("N"))).FullName); + + public void Dispose() => Directory.Delete(_scratch, recursive: true); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs new file mode 100644 index 0000000..631152d --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs @@ -0,0 +1,40 @@ +using Microsoft.Build.Locator; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +public sealed class PackageInteroperabilityFixture : IDisposable +{ + private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-interoperability-").FullName; + private readonly Dictionary _packages = new(); + + static PackageInteroperabilityFixture() + { + // MSBuild must be located before any Microsoft.Build type is loaded. + if (!MSBuildLocator.IsRegistered) + { + MSBuildLocator.RegisterDefaults(); + } + } + + public PackageInteroperabilityFixture() + { + string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); + foreach (string projectName in new[] + { + "DimensionalQuantities", + "DimensionalQuantities.Extensions.Metric", + "DimensionalQuantities.Extensions.Imperial", + "DimensionalQuantities.Extensions.Nautical", + "DimensionalQuantities.Extensions.CgsEmag", + }) + { + _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); + } + } + + internal FileInfo GetPackage(string projectName) => _packages[projectName]; + + internal PackageConsumerWorkspace CreateWorkspace() => new(Directory.CreateDirectory(Path.Combine(_scratch, Guid.NewGuid().ToString("N"))).FullName); + + public void Dispose() => Directory.Delete(_scratch, recursive: true); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs new file mode 100644 index 0000000..d500c8b --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs @@ -0,0 +1,250 @@ +using System.Reflection; +using Microsoft.Build.Utilities.ProjectCreation; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +[Collection("MSBuild")] +public sealed class PackageInteroperabilityTests : IClassFixture, IDisposable +{ + private readonly PackageInteroperabilityFixture _fixture; + private readonly PackageConsumerWorkspace _workspace; + + public PackageInteroperabilityTests(PackageInteroperabilityFixture fixture) + { + _fixture = fixture; + _workspace = fixture.CreateWorkspace(); + } + + [Fact] + public void AffineTemperatureConversionsAndDeltasWorkAcrossPackages() + { + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package metric = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Metric")); + Package imperial = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Imperial")); + + ProjectCreator measurements = _workspace.CreateProject("TemperatureMeasurements", """ + using DimensionalQuantities.Extensions.Metric; + using DimensionalQuantities.TypeSystem; + + namespace TemperatureMeasurements; + public static class Readings + { + public static Delta Difference() => + (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta(); + } + """, metric); + _workspace.Pack(measurements, "TemperatureMeasurements", repository, out Package measurementPackage); + + ProjectCreator consumer = _workspace.CreateProject("TemperatureConsumer", """ + using DimensionalQuantities.Extensions.Imperial; + using DimensionalQuantities.Extensions.Metric; + using TemperatureMeasurements; + + public static class Consumer + { + public static double[] DifferenceInEachUnit() + { + var delta = Readings.Difference(); + return [delta.AsCelsius(), delta.AsFahrenheit(), delta.AsKelvin(), delta.AsRankine()]; + } + + public static double[] AbsoluteRoundTrips() => + [ + Temperature.FromCelsius(20).AsCelsius(), + Temperature.FromFahrenheit(68).AsFahrenheit(), + Temperature.FromKelvin(293.15).AsCelsius(), + Temperature.FromRankine(527.67).AsFahrenheit() + ]; + } + """, metric, imperial, measurementPackage); + _workspace.Build(consumer); + + string outputDirectory = _workspace.OutputDirectory("TemperatureConsumer"); + using PackageAssemblyContext context = new(outputDirectory); + Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "TemperatureConsumer.dll")) + .GetType("Consumer", throwOnError: true)!; + double[] difference = (double[])type.GetMethod("DifferenceInEachUnit")!.Invoke(null, null)!; + double[] absolute = (double[])type.GetMethod("AbsoluteRoundTrips")!.Invoke(null, null)!; + + Assert.Multiple( + () => Assert.Equal([10d, 18d, 10d, 18d], difference), + () => Assert.Equal(20d, absolute[0], 12), + () => Assert.Equal(68d, absolute[1], 12), + () => Assert.Equal(20d, absolute[2], 12), + () => Assert.Equal(68d, absolute[3], 12)); + } + + [Fact] + public void IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() + { + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + Package core = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package metric = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Metric")); + + ProjectCreator projectA = _workspace.CreateProject("ProjectA", """ + namespace PackageA; + public static class Producer + { + public static Voltage Create() => Voltage.FromSiBaseUnit(6); + public static LengthCurrent CreateIntermediate() => Length.FromMetres(2) * Current.FromAmps(3); + public static System.Collections.Generic.List Values() => new() { Create(), Create() }; + public static Measurement Measure() => new(); + } + public sealed class Measurement + { + public Voltage Value => Producer.Create(); + } + """, core); + _workspace.Pack(projectA, "ProjectA", repository, out Package packageA); + + ProjectCreator projectB = _workspace.CreateProject("ProjectB", """ + using DimensionalQuantities.Extensions.Metric; + namespace PackageB; + public static class Consumer + { + public static Voltage Create() => Voltage.FromVolts(10); + public static LengthCurrent CreateIntermediate() => Length.FromMetres(5) * Current.FromAmps(2); + public static double ReadIntermediate(LengthCurrent value) => value.AsSiBaseUnit(); + public static double Read(Voltage value) => value.AsVolts(); + public static double Sum(System.Collections.Generic.IEnumerable values) + { + double total = 0; + foreach (Voltage value in values) + { + total += value.AsVolts(); + } + return total; + } + } + """, metric); + _workspace.Pack(projectB, "ProjectB", repository, out Package packageB); + + ProjectCreator projectC = _workspace.CreateProject("ProjectC", """ + using DimensionalQuantities.Extensions.Metric; + using PackageA; + public static class Application + { + public static double Direct() => PackageB.Consumer.Read(Producer.Create()); + public static double Collection() => PackageB.Consumer.Sum(Producer.Values()); + public static double Contained() => PackageB.Consumer.Read(Producer.Measure().Value); + public static double Prefixed() => Producer.Create().AsPrefixedUnits(3); + public static double Product() => (Producer.Create() * Current.FromAmps(4)).AsWatts(); + public static double Intermediate() => PackageB.Consumer.ReadIntermediate(Producer.CreateIntermediate()); + public static double IntermediateProduct() => (Producer.CreateIntermediate() * Time.FromSeconds(4)).AsSiBaseUnit(); + } + """, metric, packageA, packageB); + _workspace.Build(projectC); + + string outputDirectory = _workspace.OutputDirectory("ProjectC"); + using PackageAssemblyContext context = new(outputDirectory); + Assembly assemblyA = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectA.dll")); + Assembly assemblyB = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectB.dll")); + Assembly assemblyC = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectC.dll")); + Type producer = assemblyA.GetType("PackageA.Producer", throwOnError: true)!; + Type consumer = assemblyB.GetType("PackageB.Consumer", throwOnError: true)!; + Type application = assemblyC.GetType("Application", throwOnError: true)!; + Type producedType = producer.GetMethod("Create")!.ReturnType; + Type independentlyProducedType = consumer.GetMethod("Create")!.ReturnType; + Type acceptedType = consumer.GetMethod("Read")!.GetParameters().Single().ParameterType; + Type intermediateFromA = producer.GetMethod("CreateIntermediate")!.ReturnType; + Type intermediateFromB = consumer.GetMethod("CreateIntermediate")!.ReturnType; + Type intermediateAccepted = consumer.GetMethod("ReadIntermediate")!.GetParameters().Single().ParameterType; + + Assert.Multiple( + () => Assert.Equal(producedType, independentlyProducedType), + () => Assert.Equal(producedType, acceptedType), + () => Assert.Equal(intermediateFromA, intermediateFromB), + () => Assert.Equal(intermediateFromA, intermediateAccepted), + () => Assert.Equal(6, InvokeDouble(application, "Direct")), + () => Assert.Equal(12, InvokeDouble(application, "Collection")), + () => Assert.Equal(6, InvokeDouble(application, "Contained")), + () => Assert.Equal(0.006, InvokeDouble(application, "Prefixed"), 12), + () => Assert.Equal(24, InvokeDouble(application, "Product")), + () => Assert.Equal(6, InvokeDouble(application, "Intermediate")), + () => Assert.Equal(24, InvokeDouble(application, "IntermediateProduct"))); + } + + [Fact] + public void AllUnitPackagesWorkInALibraryAndItsPackagedConsumer() + { + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package metric = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Metric")); + Package imperial = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Imperial")); + Package nautical = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Nautical")); + Package cgsEmag = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.CgsEmag")); + + ProjectCreator library = _workspace.CreateProject("AllUnitsLibrary", """ + using DimensionalQuantities.Extensions.Metric; + using DimensionalQuantities.Extensions.Imperial; + using DimensionalQuantities.Extensions.Nautical; + using DimensionalQuantities.Extensions.CgsEmag; + + namespace AllUnitsLibrary; + public static class Measurements + { + public static Voltage Supply() => Voltage.FromVolts(0.00000001); + public static Length Depth() => Length.FromFeet(6); + public static Speed Travel() => Speed.FromKnots(1); + public static MagneticFluxDensity Field() => MagneticFluxDensity.FromGauss(10_000); + public static double[] LocalValues() => [Supply().AsVolts(), Depth().AsFeet(), Travel().AsKnots(), Field().AsGauss()]; + } + """, metric, imperial, nautical, cgsEmag); + _workspace.Pack(library, "AllUnitsLibrary", repository, out Package libraryPackage); + + ProjectCreator downstream = _workspace.CreateProject("AllUnitsDownstream", """ + using DimensionalQuantities.Extensions.Metric; + using DimensionalQuantities.Extensions.Imperial; + using DimensionalQuantities.Extensions.Nautical; + using DimensionalQuantities.Extensions.CgsEmag; + using AllUnitsLibrary; + + namespace AllUnitsDownstream; + public static class Reader + { + public static double[] LocalValues() => Measurements.LocalValues(); + public static double[] ConvertedValues() => + [ + Measurements.Supply().AsAbvolts(), + Measurements.Depth().AsFathoms(), + Measurements.Depth().AsFeet(), + Measurements.Travel().AsKnots(), + Measurements.Field().AsTeslas() + ]; + } + """, libraryPackage); + _workspace.Pack(downstream, "AllUnitsDownstream", repository, out Package downstreamPackage); + + ProjectCreator application = _workspace.CreateProject("AllUnitsApplication", """ + public static class Application + { + public static double[] LocalValues() => AllUnitsDownstream.Reader.LocalValues(); + public static double[] ConvertedValues() => AllUnitsDownstream.Reader.ConvertedValues(); + } + """, downstreamPackage); + _workspace.Build(application); + + string outputDirectory = _workspace.OutputDirectory("AllUnitsApplication"); + using PackageAssemblyContext context = new(outputDirectory); + Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "AllUnitsApplication.dll")) + .GetType("Application", throwOnError: true)!; + double[] local = (double[])type.GetMethod("LocalValues")!.Invoke(null, null)!; + double[] converted = (double[])type.GetMethod("ConvertedValues")!.Invoke(null, null)!; + + Assert.Multiple( + () => Assert.Equal([0.00000001d, 6d, 1d, 10_000d], local), + () => Assert.Equal(5, converted.Length), + () => Assert.Equal(1d, converted[0]), + () => Assert.Equal(1d, converted[1], 12), + () => Assert.Equal(6d, converted[2]), + () => Assert.Equal(1d, converted[3]), + () => Assert.Equal(1d, converted[4])); + } + + private static double InvokeDouble(Type type, string method, params object[] arguments) + => (double)type.GetMethod(method)!.Invoke(null, arguments)!; + + public void Dispose() => _workspace.Dispose(); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs index 3413f08..3609be8 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs @@ -1,30 +1,27 @@ using System.Reflection; -using Microsoft.Build.Locator; using Microsoft.Build.Utilities.ProjectCreation; using Xunit; namespace DimensionalQuantities.IntegrationTests.Packaging; [Collection("MSBuild")] -public sealed class PackagedGeneratorTests : IDisposable +public sealed class PackagedGeneratorTests : IClassFixture, IDisposable { - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-").FullName; + private readonly PackageDeliveryFixture _fixture; + private readonly PackageConsumerWorkspace _workspace; - static PackagedGeneratorTests() + public PackagedGeneratorTests(PackageDeliveryFixture fixture) { - // MSBuild must be located before any Microsoft.Build type is loaded. - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } + _fixture = fixture; + _workspace = fixture.CreateWorkspace(); } [Fact] public void CorePackageProvidesBaseUnitsCatalogueAliasesAndArithmetic() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - ProjectCreator consumer = CreateProject("CoreConsumer", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + Package core = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + ProjectCreator consumer = _workspace.CreateProject("CoreConsumer", """ public static class Consumer { public static double ConvertLength() => Length.FromMetres(2.5).AsMetres(); @@ -33,10 +30,10 @@ public static class Consumer public static double NamedArea() => Area.FromSiBaseUnit(6).AsSiBaseUnit(); } """, core); - Build(consumer); + _workspace.Build(consumer); - using PackageAssemblyContext context = new(OutputDirectory("CoreConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CoreConsumer"), "CoreConsumer.dll")) + using PackageAssemblyContext context = new(_workspace.OutputDirectory("CoreConsumer")); + Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("CoreConsumer"), "CoreConsumer.dll")) .GetType("Consumer", throwOnError: true)!; Assert.Multiple( () => Assert.Equal(2.5, InvokeDouble(type, "ConvertLength")), @@ -48,10 +45,10 @@ public static class Consumer [Fact] public void MetricPackageProvidesNamedConversionsAndArithmeticThroughCoreDependency() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - ProjectCreator consumer = CreateProject("MetricConsumer", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package metric = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Metric")); + ProjectCreator consumer = _workspace.CreateProject("MetricConsumer", """ using DimensionalQuantities.Extensions.Metric; public static class Consumer @@ -64,10 +61,10 @@ public static double MultiplyVoltageCurrent(double volts, double amps) } } """, metric); - Build(consumer); + _workspace.Build(consumer); - using PackageAssemblyContext context = new(OutputDirectory("MetricConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("MetricConsumer"), "MetricConsumer.dll")) + using PackageAssemblyContext context = new(_workspace.OutputDirectory("MetricConsumer")); + Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("MetricConsumer"), "MetricConsumer.dll")) .GetType("Consumer", throwOnError: true)!; Assert.Multiple( () => Assert.Equal(12.5, InvokeDouble(type, "ConvertVoltage", 12.5)), @@ -77,10 +74,10 @@ public static double MultiplyVoltageCurrent(double volts, double amps) [Fact] public void ImperialPackageProvidesConversionsThroughCoreDependency() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - ProjectCreator consumer = CreateProject("ImperialConsumer", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package imperial = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Imperial")); + ProjectCreator consumer = _workspace.CreateProject("ImperialConsumer", """ using DimensionalQuantities.Extensions.Imperial; public static class Consumer @@ -89,83 +86,23 @@ public static class Consumer public static double ConvertTemperature() => Temperature.FromRankine(491.67).AsSiBaseUnit(); } """, imperial); - Build(consumer); + _workspace.Build(consumer); - using PackageAssemblyContext context = new(OutputDirectory("ImperialConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("ImperialConsumer"), "ImperialConsumer.dll")) + using PackageAssemblyContext context = new(_workspace.OutputDirectory("ImperialConsumer")); + Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("ImperialConsumer"), "ImperialConsumer.dll")) .GetType("Consumer", throwOnError: true)!; Assert.Multiple( () => Assert.Equal(1.8288, InvokeDouble(type, "ConvertLength"), 12), () => Assert.Equal(273.15, InvokeDouble(type, "ConvertTemperature"), 12)); } - [Fact] - public void AffineTemperatureConversionsAndDeltasWorkAcrossPackages() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - - ProjectCreator measurements = CreateProject("TemperatureMeasurements", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.TypeSystem; - - namespace TemperatureMeasurements; - public static class Readings - { - public static Delta Difference() => - (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta(); - } - """, metric); - Pack(measurements, "TemperatureMeasurements", repository, out Package measurementPackage); - - ProjectCreator consumer = CreateProject("TemperatureConsumer", """ - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Metric; - using TemperatureMeasurements; - - public static class Consumer - { - public static double[] DifferenceInEachUnit() - { - var delta = Readings.Difference(); - return [delta.AsCelsius(), delta.AsFahrenheit(), delta.AsKelvin(), delta.AsRankine()]; - } - - public static double[] AbsoluteRoundTrips() => - [ - Temperature.FromCelsius(20).AsCelsius(), - Temperature.FromFahrenheit(68).AsFahrenheit(), - Temperature.FromKelvin(293.15).AsCelsius(), - Temperature.FromRankine(527.67).AsFahrenheit() - ]; - } - """, metric, imperial, measurementPackage); - Build(consumer); - - string outputDirectory = OutputDirectory("TemperatureConsumer"); - using PackageAssemblyContext context = new(outputDirectory); - Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "TemperatureConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - double[] difference = (double[])type.GetMethod("DifferenceInEachUnit")!.Invoke(null, null)!; - double[] absolute = (double[])type.GetMethod("AbsoluteRoundTrips")!.Invoke(null, null)!; - - Assert.Multiple( - () => Assert.Equal([10d, 18d, 10d, 18d], difference), - () => Assert.Equal(20d, absolute[0], 12), - () => Assert.Equal(68d, absolute[1], 12), - () => Assert.Equal(20d, absolute[2], 12), - () => Assert.Equal(68d, absolute[3], 12)); - } - [Fact] public void NauticalPackageProvidesConversionsThroughCoreDependency() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package nautical = PackSourceProject(repository, "DimensionalQuantities.Extensions.Nautical"); - ProjectCreator consumer = CreateProject("NauticalConsumer", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package nautical = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Nautical")); + ProjectCreator consumer = _workspace.CreateProject("NauticalConsumer", """ using DimensionalQuantities.Extensions.Nautical; public static class Consumer @@ -174,10 +111,10 @@ public static class Consumer public static double ConvertSpeed() => Speed.FromKnots(1).AsSiBaseUnit(); } """, nautical); - Build(consumer); + _workspace.Build(consumer); - using PackageAssemblyContext context = new(OutputDirectory("NauticalConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("NauticalConsumer"), "NauticalConsumer.dll")) + using PackageAssemblyContext context = new(_workspace.OutputDirectory("NauticalConsumer")); + Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("NauticalConsumer"), "NauticalConsumer.dll")) .GetType("Consumer", throwOnError: true)!; Assert.Multiple( () => Assert.Equal(1852, InvokeDouble(type, "ConvertLength")), @@ -187,10 +124,10 @@ public static class Consumer [Fact] public void CgsEmagPackageProvidesConversionsThroughCoreDependency() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package cgsEmag = PackSourceProject(repository, "DimensionalQuantities.Extensions.CgsEmag"); - ProjectCreator consumer = CreateProject("CgsEmagConsumer", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package cgsEmag = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.CgsEmag")); + ProjectCreator consumer = _workspace.CreateProject("CgsEmagConsumer", """ using DimensionalQuantities.Extensions.CgsEmag; public static class Consumer @@ -200,10 +137,10 @@ public static class Consumer public static double ConvertCharge() => ElectricCharge.FromAbcoulombs(1).AsSiBaseUnit(); } """, cgsEmag); - Build(consumer); + _workspace.Build(consumer); - using PackageAssemblyContext context = new(OutputDirectory("CgsEmagConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CgsEmagConsumer"), "CgsEmagConsumer.dll")) + using PackageAssemblyContext context = new(_workspace.OutputDirectory("CgsEmagConsumer")); + Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("CgsEmagConsumer"), "CgsEmagConsumer.dll")) .GetType("Consumer", throwOnError: true)!; Assert.Multiple( () => Assert.Equal(1, InvokeDouble(type, "ConvertFluxDensity")), @@ -214,10 +151,10 @@ public static class Consumer [Fact] public void MetricNamedConversionsRequireNamespaceImport() { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - ProjectCreator consumer = CreateProject("MissingMetricImport", """ + using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); + PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); + Package metric = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities.Extensions.Metric")); + ProjectCreator consumer = _workspace.CreateProject("MissingMetricImport", """ public static class Consumer { public static double Convert() => Voltage.FromVolts(12.5).AsVolts(); @@ -235,259 +172,8 @@ public static class Consumer } } - [Fact] - public void IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - Package metric = PackMetric(repository); - - ProjectCreator projectA = CreateProject("ProjectA", """ - namespace PackageA; - public static class Producer - { - public static Voltage Create() => Voltage.FromSiBaseUnit(6); - public static LengthCurrent CreateIntermediate() => Length.FromMetres(2) * Current.FromAmps(3); - public static System.Collections.Generic.List Values() => new() { Create(), Create() }; - public static Measurement Measure() => new(); - } - public sealed class Measurement - { - public Voltage Value => Producer.Create(); - } - """, core); - Pack(projectA, "ProjectA", repository, out Package packageA); - - ProjectCreator projectB = CreateProject("ProjectB", """ - using DimensionalQuantities.Extensions.Metric; - namespace PackageB; - public static class Consumer - { - public static Voltage Create() => Voltage.FromVolts(10); - public static LengthCurrent CreateIntermediate() => Length.FromMetres(5) * Current.FromAmps(2); - public static double ReadIntermediate(LengthCurrent value) => value.AsSiBaseUnit(); - public static double Read(Voltage value) => value.AsVolts(); - public static double Sum(System.Collections.Generic.IEnumerable values) - { - double total = 0; - foreach (Voltage value in values) - { - total += value.AsVolts(); - } - return total; - } - } - """, metric); - Pack(projectB, "ProjectB", repository, out Package packageB); - - ProjectCreator projectC = CreateProject("ProjectC", """ - using DimensionalQuantities.Extensions.Metric; - using PackageA; - public static class Application - { - public static double Direct() => PackageB.Consumer.Read(Producer.Create()); - public static double Collection() => PackageB.Consumer.Sum(Producer.Values()); - public static double Contained() => PackageB.Consumer.Read(Producer.Measure().Value); - public static double Prefixed() => Producer.Create().AsPrefixedUnits(3); - public static double Product() => (Producer.Create() * Current.FromAmps(4)).AsWatts(); - public static double Intermediate() => PackageB.Consumer.ReadIntermediate(Producer.CreateIntermediate()); - public static double IntermediateProduct() => (Producer.CreateIntermediate() * Time.FromSeconds(4)).AsSiBaseUnit(); - } - """, metric, packageA, packageB); - Build(projectC); - - string outputDirectory = OutputDirectory("ProjectC"); - using PackageAssemblyContext context = new(outputDirectory); - Assembly assemblyA = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectA.dll")); - Assembly assemblyB = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectB.dll")); - Assembly assemblyC = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectC.dll")); - Type producer = assemblyA.GetType("PackageA.Producer", throwOnError: true)!; - Type consumer = assemblyB.GetType("PackageB.Consumer", throwOnError: true)!; - Type application = assemblyC.GetType("Application", throwOnError: true)!; - Type producedType = producer.GetMethod("Create")!.ReturnType; - Type independentlyProducedType = consumer.GetMethod("Create")!.ReturnType; - Type acceptedType = consumer.GetMethod("Read")!.GetParameters().Single().ParameterType; - Type intermediateFromA = producer.GetMethod("CreateIntermediate")!.ReturnType; - Type intermediateFromB = consumer.GetMethod("CreateIntermediate")!.ReturnType; - Type intermediateAccepted = consumer.GetMethod("ReadIntermediate")!.GetParameters().Single().ParameterType; - - Assert.Multiple( - () => Assert.Equal(producedType, independentlyProducedType), - () => Assert.Equal(producedType, acceptedType), - () => Assert.Equal(intermediateFromA, intermediateFromB), - () => Assert.Equal(intermediateFromA, intermediateAccepted), - () => Assert.Equal(6, InvokeDouble(application, "Direct")), - () => Assert.Equal(12, InvokeDouble(application, "Collection")), - () => Assert.Equal(6, InvokeDouble(application, "Contained")), - () => Assert.Equal(0.006, InvokeDouble(application, "Prefixed"), 12), - () => Assert.Equal(24, InvokeDouble(application, "Product")), - () => Assert.Equal(6, InvokeDouble(application, "Intermediate")), - () => Assert.Equal(24, InvokeDouble(application, "IntermediateProduct"))); - } - - [Fact] - public void AllUnitPackagesWorkInALibraryAndItsPackagedConsumer() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - Package nautical = PackSourceProject(repository, "DimensionalQuantities.Extensions.Nautical"); - Package cgsEmag = PackSourceProject(repository, "DimensionalQuantities.Extensions.CgsEmag"); - - ProjectCreator library = CreateProject("AllUnitsLibrary", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Nautical; - using DimensionalQuantities.Extensions.CgsEmag; - - namespace AllUnitsLibrary; - public static class Measurements - { - public static Voltage Supply() => Voltage.FromVolts(0.00000001); - public static Length Depth() => Length.FromFeet(6); - public static Speed Travel() => Speed.FromKnots(1); - public static MagneticFluxDensity Field() => MagneticFluxDensity.FromGauss(10_000); - public static double[] LocalValues() => [Supply().AsVolts(), Depth().AsFeet(), Travel().AsKnots(), Field().AsGauss()]; - } - """, metric, imperial, nautical, cgsEmag); - Pack(library, "AllUnitsLibrary", repository, out Package libraryPackage); - - ProjectCreator downstream = CreateProject("AllUnitsDownstream", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Nautical; - using DimensionalQuantities.Extensions.CgsEmag; - using AllUnitsLibrary; - - namespace AllUnitsDownstream; - public static class Reader - { - public static double[] LocalValues() => Measurements.LocalValues(); - public static double[] ConvertedValues() => - [ - Measurements.Supply().AsAbvolts(), - Measurements.Depth().AsFathoms(), - Measurements.Depth().AsFeet(), - Measurements.Travel().AsKnots(), - Measurements.Field().AsTeslas() - ]; - } - """, libraryPackage); - Pack(downstream, "AllUnitsDownstream", repository, out Package downstreamPackage); - - ProjectCreator application = CreateProject("AllUnitsApplication", """ - public static class Application - { - public static double[] LocalValues() => AllUnitsDownstream.Reader.LocalValues(); - public static double[] ConvertedValues() => AllUnitsDownstream.Reader.ConvertedValues(); - } - """, downstreamPackage); - Build(application); - - string outputDirectory = OutputDirectory("AllUnitsApplication"); - using PackageAssemblyContext context = new(outputDirectory); - Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "AllUnitsApplication.dll")) - .GetType("Application", throwOnError: true)!; - double[] local = (double[])type.GetMethod("LocalValues")!.Invoke(null, null)!; - double[] converted = (double[])type.GetMethod("ConvertedValues")!.Invoke(null, null)!; - - Assert.Multiple( - () => Assert.Equal([0.00000001d, 6d, 1d, 10_000d], local), - () => Assert.Equal(5, converted.Length), - () => Assert.Equal(1d, converted[0]), - () => Assert.Equal(1d, converted[1], 12), - () => Assert.Equal(6d, converted[2]), - () => Assert.Equal(1d, converted[3]), - () => Assert.Equal(1d, converted[4])); - } - - private Package PackCore(PackageRepository repository) - { - return PackSourceProject(repository, "DimensionalQuantities"); - } - - private Package PackMetric(PackageRepository repository) - { - return PackSourceProject(repository, "DimensionalQuantities.Extensions.Metric"); - } - - private Package PackSourceProject(PackageRepository repository, string projectName) - { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - FileInfo packageFile = PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch); - return PackageTestSupport.AddPackedPackage(repository, packageFile); - } - - private static void Build(ProjectCreator project) - { - project.TryBuild(restore: true, out bool built, out BuildOutput output); - using (output) - { - if (!built) - { - throw new InvalidOperationException(output.GetConsoleLog()); - } - } - } - - private void Pack(ProjectCreator project, string name, PackageRepository repository, out Package package) - { - project.TryBuild(restore: true, target: "Pack", out bool built, out BuildOutput output); - using (output) - { - if (!built) - { - throw new InvalidOperationException(output.GetConsoleLog()); - } - } - package = PackageTestSupport.AddPackedPackage(repository, new FileInfo(Path.Combine(_scratch, name, "packages", $"{name}.1.0.0.nupkg"))); - } - - private string OutputDirectory(string project) => Path.Combine(_scratch, project, "bin", "Debug", "netstandard2.0"); - private static double InvokeDouble(Type type, string method, params object[] arguments) => (double)type.GetMethod(method)!.Invoke(null, arguments)!; - private ProjectCreator CreateProject(string name, string source, params Package[] packages) - { - string directory = Path.Combine(_scratch, name); - Directory.CreateDirectory(directory); - File.WriteAllText(Path.Combine(directory, name + ".cs"), source); - ProjectCreator creator = ProjectCreator.Templates.SdkCsproj(path: Path.Combine(directory, name + ".csproj"), targetFramework: "netstandard2.0") - .Property("LangVersion", "preview") - .Property("WarningsAsErrors", "CS8032;CS8785;AD0001") - .Property("Version", "1.0.0") - .Property("PackageOutputPath", Path.Combine(directory, "packages")) - .Property("CopyLocalLockFileAssemblies", "true"); - foreach (Package package in packages) - { - creator.ItemPackageReference(package); - } - return creator.Save(); - } - - private sealed class PackageAssemblyContext : System.Runtime.Loader.AssemblyLoadContext, IDisposable - { - private readonly string _directory; - - public PackageAssemblyContext(string directory) : base(isCollectible: true) - { - _directory = directory; - } - - protected override Assembly? Load(AssemblyName assemblyName) - { - string path = Path.Combine(_directory, assemblyName.Name + ".dll"); - return File.Exists(path) ? LoadFromAssemblyPath(path) : null; - } - - public void Dispose() => Unload(); - } - - public void Dispose() - { - Directory.Delete(_scratch, recursive: true); - } - + public void Dispose() => _workspace.Dispose(); } diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs new file mode 100644 index 0000000..2f38f6a --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs @@ -0,0 +1,38 @@ +using Microsoft.Build.Locator; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +public sealed class SymbolPackageFixture : IDisposable +{ + private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-symbols-").FullName; + private readonly Dictionary _packages = new(); + + static SymbolPackageFixture() + { + // MSBuild must be located before any Microsoft.Build type is loaded. + if (!MSBuildLocator.IsRegistered) + { + MSBuildLocator.RegisterDefaults(); + } + } + + public SymbolPackageFixture() + { + string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); + foreach (string projectName in new[] + { + "DimensionalQuantities", + "DimensionalQuantities.Extensions.Metric", + "DimensionalQuantities.Extensions.Imperial", + "DimensionalQuantities.Extensions.Nautical", + "DimensionalQuantities.Extensions.CgsEmag", + }) + { + _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); + } + } + + internal FileInfo GetPackage(string projectName) => _packages[projectName]; + + public void Dispose() => Directory.Delete(_scratch, recursive: true); +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs index 03ce449..de28c70 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs @@ -6,30 +6,26 @@ using System.Reflection.PortableExecutable; using System.Text; using System.Text.Json; -using Microsoft.Build.Locator; using Xunit; namespace DimensionalQuantities.IntegrationTests.Packaging; [Collection("MSBuild")] -public sealed class SymbolPackageTests : IDisposable +public sealed class SymbolPackageTests : IClassFixture { private static readonly Guid _sourceLinkKind = new("CC110556-A091-4D38-9FEC-25AB9A351A6A"); private static readonly Guid _embeddedSourceKind = new("0E8A571B-6926-466E-B4AD-8AB04611F5FE"); - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-symbols-").FullName; + private readonly SymbolPackageFixture _fixture; - static SymbolPackageTests() + public SymbolPackageTests(SymbolPackageFixture fixture) { - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } + _fixture = fixture; } [Fact] public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() { - (FileInfo package, FileInfo symbols) = Pack("DimensionalQuantities"); + (FileInfo package, FileInfo symbols) = GetArchives("DimensionalQuantities"); using ZipArchive binaries = ZipFile.OpenRead(package.FullName); using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); string commit = GetCurrentCommit(); @@ -57,7 +53,7 @@ public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string extension) { string projectName = "DimensionalQuantities.Extensions." + extension; - (FileInfo package, FileInfo symbols) = Pack(projectName); + (FileInfo package, FileInfo symbols) = GetArchives(projectName); using ZipArchive binaries = ZipFile.OpenRead(package.FullName); using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); SymbolDetails details = ReadSymbolDetails(binaries, symbolArchive, "lib/netstandard2.0/" + projectName, @@ -74,16 +70,10 @@ public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string () => Assert.Equal(generatedSource, details.EmbeddedGeneratedSource)); } - private (FileInfo Package, FileInfo Symbols) Pack(string projectName) + private (FileInfo Package, FileInfo Symbols) GetArchives(string projectName) { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - FileInfo package = PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch); - FileInfo symbols = new(Path.ChangeExtension(package.FullName, ".snupkg")); - if (!symbols.Exists) - { - throw new FileNotFoundException("Pack did not create the expected symbol package.", symbols.FullName); - } - return (package, symbols); + FileInfo package = _fixture.GetPackage(projectName); + return (package, new FileInfo(Path.ChangeExtension(package.FullName, ".snupkg"))); } private static SymbolDetails ReadSymbolDetails(ZipArchive binaries, ZipArchive symbols, string stem, string? generatedFileName = null) @@ -168,6 +158,4 @@ private static string GetCurrentCommit() } private sealed record SymbolDetails(Guid AssemblyGuid, uint AssemblyStamp, Guid PdbGuid, uint PdbStamp, string[] SourceUrls, byte[]? EmbeddedGeneratedSource); - - public void Dispose() => Directory.Delete(_scratch, recursive: true); } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs deleted file mode 100644 index 3a584f5..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs +++ /dev/null @@ -1,35 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Diagnostics; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -internal static class AnalyzerTestCompilation -{ - public static CSharpCompilation Create(string source, bool generate = true) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("AnalyzerConsumer", - [CSharpSyntaxTree.ParseText(source, options, "Consumer.cs")], references, new(OutputKind.DynamicallyLinkedLibrary)); - if (!generate) - { - return compilation; - } - - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generated, out _); - return (CSharpCompilation)generated; - } - - public static async Task> Analyze(string source, DiagnosticAnalyzer analyzer, bool generate = true) - { - CSharpCompilation compilation = Create(source, generate); - return await compilation.WithAnalyzers([analyzer]).GetAnalyzerDiagnosticsAsync(Xunit.TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs index c7368cb..ff648fe 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs @@ -1,6 +1,8 @@ -using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; @@ -18,60 +20,148 @@ public sealed class DimensionMismatchAnalyzerTests [InlineData("!=")] public async Task IncompatibleOperandsExplainTheirDimensions(string operation) { - string source = $$""" - public class Consumer - { - public object Calculate(Length length, Current current) => length {{operation}} current; - } - """; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0001", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Contains("Current", result.GetMessage()), - () => Assert.Equal($"length {operation} current", source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + public class Consumer + { + public object Calculate(Length length, Current current) => {|#0:length {{operation}} current|}; + } + """ + }; + test.ExpectedDiagnostics.AddRange([ + DiagnosticResult.CompilerError("CS0019").WithLocation(0), + new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Current") + ]); + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("public void Calculate(Length length) { Current current = length; }")] - [InlineData("public void Calculate(Length length, Current current) { current = length; }")] - [InlineData("public Current Calculate(Length length) => length;")] - [InlineData("public Current Calculate(Length length) { return length; }")] - [InlineData("public void Calculate(Length length) { Accept(length); } private void Accept(Current current) { }")] - [InlineData("public void Calculate(Length length) { Accept(current: length); } private void Accept(Current current) { }")] - [InlineData("public object Calculate(Length length, Current current) => Current.Min(current, length);")] - [InlineData("public object Calculate(Length length, Current current) => Current.Clamp(current, current, length);")] - [InlineData("public Current Value { get; } = Length.FromMetres(1);")] - [InlineData("public Current Value => Length.FromMetres(1);")] - [InlineData("public Current this[int index] => Length.FromMetres(1);")] - [InlineData("public Consumer(Current current) { } public object Calculate(Length length) => new Consumer(length);")] - public async Task WrongDestinationExplainsExpectedAndActualDimensions(string member) + [InlineData(""" + public void Calculate(Length length) + { + Current current = {|#0:length|}; + } + """, "CS0029")] + [InlineData(""" + public void Calculate(Length length, Current current) + { + current = {|#0:length|}; + } + """, "CS0029")] + [InlineData(""" + public Current Calculate(Length length) => {|#0:length|}; + """, "CS0029")] + [InlineData(""" + public Current Calculate(Length length) + { + return {|#0:length|}; + } + """, "CS0029")] + [InlineData(""" + public void Calculate(Length length) + { + Accept({|#0:length|}); + } + private void Accept(Current current) + { + } + """, "CS1503")] + [InlineData(""" + public void Calculate(Length length) + { + Accept(current: {|#0:length|}); + } + private void Accept(Current current) + { + } + """, "CS1503")] + [InlineData(""" + public object Calculate(Length length, Current current) => Current.Min(current, {|#0:length|}); + """, "CS1503")] + [InlineData(""" + public object Calculate(Length length, Current current) => Current.Clamp(current, current, {|#0:length|}); + """, "CS1503")] + [InlineData(""" + public Current Value { get; } = {|#0:Length.FromMetres(1)|}; + """, "CS0029")] + [InlineData(""" + public Current Value => {|#0:Length.FromMetres(1)|}; + """, "CS0029")] + [InlineData(""" + public Current this[int index] => {|#0:Length.FromMetres(1)|}; + """, "CS0029")] + [InlineData(""" + public Consumer(Current current) + { + } + public object Calculate(Length length) => new Consumer({|#0:length|}); + """, "CS1503")] + public async Task WrongDestinationExplainsExpectedAndActualDimensions(string member, string compilerError) { - string source = $"public class Consumer {{ {member} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0002", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains("Expected Current", result.GetMessage()), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Equal("Consumer.cs", result.Location.SourceTree!.FilePath)); + QuantityAnalyzerTest test = new(); + test.TestState.Sources.Add(("Consumer.cs", $$""" + public class Consumer + { + {{member}} + } + """)); + test.ExpectedDiagnostics.AddRange([ + DiagnosticResult.CompilerError(compilerError).WithLocation(0), + new DiagnosticResult("DQ0002", DiagnosticSeverity.Error).WithLocation(0).WithArguments("Current", "Length") + ]); + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("public object Calculate(Length length, Length other) => length + other;")] - [InlineData("public object Calculate(Length length, Current current) => length * current;")] - [InlineData("public object Calculate(Length length, Current current) => length / current;")] - [InlineData("public object Calculate(Energy energy, Torque torque) => energy + torque;")] - [InlineData("public Current? Calculate() => null;")] - [InlineData("public Current Calculate() => default;")] - [InlineData("public object Calculate(Length length) => length;")] - [InlineData("public object Calculate(Length length) => length + missing;")] - [InlineData("public void Calculate(Length length) { Accept(length); } private void Accept(Length value) { } private void Accept(Current value) { }")] + [InlineData(""" + public object Calculate(Length length, Length other) => length + other; + """)] + [InlineData(""" + public object Calculate(Length length, Current current) => length * current; + """)] + [InlineData(""" + public object Calculate(Length length, Current current) => length / current; + """)] + [InlineData(""" + public object Calculate(Energy energy, Torque torque) => energy + torque; + """)] + [InlineData(""" + public Current? Calculate() => null; + """)] + [InlineData(""" + public Current Calculate() => default; + """)] + [InlineData(""" + public object Calculate(Length length) => length; + """)] + [InlineData(""" + public object Calculate(Length length) => length + {|CS0103:missing|}; + """)] + [InlineData(""" + public void Calculate(Length length) + { + Accept(length); + } + private void Accept(Length value) + { + } + private void Accept(Current value) + { + } + """)] public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) { - ImmutableArray result = await AnalyzerTestCompilation.Analyze($"public class Consumer {{ {member} }}", new DimensionMismatchAnalyzer()); - Assert.Empty(result); + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + public class Consumer + { + {{member}} + } + """ + }; + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -79,42 +169,74 @@ public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) [InlineData("-=")] public async Task CompoundAssignmentsExplainIncompatibleDimensions(string operation) { - string source = $"public class Consumer {{ public void Calculate(Length length, Current current) {{ length {operation} current; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Equal("DQ0001", result.Id); + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + public class Consumer + { + public void Calculate(Length length, Current current) + { + {|#0:length {{operation}} current|}; + } + } + """ + }; + test.ExpectedDiagnostics.AddRange([ + DiagnosticResult.CompilerError("CS0019").WithLocation(0), + new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Current") + ]); + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task NullableOperandsStillExplainDimensions() { - const string source = "public class Consumer { public object Calculate(Length? length, Current? current) => length + current; }"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Equal("DQ0001", result.Id); + QuantityAnalyzerTest test = new() + { + TestCode = """ + public class Consumer + { + public object Calculate(Length? length, Current? current) => {|#0:length + current|}; + } + """ + }; + test.ExpectedDiagnostics.AddRange([ + DiagnosticResult.CompilerError("CS0019").WithLocation(0), + new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments("+", "Length", "Current") + ]); + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task ExistingUserOperatorIsRespected() { - const string source = """ - public static class Custom - { - extension(Length) + QuantityAnalyzerTest test = new() + { + TestCode = """ + public static class Custom { - public static double operator +(Length length, Current current) => 1; + extension(Length) + { + public static double operator +(Length length, Current current) => 1; + } } - } - public class Consumer { public double Calculate(Length length, Current current) => length + current; } - """; - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer()); - Assert.Empty(result); + public class Consumer + { + public double Calculate(Length length, Current current) => length + current; + } + """ + }; + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task UnrelatedCompilationWithoutLibraryDoesNotCrash() { - Microsoft.CodeAnalysis.CSharp.CSharpCompilation compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("Empty"); - ImmutableArray result = await Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(compilation, - [new DimensionMismatchAnalyzer()], options: null).GetAnalyzerDiagnosticsAsync(Xunit.TestContext.Current.CancellationToken); - Assert.Empty(result); + CSharpAnalyzerTest test = new() + { + ReferenceAssemblies = ReferenceAssemblies.Net.Net100 + }; + test.TestState.Sources.Add(("Consumer.cs", "")); + await test.RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs index 36010d3..ac73a92 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs @@ -1,6 +1,7 @@ -using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; @@ -12,12 +13,18 @@ public sealed class QuantityEncodingAnalyzerTests [Fact] public async Task RawQuantitySuggestsReadableAlias() { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {LengthType} Value {{ get; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0003", result.Id), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Equal(LengthType, source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public {|#0:{{LengthType}}|} Value { get; } + } + """ + }; + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0003", DiagnosticSeverity.Info).WithLocation(0).WithArguments("Length")); + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -25,48 +32,98 @@ public async Task RawQuantitySuggestsReadableAlias() [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] public async Task NonCanonicalEncodingExplainsDistinctTypeIdentity(string exponent) { - string type = $"global::DimensionalQuantities.TypeSystem.Quantity>"; - string source = $"using MyLength = {type}; public class Consumer {{ }}"; - ImmutableArray results = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer()); - Diagnostic result = Assert.Single(results); - Assert.Multiple( - () => Assert.Equal("DQ0004", result.Id), - () => Assert.Equal(DiagnosticSeverity.Warning, result.Severity)); + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + using MyLength = global::DimensionalQuantities.TypeSystem.{|#0:{{type}}|}; + public class Consumer + { + } + """ + }; + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0004", DiagnosticSeverity.Warning).WithLocation(0)); + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("Quantity")] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>")] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>")] - public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string type) + [InlineData("Quantity", false)] + [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] + [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] + public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string type, bool invalidConstraint) { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {type} Value {{ get; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer(), generate: false)); - Assert.Multiple( - () => Assert.Equal("DQ0005", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity)); + QuantityAnalyzerTest test = new(generate: false) + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public {|#0:{{type}}|} {|#1:Value|} { get; } + } + """ + }; + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0005", DiagnosticSeverity.Error).WithLocation(0)); + if (invalidConstraint) + { + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0315").WithLocation(1)); + } + + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("Quantity")] - [InlineData("Power")] + [InlineData("Quantity<{|CS0246:Missing|}>")] + [InlineData("Power<{|CS0246:Missing|}>")] public async Task UnresolvedArgumentsDoNotProduceEncodingDiagnostics(string type) { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {type} Value {{ get; }} }}"; - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer(), generate: false); - Assert.Empty(result); + QuantityAnalyzerTest test = new(generate: false) + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public {{type}} Value { get; } + } + """ + }; + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("using MyLength = DimensionalQuantities.TypeSystem.Quantity>; public class Consumer { public MyLength Value { get; } }")] - [InlineData("public class Consumer { public Length Value { get; } }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public Quantity Value { get; } }")] - [InlineData("public class Quantity { } public class Consumer { public Quantity Value { get; } }")] + [InlineData(""" + using MyLength = DimensionalQuantities.TypeSystem.Quantity>; + public class Consumer + { + public MyLength Value { get; } + } + """)] + [InlineData(""" + public class Consumer + { + public Length Value { get; } + } + """)] + [InlineData(""" + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public Quantity Value { get; } + } + """)] + [InlineData(""" + public class Quantity + { + } + public class Consumer + { + public Quantity Value { get; } + } + """)] public async Task DeliberateAliasesOpenGenericsAndUnrelatedTypesAreAllowed(string source) { - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer()); - Assert.Empty(result); + QuantityAnalyzerTest test = new() { TestCode = source }; + await test.RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs index e2e6779..eef20fc 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs @@ -1,94 +1,149 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Analyzers; -using DimensionalQuantities.Roslyn.CodeFixes; -using DimensionalQuantities.Roslyn.Tests.Analyzers; +using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CodeActions; -using Microsoft.CodeAnalysis.CodeFixes; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.CodeAnalysis.Text; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; public sealed class QuantityAliasCodeFixProviderTests { - private const string LengthType = "global::DimensionalQuantities.TypeSystem.Quantity>"; - private const string LengthCurrentType = "global::DimensionalQuantities.TypeSystem.Quantity>"; [Theory] - [InlineData("public class Consumer { public TYPE Value { get; } }", "public class Consumer { public Length Value { get; } }")] - [InlineData("public class Consumer { public TYPE? Value { get; } }", "public class Consumer { public Length? Value { get; } }")] - [InlineData("public class Consumer { public /* measurement */ TYPE Value { get; } }", "public class Consumer { public /* measurement */ Length Value { get; } }")] - [InlineData("public class Consumer { public TYPE Value { get; } }", "public class Consumer { public LengthCurrent Value { get; } }", LengthCurrentType)] + [InlineData(""" + public class Consumer + { + public TYPE Value { get; } + } + """, """ + public class Consumer + { + public Length Value { get; } + } + """)] + [InlineData(""" + public class Consumer + { + public TYPE? Value { get; } + } + """, """ + public class Consumer + { + public Length? Value { get; } + } + """)] + [InlineData(""" + public class Consumer + { + public /* measurement */ TYPE Value { get; } + } + """, """ + public class Consumer + { + public /* measurement */ Length Value { get; } + } + """)] + [InlineData(""" + public class Consumer + { + public TYPE Value { get; } + } + """, """ + public class Consumer + { + public LengthCurrent Value { get; } + } + """, LengthCurrentType)] public async Task FixUsesAliasAndPreservesSurroundingSource(string template, string expected, string? rawType = null) { - string source = template.Replace("TYPE", rawType ?? LengthType); - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - Diagnostic diagnostic = Assert.Single(await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken)); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - CodeAction action = Assert.Single(actions); - ImmutableArray operations = await action.GetOperationsAsync(TestContext.Current.CancellationToken); - ApplyChangesOperation changes = Assert.Single(operations.OfType()); - Document changed = changes.ChangedSolution.GetDocument(document.Id)!; - string result = (await changed.GetTextAsync(TestContext.Current.CancellationToken)).ToString(); - CSharpCompilation finalCompilation = AnalyzerTestCompilation.Create(result); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.DoesNotContain(finalCompilation.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)); + string type = rawType ?? LengthType; + QuantityCodeFixTest test = new() + { + TestCode = template.Replace("TYPE", $$""" + global::DimensionalQuantities.TypeSystem.{|#0:{{type}}|} + """), + FixedCode = expected, + CodeActionEquivalenceKey = rawType is null ? "UseAlias:Length" : "UseAlias:LengthCurrent" + }; + test.ExpectedDiagnostics.Add(Suggestion(0, rawType is null ? "Length" : "LengthCurrent")); + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task NameOfDoesNotOfferFixThatChangesTheReturnedName() { - string source = $"public class Consumer {{ public string Value() => nameof({LengthType}); }}"; - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - Diagnostic diagnostic = Assert.Single(await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken)); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - Assert.Empty(actions); + QuantityCodeFixTest test = new() + { + TestCode = $$""" + public class Consumer + { + public string Value() => nameof(global::DimensionalQuantities.TypeSystem.{|#0:{{LengthType}}|}); + } + """, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task ShadowedAliasDoesNotOfferUnsafeFix() { - string source = $"namespace ConsumerNamespace {{ public class Length {{ }} public class Consumer {{ public {LengthType} Value {{ get; }} }} }}"; - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - ImmutableArray diagnostics = await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - foreach (Diagnostic diagnostic in diagnostics.Where(diagnostic => diagnostic.Id == "DQ0003")) + QuantityCodeFixTest test = new() { - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - } - Assert.Empty(actions); + TestCode = $$""" + namespace ConsumerNamespace + { + public class Length + { + } + public class Consumer + { + public global::DimensionalQuantities.TypeSystem.{|#0:{{LengthType}}|} Value { get; } + } + } + """, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); } - private static Document CreateDocument(AdhocWorkspace workspace, string source) + [Fact] + public async Task FixAllReplacesMultipleRawQuantities() { - CSharpCompilation compilation = AnalyzerTestCompilation.Create(source); - Project project = workspace.AddProject(ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Consumer", "Consumer", LanguageNames.CSharp, - compilationOptions: compilation.Options, parseOptions: new CSharpParseOptions(LanguageVersion.Preview), metadataReferences: compilation.References)); - Document userDocument = workspace.AddDocument(project.Id, "Consumer.cs", SourceText.From(source)); - foreach (SyntaxTree tree in compilation.SyntaxTrees.Where(tree => tree.FilePath != "Consumer.cs")) + QuantityCodeFixTest test = new() { - workspace.AddDocument(project.Id, Path.GetFileName(tree.FilePath), tree.GetText()); - } - return workspace.CurrentSolution.GetDocument(userDocument.Id)!; + TestCode = $$""" + public class Consumer + { + public global::DimensionalQuantities.TypeSystem.{|#0:{{LengthType}}|} First { get; } + public global::DimensionalQuantities.TypeSystem.{|#1:{{LengthType}}|} Second { get; } + } + """, + FixedCode = """ + public class Consumer + { + public Length First { get; } + public Length Second { get; } + } + """, + CodeActionEquivalenceKey = "UseAlias:Length", + NumberOfIncrementalIterations = 2, + NumberOfFixAllIterations = 1, + NumberOfFixAllInDocumentIterations = 1 + }; + test.ExpectedDiagnostics.AddRange([Suggestion(0, "Length"), Suggestion(1, "Length")]); + await test.RunAsync(TestContext.Current.CancellationToken); } + + private static DiagnosticResult Suggestion(int location, string alias) => new DiagnosticResult("DQ0003", DiagnosticSeverity.Info).WithLocation(location).WithArguments(alias); } diff --git a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj index 8766356..f4692dd 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj +++ b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj @@ -16,6 +16,11 @@ + + + + + diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityAnalyzerTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityAnalyzerTest.cs new file mode 100644 index 0000000..cac9985 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityAnalyzerTest.cs @@ -0,0 +1,17 @@ +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Diagnostics; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Framework; + +internal sealed class QuantityAnalyzerTest : CSharpAnalyzerTest where TAnalyzer : DiagnosticAnalyzer, new() +{ + public QuantityAnalyzerTest(bool generate = true) + { + QuantityTestEnvironment.Configure(this); + if (generate) + { + SolutionTransforms.Add((solution, project) => solution.AddAnalyzerReference(project, new QuantitySourceReference())); + } + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs new file mode 100644 index 0000000..c712bda --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs @@ -0,0 +1,26 @@ +using System.Collections.Immutable; +using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.CodeFixes; +using Microsoft.CodeAnalysis.CodeActions; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.Framework; + +internal sealed class QuantityCodeFixTest : CSharpCodeFixTest +{ + public QuantityCodeFixTest() + { + QuantityTestEnvironment.Configure(this); + // Fixes resolve aliases through their Document.Project, so the workspace must run the generator. + SolutionTransforms.Add((solution, project) => solution.AddAnalyzerReference(project, new QuantitySourceReference())); + } + + protected override ImmutableArray FilterCodeActions(ImmutableArray actions) + { + // Framework selection accepts the first matching action, so reject additional alternatives. + Assert.InRange(actions.Length, 0, 1); + return base.FilterCodeActions(actions); + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityGeneratorTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityGeneratorTest.cs new file mode 100644 index 0000000..d3bf25d --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityGeneratorTest.cs @@ -0,0 +1,29 @@ +using System.Collections.Immutable; +using DimensionalQuantities.Roslyn.Generators; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Framework; + +internal class QuantityGeneratorTest : CSharpSourceGeneratorTest +{ + public QuantityGeneratorTest() + { + QuantityTestEnvironment.Configure(this); + } + + public Compilation Compilation { get; private set; } = null!; + + protected override async Task<(Compilation compilation, ImmutableArray generatorDiagnostics)> GetProjectCompilationAsync( + Project project, IVerifier verifier, CancellationToken cancellationToken) + { + (Compilation compilation, ImmutableArray generatorDiagnostics) result = await base.GetProjectCompilationAsync(project, verifier, cancellationToken); + if (project.Name == TestState.Name) + { + Compilation = result.compilation; + } + + return result; + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantitySourceReference.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantitySourceReference.cs new file mode 100644 index 0000000..89f7ddb --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantitySourceReference.cs @@ -0,0 +1,17 @@ +using System.Collections.Immutable; +using DimensionalQuantities.Roslyn.Generators; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Diagnostics; + +namespace DimensionalQuantities.Roslyn.Tests.Framework; + +internal sealed class QuantitySourceReference : AnalyzerReference +{ + private readonly ImmutableArray _generators = [new QuantityGenerator().AsSourceGenerator()]; + + public override string? FullPath => null; + public override object Id => typeof(QuantityGenerator); + public override ImmutableArray GetAnalyzers(string language) => []; + public override ImmutableArray GetAnalyzersForAllLanguages() => []; + public override ImmutableArray GetGenerators(string language) => language == LanguageNames.CSharp ? _generators : []; +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityTestEnvironment.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityTestEnvironment.cs new file mode 100644 index 0000000..51d28a3 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityTestEnvironment.cs @@ -0,0 +1,16 @@ +using DimensionalQuantities.TypeSystem; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Framework; + +internal static class QuantityTestEnvironment +{ + public static void Configure(AnalyzerTest test) where TVerifier : IVerifier, new() + { + test.ReferenceAssemblies = ReferenceAssemblies.Net.Net100; + test.TestState.AdditionalReferences.Add(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); + test.SolutionTransforms.Add((solution, project) => solution.WithProjectParseOptions(project, new CSharpParseOptions(LanguageVersion.Preview))); + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs index 7c633c0..da41768 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs @@ -1,8 +1,5 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; +using DimensionalQuantities.Roslyn.Tests.Framework; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -10,15 +7,25 @@ namespace DimensionalQuantities.Roslyn.Tests.Generators; public sealed class CoreConversionBoundaryTests { [Theory] - [InlineData("Voltage.FromVolts(12)")] - [InlineData("Voltage.FromPrefixedUnits(12, 0)")] - [InlineData("Voltage.FromSiBaseUnit(12).AsVolts()")] - [InlineData("Voltage.FromSiBaseUnit(12).AsPrefixedUnits(0)")] - public void CatalogueConversionsRequireAnExtensionPackage(string expression) + [InlineData("Voltage.{|#0:FromVolts|}(12)", "CS0117")] + [InlineData("{|#0:Voltage|}.FromPrefixedUnits(12, 0)", "CS1929")] + [InlineData("Voltage.FromSiBaseUnit(12).{|#0:AsVolts|}()", "CS1061")] + [InlineData("{|#0:Voltage.FromSiBaseUnit(12)|}.AsPrefixedUnits(0)", "CS1929")] + public async Task CatalogueConversionsRequireAnExtensionPackage(string expression, string error) { - Diagnostic[] result = Compile($"public class Consumer {{ public object Value() => {expression}; }}"); + QuantityGeneratorTest test = new() + { + TestCode = $$""" + public class Consumer + { + public object Value() => {{expression}}; + } + """, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError(error).WithLocation(0)); - Assert.Contains(result, diagnostic => diagnostic.Id is "CS0117" or "CS1061" or "CS1929"); + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -28,25 +35,19 @@ public void CatalogueConversionsRequireAnExtensionPackage(string expression) [InlineData("Voltage.FromArbitrarySiComponents(12).AsArbitrarySiComponents()")] [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).AsPrefixedUnits(3, 0)")] [InlineData("Voltage.FromSiBaseUnit(12).Squared().AsSiBaseUnit()")] - public void BaseGenericAndIntermediateConversionsRemainAvailable(string expression) + public async Task BaseGenericAndIntermediateConversionsRemainAvailable(string expression) { - Diagnostic[] result = Compile($"public class Consumer {{ public object Value() => {expression}; }}"); + QuantityGeneratorTest test = new() + { + TestCode = $$""" + public class Consumer + { + public object Value() => {{expression}}; + } + """, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; - Assert.Empty(result); - } - - private static Diagnostic[] Compile(string source) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("Consumer", [CSharpSyntaxTree.ParseText(source, options)], - references, new(OutputKind.DynamicallyLinkedLibrary)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation result, out ImmutableArray diagnostics, - TestContext.Current.CancellationToken); - return diagnostics.Concat(result.GetDiagnostics(TestContext.Current.CancellationToken)) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + await test.RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs new file mode 100644 index 0000000..eda5454 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs @@ -0,0 +1,33 @@ +using DimensionalQuantities.Numerics; +using DimensionalQuantities.Roslyn.Generators; +using DimensionalQuantities.Units; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.Generators; + +public sealed class FractionalPrefixEmitterTests +{ + [Theory] + [InlineData(""" + public static Length FromPrefixedUnits(double value, int widgetPrefixExponent = 0) => Length.FromSiBaseUnit(value * 2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); + """)] + [InlineData(""" + public double AsPrefixedUnits(int widgetPrefixExponent = 0) => length.AsSiBaseUnit() / (2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); + """)] + [InlineData(""" + public double AsPrefixedUnits(int widgetPrefixExponent = 0) => delta.AsSiBaseUnit() / (2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); + """)] + public void FractionalPrefixConversionsUseFloatingPointDivision(string expectedDeclaration) + { + AtomicUnit widget = new("Widget", "Widgets", "w", Scale: 4); + UnitConversionSpec[] units = + [ + new("Length", "Length", [new UnitDefinition("Length", [new(widget, new Rational(1, 2))])], + IncludeNamed: false, GenerateSiPrefixes: false, GeneratePrefixConversions: true) + ]; + + string source = UnitConversionSourceEmitter.Emit(units, "Custom", "public"); + + Assert.Contains(expectedDeclaration, source); + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs index c175137..2e824b0 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs @@ -1,8 +1,10 @@ using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Generators; +using DimensionalQuantities.Roslyn.Tests.Framework; using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -10,159 +12,401 @@ namespace DimensionalQuantities.Roslyn.Tests.Generators; public sealed class GenerationDiagnosticTests { [Fact] - public void GeneratedAliasWarnsWhenItShadowsAnImportedType() + public async Task GeneratedAliasWarnsWhenItShadowsAnImportedType() { - const string source = """ + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ using Other; - namespace Other { public class Current { } } - public class Consumer { public Current Value { get; } } - """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Multiple( - () => Assert.Equal("DQ0006", result.Id), - () => Assert.Equal(DiagnosticSeverity.Warning, result.Severity), - () => Assert.Contains("Current", result.GetMessage()), - () => Assert.Equal("Consumer.cs", result.Location.SourceTree!.FilePath)); + namespace Other + { + public class Current { } + } + public class Consumer + { + public {|#0:Current|} Value { get; } + } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void ImportedMetadataTypeShadowingIsDiagnosed() + public async Task ImportedMetadataTypeShadowingIsDiagnosed() { - CSharpCompilation library = CreateCompilation("namespace Other { public class Current { } }").WithAssemblyName("OtherLibrary"); - using MemoryStream bytes = new(); - Microsoft.CodeAnalysis.Emit.EmitResult emitted = library.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) + QuantityGeneratorTest test = new() { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - CSharpCompilation consumer = CreateCompilation("using Other; public class Consumer { public Current Value { get; } }") - .AddReferences(MetadataReference.CreateFromImage(bytes.ToArray())); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(consumer, TestContext.Current.CancellationToken); - Diagnostic result = Assert.Single(driver.GetRunResult().Diagnostics); + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using Other; + public class Consumer + { + public {|#0:Current|} Value { get; } + } + """)); + test.TestState.AdditionalReferences.Add(await CreateImportedLibraryReference()); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - Assert.Equal("DQ0006", result.Id); + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void CollisionWarningPreservesTheGeneratedAliasBinding() + public async Task CollisionWarningPreservesTheGeneratedAliasBinding() { - const string source = "using Other; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - CSharpCompilation original = CreateCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver.RunGeneratorsAndUpdateCompilation(original, out Compilation generated, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - IPropertySymbol property = (IPropertySymbol)generated.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using Other; + namespace Other + { + public class Current { } + } + public class Consumer + { + public {|#0:Current|} Value { get; } + } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + + await test.RunAsync(TestContext.Current.CancellationToken); + IPropertySymbol property = (IPropertySymbol)test.Compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); INamedTypeSymbol result = ((INamedTypeSymbol)property.Type).OriginalDefinition; - INamedTypeSymbol expected = generated.GetTypeByMetadataName(typeof(Quantity<>).FullName!)!; + INamedTypeSymbol expected = test.Compilation.GetTypeByMetadataName(typeof(Quantity<>).FullName!)!; - Assert.Multiple( - () => Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "DQ0006"), - () => Assert.True(SymbolEqualityComparer.Default.Equals(expected, result))); + Assert.True(SymbolEqualityComparer.Default.Equals(expected, result)); } - [Theory] - [InlineData("public class Current { } public class Consumer { }")] - [InlineData("public delegate void Current();")] - [InlineData("using Current = Other.Current; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }")] - public void ConflictingDeclarationsAndExplicitAliasesWarn(string source) + [Fact] + public async Task ConflictingGlobalTypeDeclarationWarns() { - ImmutableArray results = Generate(source); - Assert.Contains(results, diagnostic => diagnostic.Id == "DQ0006" && diagnostic.Severity == DiagnosticSeverity.Warning); + QuantityGeneratorTest test = new() + { + // The conflicting global name causes cascading errors throughout the generated catalogue. + // This case verifies the collision warning; successful compilations are checked separately. + CompilerDiagnostics = CompilerDiagnostics.None, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + public class {|#0:Current|} { } + public class Consumer { } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void StaticMemberUseOfImportedTypeWarnsWhenShadowed() + public async Task ConflictingDelegateDeclarationWarns() { - const string source = """ + QuantityGeneratorTest test = new() + { + // The conflicting global name causes cascading errors throughout the generated catalogue. + // This case verifies the collision warning; successful compilations are checked separately. + CompilerDiagnostics = CompilerDiagnostics.None, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + public delegate void {|#0:Current|}(); + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task ConflictingExplicitAliasWarns() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using {|#0:Current|} = Other.Current; + namespace Other + { + public class Current { } + } + public class Consumer + { + public Current Value { get; } + } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1537").WithLocation(0)); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task StaticMemberUseOfImportedTypeWarnsWhenShadowed() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ using Other; - namespace Other { public class Current { public static int Create() => 1; } } - public class Consumer { public int Value => Current.Create(); } - """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Equal("DQ0006", result.Id); + namespace Other + { + public class Current + { + public static int Create() => 1; + } + } + public class Consumer + { + public int Value => {|#0:Current|}.{|#1:Create|}(); + } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) + .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0117").WithLocation(1)); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() + public async Task UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() { - const string source = "namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - Assert.Empty(Generate(source)); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + namespace Other + { + public class Current { } + } + public class Consumer + { + public Current Value { get; } + } + """)); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void QualifiedReferenceToSameNamedTypeDoesNotWarn() + public async Task QualifiedReferenceToSameNamedTypeDoesNotWarn() { - const string source = "namespace Other { public class Current { } } public class Consumer { public Other.Current Value { get; } }"; - Assert.Empty(Generate(source)); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + namespace Other + { + public class Current { } + } + public class Consumer + { + public Other.Current Value { get; } + } + """)); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Theory] [InlineData("NumberTwoOverZero")] [InlineData("NumberBanana")] - public void InvalidEnglishExponentExplainsUnresolvedRequest(string name) + public async Task InvalidEnglishExponentExplainsUnresolvedRequest(string name) { - string source = $$""" + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", $$""" using DimensionalQuantities.TypeSystem; - public class Consumer { public object Calculate(Length length) => Power<{{name}}>.Of(length); } - """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Multiple( - () => Assert.Equal("DQ0007", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains(name, result.GetMessage()), - () => Assert.Equal(name, source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + public class Consumer + { + public object Calculate(Length length) => {|#1:Power<{|#0:{{name}}|}>|}.Of(length); + } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0007", DiagnosticSeverity.Error) + .WithLocation(0).WithMessage($"English exponent '{name}' cannot be resolved")); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() + public async Task FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - CSharpCompilation compilation = CreateCompilation(source).AddSyntaxTrees(CSharpSyntaxTree.ParseText( - "using NumberBanana = System.Int32; public class OtherConsumer { }", - new CSharpParseOptions(LanguageVersion.Preview), "OtherConsumer.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(compilation, TestContext.Current.CancellationToken); - Diagnostic diagnostic = Assert.Single(driver.GetRunResult().Diagnostics); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public object Calculate(Length length) => {|#1:Power<{|#0:NumberBanana|}>|}.Of(length); + } + """)); + test.TestState.Sources.Add(("OtherConsumer.cs", """ + using NumberBanana = System.Int32; + public class OtherConsumer { } + """)); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0007", DiagnosticSeverity.Error) + .WithLocation(0).WithMessage("English exponent 'NumberBanana' cannot be resolved")); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - Assert.Multiple( - () => Assert.Equal("DQ0007", diagnostic.Id), - () => Assert.Equal("Consumer.cs", diagnostic.Location.SourceTree!.FilePath)); + await test.RunAsync(TestContext.Current.CancellationToken); } - [Theory] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("public class Power { public static double Of(double value) => value; } public class Consumer { public object Calculate() => Power.Of(2); }")] - [InlineData("using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex2; using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class NumberBanana { } public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - public void BoundNamesAndUnrelatedRequestsDoNotProduceGenerationDiagnostics(string source) + [Fact] + public async Task ValidEnglishExponentDoesNotProduceGenerationDiagnostics() { - Assert.Empty(Generate(source)); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public object Calculate(Length length) => Power.Of(length); + } + """)); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void InvalidNumericEncodingDoesNotCrashGenerator() + public async Task UnrelatedMissingNameDoesNotProduceGenerationDiagnostics() { - const string source = """ + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ using DimensionalQuantities.TypeSystem; public class Consumer { - public object Calculate(Length length) => Power>.Of(length); + public object Calculate(Length length) => {|#1:Power<{|#0:Missing|}>|}.Of(length); } - """; - ImmutableArray results = Generate(source); - Assert.DoesNotContain(results, diagnostic => diagnostic.Id == "CS8785"); + """)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task UnrelatedPowerTypeDoesNotProduceGenerationDiagnostics() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + public class Power + { + public static double Of(double value) => value; + } + public class Consumer + { + public object Calculate() => Power<{|#0:NumberBanana|}>.Of(2); + } + """)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task ExplicitlyBoundExponentDoesNotProduceGenerationDiagnostics() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex2; + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public object Calculate(Length length) => Power.Of(length); + } + """)); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task BoundInvalidEnglishNameDoesNotProduceGenerationDiagnostics() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using DimensionalQuantities.TypeSystem; + public class NumberBanana { } + public class Consumer + { + public object Calculate(Length length) => {|#1:Power<{|#0:NumberBanana|}>|}.Of(length); + } + """)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0453").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); + + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task InvalidNumericEncodingDoesNotCrashGenerator() + { + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", """ + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public object Calculate(Length length) => {|#0:Power>|}.Of(length); + } + """)); + + test.ExpectedDiagnostics.AddRange([ + DiagnosticResult.CompilerError("CS1929").WithLocation(0), + DiagnosticResult.CompilerError("CS0315").WithLocation(1) + ]); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] public void CorrectingAnEnglishExponentRemovesItsDiagnostic() { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - CSharpCompilation original = CreateCompilation(source); + const string source = """ + using DimensionalQuantities.TypeSystem; + public class Consumer + { + public object Calculate(Length length) => Power.Of(length); + } + """; + CSharpCompilation original = CreateLifecycleCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); driver = driver.RunGenerators(original, TestContext.Current.CancellationToken); ImmutableArray initial = driver.GetRunResult().Diagnostics; - CSharpCompilation edited = CreateCompilation(source.Replace("NumberBanana", "NumberTwo")); + CSharpCompilation edited = CreateLifecycleCompilation(source.Replace("NumberBanana", "NumberTwo")); driver = driver.RunGenerators(edited, TestContext.Current.CancellationToken); ImmutableArray result = driver.GetRunResult().Diagnostics; @@ -171,14 +415,30 @@ public void CorrectingAnEnglishExponentRemovesItsDiagnostic() () => Assert.Empty(result)); } - private static ImmutableArray Generate(string source) + private static async Task CreateImportedLibraryReference() { - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(CreateCompilation(source), TestContext.Current.CancellationToken); - return driver.GetRunResult().Diagnostics; + const string source = """ + namespace Other + { + public class Current { } + } + """; + ImmutableArray references = await ReferenceAssemblies.Net.Net100.ResolveAsync( + LanguageNames.CSharp, TestContext.Current.CancellationToken); + CSharpCompilation library = CSharpCompilation.Create("OtherLibrary", + [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))], + references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); + using MemoryStream bytes = new(); + Microsoft.CodeAnalysis.Emit.EmitResult result = library.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); + if (!result.Success) + { + throw new InvalidOperationException(string.Join(Environment.NewLine, result.Diagnostics)); + } + + return MetadataReference.CreateFromImage(bytes.ToArray()); } - private static CSharpCompilation CreateCompilation(string source) + private static CSharpCompilation CreateLifecycleCompilation(string source) { string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs index 32849f3..2ae5477 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs @@ -4,12 +4,14 @@ using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Discovery; using DimensionalQuantities.Roslyn.Generators; +using DimensionalQuantities.Roslyn.Tests.Framework; using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Emit; using Microsoft.CodeAnalysis.Text; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -19,7 +21,7 @@ public sealed class QuantityGeneratorTests private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); [Fact] - public void BaseAliasesHaveUnprefixedFactoriesAndAccessors() + public async Task BaseAliasesHaveUnprefixedFactoriesAndAccessors() { const string source = """ public static class Consumer @@ -39,11 +41,11 @@ public static double UseBaseQuantities() } """; - Compile(source); + await Compile(source); } [Fact] - public void SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() + public async Task SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() { const string source = """ public static class Consumer @@ -51,7 +53,13 @@ public static class Consumer public static Length Use(Length input) => Length.FromMetres(2); } """; - CSharpCompilation result = Compile(source, new SemanticProbeGenerator()); + SemanticProbeTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation result = test.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; IFieldSymbol aliasResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("AliasResolved"))); IFieldSymbol factoryResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); @@ -62,7 +70,7 @@ public static class Consumer } [Fact] - public void CatalogueAliasesAreAvailableToConsumers() + public async Task CatalogueAliasesAreAvailableToConsumers() { const string source = """ public static class Consumer @@ -81,7 +89,7 @@ public static class Consumer } """; - Compile(source); + await Compile(source); } [Theory] @@ -104,16 +112,16 @@ public static class Consumer [InlineData("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] [InlineData("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] [InlineData("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] - public void QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) + public async Task QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) { string expression = $"(({resultType})({arithmetic})).AsSiBaseUnit()"; - double result = Evaluate(expression); + double result = await Evaluate(expression); Assert.Equal(expected, result); } [Fact] - public void QuantityArithmeticAcceptsTypedMethodParametersAndReturns() + public async Task QuantityArithmeticAcceptsTypedMethodParametersAndReturns() { const string source = """ public static class Consumer @@ -124,11 +132,11 @@ public static class Consumer } """; - Compile(source); + await Compile(source); } [Fact] - public void RepeatedConsumerOperationIsEmittedOnce() + public async Task RepeatedConsumerOperationIsEmittedOnce() { const string source = """ public static class Consumer @@ -137,14 +145,14 @@ public static class Consumer public static Area Second(Length left, Length right) => left * right; } """; - CSharpCompilation compilation = Compile(source); + CSharpCompilation compilation = await Compile(source); INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")!; Assert.Single(extensions.GetMembers().OfType(), method => method.MetadataName == "op_Multiply"); } [Fact] - public void ArithmeticReadsFieldAndMethodReturnTypes() + public async Task ArithmeticReadsFieldAndMethodReturnTypes() { const string source = """ public static class Consumer @@ -154,11 +162,11 @@ public static class Consumer public static Power Calculate() => Input * Input * GetResistance(); } """; - Compile(source); + await Compile(source); } [Fact] - public void DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() + public async Task DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() { const string source = """ public static class Consumer @@ -166,7 +174,7 @@ public static class Consumer public static Current Scale(Current original, double factor) => factor * original / 2; } """; - CSharpCompilation compilation = Compile(source); + CSharpCompilation compilation = await Compile(source); Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); } @@ -258,27 +266,28 @@ public static class Consumer } [Fact] - public void GeneratorIgnoresUnrelatedAndIncompleteArithmetic() + public async Task GeneratorIgnoresUnrelatedAndIncompleteArithmetic() { const string source = """ public static class Consumer { public static int Number(int left, int right) => left * right; - public static object Incomplete(Length length) => length * Missing; + public static object Incomplete(Length length) => length * {|#0:Missing|}; } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray generatorDiagnostics, - TestContext.Current.CancellationToken); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0103").WithLocation(0)); + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation output = test.Compilation; - Assert.Multiple( - () => Assert.Empty(generatorDiagnostics), - () => Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions"))); + Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); } - [Fact] public void LocalInitialiserEditsRefreshDependentOperatorsAndRemoveObsoleteOutput() { @@ -294,7 +303,12 @@ public static double Value(Current current, Length length, Time time) } """; string editedSource = source.Replace("current * length", "length * length", StringComparison.Ordinal); - const string removedSource = "public static class Consumer { public static double Value() => 0; }"; + const string removedSource = """ + public static class Consumer + { + public static double Value() => 0; + } + """; CSharpCompilation input = CreateInputCompilation(source); SyntaxTree originalTree = Assert.Single(input.SyntaxTrees); SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); @@ -346,7 +360,7 @@ public static double Value(Current current, Length length, Time time) [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] [InlineData("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] - public void SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) + public async Task SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) { string source = $$""" public static class Consumer @@ -354,8 +368,8 @@ public static class Consumer public static double Value() => ({{expression}}).{{accessor}}(); } """; - double result = EvaluateSource(source); - CSharpCompilation compilation = Compile(source); + CSharpCompilation compilation = await Compile(source); + double result = EvaluateCompilation(compilation); Assert.Multiple( () => Assert.Equal(expected, result), @@ -366,7 +380,7 @@ public static class Consumer [InlineData("firstSquared + secondSquared", 52)] [InlineData("firstSquared - secondSquared", 20)] [InlineData("-firstSquared", -36)] - public void SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) + public async Task SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) { string source = $$""" public static class Consumer @@ -384,7 +398,7 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result); } @@ -393,9 +407,9 @@ public static double Value() [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] [InlineData("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] - public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) + public async Task SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) { - double result = Evaluate(expression); + double result = await Evaluate(expression); Assert.Equal(expected, result); } @@ -405,22 +419,25 @@ public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(strin [InlineData("current - length")] [InlineData("current + 2")] [InlineData("2 - current")] - public void InvalidSameDimensionArithmeticRemainsACompilerError(string expression) + public async Task InvalidSameDimensionArithmeticRemainsACompilerError(string expression) { string source = $$""" public static class Consumer { - public static object Value(Current current, Length length) => {{expression}}; + public static object Value(Current current, Length length) => {|#0:{{expression}}|}; } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0019").WithLocation(0)); + await test.RunAsync(TestContext.Current.CancellationToken); + Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Equal("CS0019", Assert.Single(errors).Id)); + Assert.Equal("CS0019", Assert.Single(errors).Id); } [Theory] @@ -430,9 +447,9 @@ public static class Consumer [InlineData("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] [InlineData("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] [InlineData("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] - public void CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) + public async Task CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) { - double result = Evaluate(expression); + double result = await Evaluate(expression); Assert.Equal(expected, result); } @@ -444,7 +461,7 @@ public void CancelledDimensionsCompileAndExecuteAsDouble(string expression, doub [InlineData("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] [InlineData("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] [InlineData("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] - public void CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) + public async Task CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) { string source = $$""" public static class Consumer @@ -459,7 +476,7 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result); } @@ -475,7 +492,7 @@ public static double Value() [InlineData("Fraction", -8, -2)] [InlineData("Fraction", -8, 4)] [InlineData("Fraction, TerminalHex3>", -8, -0.5)] - public void EncodedPowersCompileAndExecute(string exponent, double value, double expected) + public async Task EncodedPowersCompileAndExecute(string exponent, double value, double expected) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -484,7 +501,7 @@ public static class Consumer public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result, 12); } @@ -498,7 +515,7 @@ public static class Consumer [InlineData("NumberTwoOverThree", -8, 4)] [InlineData("NumberMinusOneOverThree", -8, -0.5)] [InlineData("NumberMillionth", 1, 1)] - public void EnglishPowersCompileAndExecute(string exponent, double value, double expected) + public async Task EnglishPowersCompileAndExecute(string exponent, double value, double expected) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -507,20 +524,27 @@ public static class Consumer public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result, 12); } [Fact] - public void GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() + public async Task GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() { - CSharpCompilation unused = Compile("class Consumer { }"); + CSharpCompilation unused = await Compile(""" + class Consumer + { + } + """); const string source = """ using DimensionalQuantities.TypeSystem; - class Consumer { object Value(Length value) => Power.Of(value); } + class Consumer + { + object Value(Length value) => Power.Of(value); + } """; - CSharpCompilation used = Compile(source); + CSharpCompilation used = await Compile(source); string[] unusedNames = unused.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); string[] usedNames = used.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) @@ -538,21 +562,40 @@ class Consumer { object Value(Length value) => Power.Of(value); } [InlineData("typeof(NumberTwo)")] [InlineData("Power.Other(value)")] [InlineData("Other.Power.Of(value)")] - public void EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) + public async Task EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) { + string markedExpression = expression.Replace("NumberTwo", "{|#0:NumberTwo|}", StringComparison.Ordinal) + .Replace(".Other", ".{|#1:Other|}", StringComparison.Ordinal); string source = $$""" using DimensionalQuantities.TypeSystem; - namespace Other { public struct Power { public static object Of(object value) => value; } } - class Consumer { object Value(Length value) => {{expression}}; } + namespace Other + { + public struct Power + { + public static object Of(object value) => value; + } + } + class Consumer + { + object Value(Length value) => {{markedExpression}}; + } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + if (expression == "Power.Other(value)") + { + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0117").WithLocation(1)); + } + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation output = test.Compilation; string[] aliases = output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.DoesNotContain("NumberTwo", aliases), () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))); } @@ -562,7 +605,10 @@ public void RemovingEnglishPowerCallsRemovesTheirAliases() { const string source = """ using DimensionalQuantities.TypeSystem; - class Consumer { object Value(Length value) => Power.Of(value); } + class Consumer + { + object Value(Length value) => Power.Of(value); + } """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); @@ -582,7 +628,7 @@ class Consumer { object Value(Length value) => Power.Of(value); } } [Fact] - public void EnglishPowersWorkWithNestedCallsArithmeticAndLocals() + public async Task EnglishPowersWorkWithNestedCallsArithmeticAndLocals() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -598,13 +644,13 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(15, result); } [Fact] - public void EnglishLookingUserAliasKeepsItsDeclaredExponent() + public async Task EnglishLookingUserAliasKeepsItsDeclaredExponent() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -614,31 +660,42 @@ public static class Consumer public static double Value() => Power.Of(Length.FromMetres(3)).AsSiBaseUnit(); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(27, result); } [Fact] - public void ExplicitAliasInAnotherFileReservesTheName() + public async Task ExplicitAliasInAnotherFileReservesTheName() { const string generatedAliasSource = """ using DimensionalQuantities.TypeSystem; - class First { public Area Value(Length value) => Power.Of(value); } + class First + { + public Area Value(Length value) => {|#1:Power<{|#0:NumberTwo|}>|}.Of(value); + } """; const string explicitAliasSource = """ using DimensionalQuantities.TypeSystem; using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; - class Second { public Volume Value(Length value) => Power.Of(value); } + class Second + { + public Volume Value(Length value) => Power.Of(value); + } """; - CSharpCompilation input = CreateInputCompilation(generatedAliasSource).AddSyntaxTrees( - CSharpSyntaxTree.ParseText(explicitAliasSource, _parseOptions, path: "Second.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", generatedAliasSource)); + test.TestState.Sources.Add(("Second.cs", explicitAliasSource)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation output = test.Compilation; Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal)), () => Assert.DoesNotContain(errors, diagnostic => diagnostic.Location.SourceTree?.FilePath == "Second.cs"), () => Assert.DoesNotContain(output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings), @@ -646,7 +703,7 @@ class Second { public Volume Value(Length value) => Power.Of(value); } [Fact] - public void EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() + public async Task EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -663,11 +720,11 @@ public static bool Value() } """; - Assert.True(EvaluateSource(source)); + Assert.True(await EvaluateSource(source)); } [Fact] - public void EnglishZerothPowerReturnsDouble() + public async Task EnglishZerothPowerReturnsDouble() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -677,11 +734,11 @@ public static class Consumer } """; - Assert.Equal(1, EvaluateSource(source)); + Assert.Equal(1, await EvaluateSource(source)); } [Fact] - public void PowersReturnExistingQuantityTypesWhenCalledThroughAliases() + public async Task PowersReturnExistingQuantityTypesWhenCalledThroughAliases() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -702,7 +759,7 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); double expected = 51; Assert.Equal(expected, result); @@ -715,7 +772,7 @@ public static double Value() [InlineData("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] [InlineData("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] [InlineData("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] - public void PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) + public async Task PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -730,13 +787,13 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result, 12); } [Fact] - public void ZerothPowerReturnsDouble() + public async Task ZerothPowerReturnsDouble() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -745,7 +802,7 @@ public static class Consumer public static double Value() => Power.Of(Length.FromMetres(3)); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(1, result); } @@ -753,22 +810,31 @@ public static class Consumer [Theory] [InlineData("Two")] [InlineData("NumberNotANumber", "DQ0007")] - public void UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) + public async Task UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) { string source = $$""" using DimensionalQuantities.TypeSystem; public static class Consumer { - public static object Value(Length length) => Power<{{name}}>.Of(length); + public static object Value(Length length) => {|#1:Power<{|#0:{{name}}|}>|}.Of(length); } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + foreach (string diagnosticId in expectedDiagnosticIds) + { + test.ExpectedDiagnostics.Add(new DiagnosticResult(diagnosticId, DiagnosticSeverity.Error) + .WithLocation(0).WithMessage($"English exponent '{name}' cannot be resolved")); + } + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); + await test.RunAsync(TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Equal(expectedDiagnosticIds, diagnostics.Select(diagnostic => diagnostic.Id)), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal))); + Assert.Contains(test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken), + diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal)); } [Theory] @@ -821,7 +887,7 @@ public static class Consumer [InlineData("Root4", 16, 2)] [InlineData("Root5", 32, 2)] [InlineData("Root6", 64, 2)] - public void ConveniencePowersCompileAndExecute(string method, double value, double expected) + public async Task ConveniencePowersCompileAndExecute(string method, double value, double expected) { string source = $$""" public static class Consumer @@ -829,13 +895,13 @@ public static class Consumer public static double Value() => Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}}).{{method}}().AsSiBaseUnit(); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result, 12); } [Fact] - public void ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() + public async Task ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -857,7 +923,7 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(57, result, 12); } @@ -867,7 +933,7 @@ public static double Value() [InlineData("Power.Of(current.Squared()) * resistance", 12)] [InlineData("Power.Of(current).SquareRoot() * resistance", 12)] [InlineData("(current * resistance).Squared().SquareRoot()", 12)] - public void ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) + public async Task ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -882,13 +948,13 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(expected, result, 12); } [Fact] - public void GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() + public async Task GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() { const string source = """ class Consumer @@ -897,7 +963,7 @@ class Consumer object Second(Length length, Current current) => (length * current).Squared(); } """; - CSharpCompilation output = Compile(source); + CSharpCompilation output = await Compile(source); string[] convenienceNames = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; string[] result = ReadConvenienceMethods(output, new(Length: 1, ElectricCurrent: 1)).Where(convenienceNames.Contains).ToArray(); string[] expected = ["Squared"]; @@ -906,9 +972,9 @@ class Consumer } [Fact] - public void BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() + public async Task BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() { - CSharpCompilation result = Compile(string.Empty); + CSharpCompilation result = await Compile(string.Empty); string[] expected = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); @@ -916,7 +982,7 @@ public void BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() } [Fact] - public void InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() + public async Task InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() { const string source = """ public static class Consumer @@ -929,13 +995,13 @@ public static double Value() } } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(81, result); } [Fact] - public void CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() + public async Task CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() { const string source = """ public static class Consumer @@ -943,7 +1009,13 @@ public static class Consumer public static object Value(Voltage voltage) => voltage.Squared(); } """; - CSharpCompilation result = Compile(source, new SemanticProbeGenerator()); + SemanticProbeTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation result = test.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; IFieldSymbol resolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); @@ -951,22 +1023,31 @@ public static class Consumer } [Fact] - public void ExistingQuantityExtensionMethodKeepsItsBehaviour() + public async Task ExistingQuantityExtensionMethodKeepsItsBehaviour() { const string source = """ - public static class UserMethods { public static double Squared(this Length value) => 42; } - public static class Consumer { public static double Value() => Length.FromMetres(3).Squared(); } + public static class UserMethods + { + public static double Squared(this Length value) => 42; + } + public static class Consumer + { + public static double Value() => Length.FromMetres(3).Squared(); + } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(42, result); } [Fact] - public void ConvenienceMethodCoexistsWithAnExistingOverload() + public async Task ConvenienceMethodCoexistsWithAnExistingOverload() { const string source = """ - public static class UserMethods { public static double Squared(this Length value, int factor) => value.AsMetres() * factor; } + public static class UserMethods + { + public static double Squared(this Length value, int factor) => value.AsMetres() * factor; + } public static class Consumer { public static double[] Value() @@ -976,7 +1057,7 @@ public static double[] Value() } } """; - double[] result = EvaluateSource(source); + double[] result = await EvaluateSource(source); double[] expected = [9, 12]; Assert.Equal(expected, result); @@ -985,22 +1066,37 @@ public static double[] Value() [Theory] [InlineData("(3d).Squared()", "CS1929")] [InlineData("Length.FromMetres(3).Pow7()", "CS1061")] - public void UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) + public async Task UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) { - string source = $$"""class Consumer { object Value() => {{expression}}; }"""; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + string markedExpression = expression == "(3d).Squared()" + ? "({|#0:3d|}).Squared()" + : "Length.FromMetres(3).{|#0:Pow7|}()"; + string source = $$""" + class Consumer + { + object Value() => {{markedExpression}}; + } + """; + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError(diagnosticId).WithLocation(0)); + await test.RunAsync(TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId)); + Assert.Contains(test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId); } [Fact] public void RemovingIntermediateConvenienceCallsRemovesTheirGeneratedMethods() { - const string source = "class Consumer { object Value(Length length, Current current) => (length * current).Squared(); }"; + const string source = """ + class Consumer + { + object Value(Length length, Current current) => (length * current).Squared(); + } + """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); @@ -1015,7 +1111,6 @@ public void RemovingIntermediateConvenienceCallsRemovesTheirGeneratedMethods() } - [Fact] public void EditingExplicitLocalUpdatesItsDependentArithmetic() { @@ -1076,8 +1171,18 @@ object Value(bool choose, Length length, Current current, Time time) [Fact] public void EditingMemberDefinitionRemovesObsoleteDependentOperations() { - const string source = "class Inputs { public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Stored * time; }"; + const string source = """ + class Inputs + { + public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); + } + """; + const string consumer = """ + class Consumer + { + object Value(Time time) => Inputs.Stored * time; + } + """; string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); @@ -1097,8 +1202,18 @@ public void EditingMemberDefinitionRemovesObsoleteDependentOperations() [Fact] public void EditingMethodDefinitionRefreshesUnchangedConsumers() { - const string source = "class Inputs { public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Make() * time; }"; + const string source = """ + class Inputs + { + public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); + } + """; + const string consumer = """ + class Consumer + { + object Value(Time time) => Inputs.Make() * time; + } + """; string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); @@ -1117,7 +1232,7 @@ public void EditingMethodDefinitionRefreshesUnchangedConsumers() [Theory] [InlineData(false, 216)] [InlineData(true, 72)] - public void WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) + public async Task WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) { string source = $$""" public static class Consumer @@ -1145,7 +1260,7 @@ public static double[] Value() } } """; - double[] result = EvaluateSource(source); + double[] result = await EvaluateSource(source); Assert.Multiple( () => Assert.Equal(expectedLoss, result[0], 12), @@ -1154,7 +1269,7 @@ public static double[] Value() [Fact] - public void TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() + public async Task TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() { const string source = """ public record Measurement(LengthCurrent Value); @@ -1167,13 +1282,13 @@ public class Consumer public LengthCurrent Identity(LengthCurrent value) => value; } """; - CSharpCompilation result = Compile(source); + CSharpCompilation result = await Compile(source); Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() + public async Task TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() { const string source = """ public static class Consumer @@ -1182,48 +1297,80 @@ public static class Consumer public static double Value() => Multiply(LengthCurrent.FromSiBaseUnit(6), Time.FromSeconds(4)).AsSiBaseUnit(); } """; - double result = EvaluateSource(source); + double result = await EvaluateSource(source); Assert.Equal(24, result); } - - - - [Theory] - [InlineData("public class LengthCurrent { }")] - [InlineData("using LengthCurrent = System.Int32;")] - public void ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) + [InlineData(""" + public class LengthCurrent + { + } + """)] + [InlineData(""" + using LengthCurrent = System.Int32; + """)] + public async Task ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) { - string source = $$"""{{declaration}} class Consumer { object Value(LengthCurrent value) => value; }"""; - CSharpCompilation result = Compile(source); + string source = $$""" + {{declaration}} + class Consumer + { + object Value(LengthCurrent value) => value; + } + """; + CSharpCompilation result = await Compile(source); Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void QuantityLookingVariableNamesDoNotRequestTypes() + public async Task QuantityLookingVariableNamesDoNotRequestTypes() { - const string source = "class Consumer { int Value() { int LengthCurrent = 7; return LengthCurrent; } }"; - CSharpCompilation result = Compile(source); + const string source = """ + class Consumer + { + int Value() + { + int LengthCurrent = 7; + return LengthCurrent; + } + } + """; + CSharpCompilation result = await Compile(source); Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() + public async Task TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() { - const string source = "class First { public LengthCurrent Value; }"; - const string aliasSource = "using LengthCurrent = System.Int32; class Second { public int Value(LengthCurrent value) => value; }"; - CSharpCompilation input = CreateInputCompilation(source).AddSyntaxTrees(CSharpSyntaxTree.ParseText(aliasSource, _parseOptions, path: "Alias.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + const string source = """ + class First + { + public {|#0:LengthCurrent|} Value; + } + """; + const string aliasSource = """ + using LengthCurrent = System.Int32; + class Second + { + public int Value(LengthCurrent value) => value; + } + """; + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.TestState.Sources.Add(("Alias.cs", aliasSource)); + test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); + await test.RunAsync(TestContext.Current.CancellationToken); + Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.Contains(errors, error => error.Id == "CS0246" && error.Location.SourceTree?.FilePath == "Consumer.cs"), () => Assert.DoesNotContain(errors, error => error.Location.SourceTree?.FilePath == "Alias.cs")); } @@ -1231,7 +1378,12 @@ public void TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() [Fact] public void RemovingTypeOnlyDeclarationsRemovesTheirQuantities() { - const string source = "class Consumer { public LengthCurrent Identity(LengthCurrent value) => value; }"; + const string source = """ + class Consumer + { + public LengthCurrent Identity(LengthCurrent value) => value; + } + """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); @@ -1249,9 +1401,9 @@ public void RemovingTypeOnlyDeclarationsRemovesTheirQuantities() [InlineData("Library.Property")] [InlineData("Library.Values()[0]")] [InlineData("Library.Measure().Value")] - public void ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) + public async Task ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) { - PortableExecutableReference library = CreateLibraryReference(""" + PortableExecutableReference library = await CreateLibraryReference(""" public static class Library { public static LengthCurrent Create() => Length.FromMetres(2) * Current.FromAmps(3); @@ -1260,39 +1412,55 @@ public static class Library public static System.Collections.Generic.List Values() => new() { Create() }; public static Measurement Measure() => new(); } - public sealed class Measurement { public LengthCurrent Value => Library.Create(); } + public sealed class Measurement + { + public LengthCurrent Value => Library.Create(); + } """); - CSharpCompilation input = CreateInputCompilation($"public class Consumer {{ public double Value() => {expression}.AsPrefixedUnits(3, 0); }}").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + CSharpCompilation result = await Compile($$""" + public class Consumer + { + public double Value() => {{expression}}.AsPrefixedUnits(3, 0); + } + """, library); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void ReferencedCollectionTypesRequestTheirNestedQuantity() + public async Task ReferencedCollectionTypesRequestTheirNestedQuantity() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static System.Collections.Generic.List Values() => new(); }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Values(); }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + PortableExecutableReference library = await CreateLibraryReference(""" + public static class Library + { + public static System.Collections.Generic.List Values() => new(); + } + """); + CSharpCompilation result = await Compile(""" + public class Consumer + { + public object Value() => Library.Values(); + } + """, library); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void RemovingMetadataUsageRemovesItsLocallyGeneratedConversions() + public async Task RemovingMetadataUsageRemovesItsLocallyGeneratedConversions() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Create(); }").AddReferences(library); + PortableExecutableReference library = await CreateLibraryReference(""" + public static class Library + { + public static LengthCurrent Create() => default; + } + """); + CSharpCompilation input = CreateInputCompilation(""" + public class Consumer + { + public object Value() => Library.Create(); + } + """).AddReferences(library); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); @@ -1305,77 +1473,107 @@ public void RemovingMetadataUsageRemovesItsLocallyGeneratedConversions() } [Fact] - public void ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() + public async Task ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() { - PortableExecutableReference library = CreateLibraryReference("public class LengthCurrent { } public static class Library { public static LengthCurrent Create() => new(); }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Create(); }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + PortableExecutableReference library = await CreateLibraryReference(""" + public class LengthCurrent + { + } + public static class Library + { + public static LengthCurrent Create() => new(); + } + """); + CSharpCompilation result = await Compile(""" + public class Consumer + { + public object Value() => Library.Create(); + } + """, library); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void MetadataDiscoveryPreservesExplicitConsumerAliases() + public async Task MetadataDiscoveryPreservesExplicitConsumerAliases() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - CSharpCompilation input = CreateInputCompilation("using LengthCurrent = System.Int32; public class Consumer { public object Value() => Library.Create(); public LengthCurrent Count => 1; }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors)); + PortableExecutableReference library = await CreateLibraryReference(""" + public static class Library + { + public static LengthCurrent Create() => default; + } + """); + await Compile(""" + using LengthCurrent = System.Int32; + public class Consumer + { + public object Value() => Library.Create(); + public LengthCurrent Count => 1; + } + """, library); } [Theory] - [InlineData("public class LengthCurrent { public int Marker { get; init; } }", "LengthCurrent", "new() { Marker = 7 }")] - [InlineData("namespace LengthCurrent { public class Item { } }", "LengthCurrent.Item", "new()")] - public void MetadataDiscoveryPreservesExistingConsumerTypesAndNamespaces(string declaration, string type, string value) + [InlineData(""" + public class LengthCurrent + { + public int Marker + { + get; + init; + } + } + """, "LengthCurrent", "new() { Marker = 7 }")] + [InlineData(""" + namespace LengthCurrent + { + public class Item + { + } + } + """, "LengthCurrent.Item", "new()")] + public async Task MetadataDiscoveryPreservesExistingConsumerTypesAndNamespaces(string declaration, string type, string value) { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - string source = $$"""{{declaration}} public class Consumer { public object Value() => Library.Create(); public {{type}} Item => {{value}}; }"""; - CSharpCompilation input = CreateInputCompilation(source).AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors)); + PortableExecutableReference library = await CreateLibraryReference(""" + public static class Library + { + public static LengthCurrent Create() => default; + } + """); + string source = $$""" + {{declaration}} + public class Consumer + { + public object Value() => Library.Create(); + public {{type}} Item => {{value}}; + } + """; + await Compile(source, library); } [Fact] - public void ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() + public async Task ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthTime Convert(T value) => default; }"); + PortableExecutableReference library = await CreateLibraryReference(""" + public static class Library + { + public static LengthTime Convert(T value) => default; + } + """); const string source = """ public static class Consumer { public static double Value(Length length, Current current) => Library.Convert(length * current).AsPrefixedUnits(0, 0); } """; - CSharpCompilation input = CreateInputCompilation(source).AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); + CSharpCompilation result = await Compile(source, library); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")); } - private static PortableExecutableReference CreateLibraryReference(string source) + private static async Task CreateLibraryReference(string source) { - CSharpCompilation library = Compile(source).WithAssemblyName("ReferencedQuantities"); + CSharpCompilation library = (await Compile(source)).WithAssemblyName("ReferencedQuantities"); using MemoryStream stream = new(); EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); if (!emitted.Success) @@ -1397,7 +1595,7 @@ private static string[] ReadConvenienceMethods(Compilation compilation, Dimensio .Select(method => method.Identifier.ValueText).ToArray(); } - private static T Evaluate(string expression) + private static async Task Evaluate(string expression) { string source = $$""" public static class Consumer @@ -1405,34 +1603,39 @@ public static class Consumer public static global::{{typeof(T).FullName}} Value() => {{expression}}; } """; - return EvaluateSource(source); + return await EvaluateSource(source); + } + + private static async Task EvaluateSource(string source) + { + CSharpCompilation compilation = await Compile(source); + return EvaluateCompilation(compilation); } - private static T EvaluateSource(string source) + private static T EvaluateCompilation(Compilation compilation) { - CSharpCompilation compilation = Compile(source); using MemoryStream assemblyBytes = new(); EmitResult emitResult = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics)); + if (!emitResult.Success) + { + throw new InvalidOperationException(string.Join(Environment.NewLine, emitResult.Diagnostics)); + } Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; return Assert.IsType(method.Invoke(null, null)); } - private static CSharpCompilation Compile(string source, IIncrementalGenerator? additionalGenerator = null) + private static async Task Compile(string source, params MetadataReference[] references) { - CSharpCompilation input = CreateInputCompilation(source); - ISourceGenerator[] generators = additionalGenerator is null - ? [new QuantityGenerator().AsSourceGenerator()] - : [new QuantityGenerator().AsSourceGenerator(), additionalGenerator.AsSourceGenerator()]; - GeneratorDriver driver = CSharpGeneratorDriver.Create(generators, parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray generatorDiagnostics); - Diagnostic[] compilationErrors = output.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.True(generatorDiagnostics.IsEmpty, string.Join(Environment.NewLine, generatorDiagnostics)), - () => Assert.True(compilationErrors.Length == 0, string.Join(Environment.NewLine, compilationErrors))); - return (CSharpCompilation)output; + QuantityGeneratorTest test = new() + { + // These tests inspect compilation or execution, rather than snapshotting the default catalogue. + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(("Consumer.cs", source)); + test.TestState.AdditionalReferences.AddRange(references); + await test.RunAsync(TestContext.Current.CancellationToken); + return (CSharpCompilation)test.Compilation; } private static CSharpCompilation CreateInputCompilation(string source) @@ -1447,8 +1650,18 @@ private static CSharpCompilation CreateInputCompilation(string source) new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); } + private sealed class SemanticProbeTest : QuantityGeneratorTest + { + protected override IEnumerable GetSourceGenerators() => + base.GetSourceGenerators().Append(typeof(SemanticProbeGenerator)); + } + private sealed class SemanticProbeGenerator : IIncrementalGenerator { + public SemanticProbeGenerator() + { + } + public void Initialize(IncrementalGeneratorInitializationContext context) { IncrementalValuesProvider<(bool IsInvocation, bool Resolved)> observed = context.SyntaxProvider.CreateSyntaxProvider( @@ -1470,7 +1683,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context) { bool aliasResolved = symbols.Any(symbol => !symbol.IsInvocation && symbol.Resolved); bool factoryResolved = symbols.Any(symbol => symbol.IsInvocation && symbol.Resolved); - string source = $"internal static class SemanticProbe {{ public const bool AliasResolved = {aliasResolved.ToString().ToLowerInvariant()}; public const bool FactoryResolved = {factoryResolved.ToString().ToLowerInvariant()}; }}"; + string source = $$""" + internal static class SemanticProbe + { + public const bool AliasResolved = {{aliasResolved.ToString().ToLowerInvariant()}}; + public const bool FactoryResolved = {{factoryResolved.ToString().ToLowerInvariant()}}; + } + """; output.AddSource("SemanticProbe.g.cs", SourceText.From(source, Encoding.UTF8)); }); } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs index cb7f06e..c0d58be 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs @@ -1,10 +1,8 @@ -using System.Collections.Immutable; using System.Reflection; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; +using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -28,7 +26,7 @@ private sealed class Foot; """; [Fact] - public void IndependentProviderGeneratesScaledFactoriesAndAccessors() + public async Task IndependentProviderGeneratesScaledFactoriesAndAccessors() { const string consumer = """ namespace Independent.Units; @@ -37,16 +35,22 @@ public static class Consumer public static double[] Values() => [Length.FromFeet(10).AsMetres(), Length.FromMetres(0.6096).AsFeet()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(FootProvider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(FootProvider); + test.TestState.Sources.Add(consumer); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Multiple( () => Assert.Equal(3.048, result[0], 12), () => Assert.Equal(2, result[1], 12)); } [Fact] - public void AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() + public async Task AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -70,17 +74,27 @@ public static double[] Values() } } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([16d, 3d, 1d], Evaluate(compilation, "Consumer")); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + Assert.Equal([16d, 3d, 1d], Evaluate(test.Compilation, "Consumer")); } [Fact] - public void ProviderConversionsArePublicAndNotRegeneratedByConsumers() + public async Task ProviderConversionsArePublicAndNotRegeneratedByConsumers() { - (Compilation provider, ImmutableArray providerDiagnostics) = Generate(FootProvider, ""); - Assert.Empty(providerDiagnostics); - MetadataReference reference = MetadataReference.CreateFromImage(Emit(provider)); + QuantityGeneratorTest provider = new() + { + TestCode = FootProvider, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + provider.SolutionTransforms.Add((solution, project) => solution.WithProjectAssemblyName(project, "Independent.Provider")); + await provider.RunAsync(TestContext.Current.CancellationToken); + MetadataReference reference = MetadataReference.CreateFromImage(Emit(provider.Compilation)); const string consumer = """ using Independent.Units; public static class Consumer @@ -88,18 +102,22 @@ public static class Consumer public static Area Value() => Length.FromFeet(1) * Length.FromFeet(2); } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate("", consumer, reference); - INamespaceSymbol? localNamespace = compilation.Assembly.GlobalNamespace.GetNamespaceMembers() + QuantityGeneratorTest test = new() + { + TestCode = consumer, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.AdditionalReferences.Add(reference); + + await test.RunAsync(TestContext.Current.CancellationToken); + INamespaceSymbol? localNamespace = test.Compilation.Assembly.GlobalNamespace.GetNamespaceMembers() .SingleOrDefault(symbol => symbol.Name == "Independent"); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(localNamespace)); + Assert.Null(localNamespace); } [Fact] - public void ProviderCanOptIntoNamedAndParameterisedSiPrefixes() + public async Task ProviderCanOptIntoNamedAndParameterisedSiPrefixes() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -119,14 +137,19 @@ public static double[] Values() => [Voltage.FromMilliSparks(500).AsSiBaseUnit(), Voltage.FromPrefixedUnits(3, sparkPrefixExponent: 3).AsSiBaseUnit(), Voltage.FromSiBaseUnit(0.004).AsPrefixedUnits(-3)]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Equal([0.5, 2, 3000, 4], result); } [Fact] - public void CompoundFactorsPreserveOrderPowersAndAdditionalConversions() + public async Task CompoundFactorsPreserveOrderPowersAndAdditionalConversions() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -154,14 +177,19 @@ public static double[] Values() => [CurrentDensity.FromAmpsPerSquareMilliMetre(1 CurrentDensity.FromSiBaseUnit(1000000).AsAmpsPerSquareMilliMetre()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Equal([1000000d, 2000000d, 1d], result); } [Fact] - public void ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() + public async Task ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -188,13 +216,18 @@ public static double[] Values() => Density.FromPrefixedUnits(2, gramPrefixExponent: 0, metrePrefixExponent: 0).AsSiBaseUnit()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([2d, 2000000d, 0.002d, 0.002d], Evaluate(compilation, "Independent.Units.Consumer")); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + Assert.Equal([2d, 2000000d, 0.002d, 0.002d], Evaluate(test.Compilation, "Independent.Units.Consumer")); } [Fact] - public void OneUnitDeclarationCanServeDistinctQuantityTypes() + public async Task OneUnitDeclarationCanServeDistinctQuantityTypes() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -215,13 +248,18 @@ public static double[] Values() => [Length.FromTokens(2).AsSiBaseUnit(), Time.FromTokens(3).AsSiBaseUnit()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([2d, 3d], Evaluate(compilation, "Independent.Units.Consumer")); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + Assert.Equal([2d, 3d], Evaluate(test.Compilation, "Independent.Units.Consumer")); } [Fact] - public void ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() + public async Task ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() { const string consumer = """ namespace Independent.Units; @@ -230,14 +268,20 @@ public static class Consumer public static double[] Values() => [(Length.FromFeet(2) * Length.FromFeet(3)).AsSiBaseUnit()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(FootProvider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(FootProvider); + test.TestState.Sources.Add(consumer); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Equal(0.55741824, Assert.Single(result), 12); } [Fact] - public void RecordClassProvidersGenerateConversions() + public async Task RecordClassProvidersGenerateConversions() { const string provider = """ using DimensionalQuantities.Units.Declarations; @@ -259,21 +303,27 @@ public static class Consumer public static double[] Values() => [Length.FromFeet(1).AsMetres()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(provider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(provider); + test.TestState.Sources.Add(consumer); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Equal(0.3048, Assert.Single(result), 12); } [Theory] [InlineData("Bad name", "Feet")] [InlineData("Foot", "Bad names")] - public void InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) + public async Task InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) { string source = $$""" using DimensionalQuantities.Units.Declarations; [UnitProvider(GeneratePrefixConversions = true)] - internal static class Units + internal static class {|#0:Units|} { [QuantityUnit(typeof(Length))] [UnitFactor(typeof(Foot))] @@ -282,14 +332,19 @@ private sealed class LengthUnit; private sealed class Foot; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Multiple( - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); + QuantityGeneratorTest test = new() + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0008", DiagnosticSeverity.Error) + .WithLocation(0).WithMessage("Unit provider for Length produces an invalid C# identifier.")); + + await test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void ProvidersInSameNamespaceCanConvertSameQuantity() + public async Task ProvidersInSameNamespaceCanConvertSameQuantity() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -317,27 +372,19 @@ public static class Consumer public static double[] Values() => [Length.FromFeet(3).AsYards(), Length.FromYards(2).AsFeet()]; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); + QuantityGeneratorTest test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + test.TestState.Sources.Add(source); + + await test.RunAsync(TestContext.Current.CancellationToken); + double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); Assert.Multiple( () => Assert.Equal(1, result[0], 12), () => Assert.Equal(6, result[1], 12)); } - private static (Compilation Compilation, ImmutableArray Diagnostics) Generate(string provider, string consumer, params MetadataReference[] additionalReferences) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)).Concat(additionalReferences); - CSharpCompilation input = CSharpCompilation.Create("ProviderTest" + Guid.NewGuid().ToString("N"), - [CSharpSyntaxTree.ParseText(provider, options), CSharpSyntaxTree.ParseText(consumer, options)], references, new(OutputKind.DynamicallyLinkedLibrary)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - return (output, diagnostics); - } - private static double[] Evaluate(Compilation compilation, string consumerType) { Assembly assembly = Assembly.Load(Emit(compilation)); From 05e15e93efa5543b89b4361336a4f39a6b97007e Mon Sep 17 00:00:00 2001 From: James McMahon Date: Sat, 14 Nov 2026 22:33:26 +0000 Subject: [PATCH 2/2] ci: rerun PR checks with corrected title