diff --git a/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs b/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs new file mode 100644 index 0000000..a55a04b --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs @@ -0,0 +1,95 @@ +using System.Collections.Immutable; +using System.Composition.Hosting; +using System.IO.Compression; +using System.Reflection; +using System.Runtime.Loader; +using DimensionalQuantities.IntegrationTests.Delivery; +using DimensionalQuantities.IntegrationTests.Fixtures; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CodeActions; +using Microsoft.CodeAnalysis.CodeFixes; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Text; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +[Collection(typeof(PackageDeliveryCollection))] +public sealed class DeliveredCodeFixTests +{ + private readonly PackageDeliveryFixture _fixture; + + public DeliveredCodeFixTests(PackageDeliveryFixture fixture) + { + _fixture = fixture; + } + + [Fact] + public async Task PackagedMefExportLoadsAndReplacesRawQuantityWithSafeAlias() + { + using PackageSandbox sandbox = _fixture.CreateConsumer(); + string extracted = Path.Combine(sandbox.Root, "extracted"); + ZipFile.ExtractToDirectory(sandbox.ArchivePath("DimensionalQuantities"), extracted); + string codeFixPath = Path.Combine(extracted, "analyzers/dotnet/cs/DimensionalQuantities.Roslyn.CodeFixes.dll"); + AssemblyLoadContext loadContext = new("delivered-fix-" + Guid.NewGuid(), isCollectible: true); + loadContext.Resolving += (_, name) => AssemblyLoadContext.Default.LoadFromAssemblyName(name); + try + { + Assembly delivered = loadContext.LoadFromAssemblyPath(codeFixPath); + using CompositionHost exports = new ContainerConfiguration().WithAssembly(delivered).CreateContainer(); + CodeFixProvider provider = Assert.Single(exports.GetExports()); + Assert.Multiple( + () => Assert.Equal(codeFixPath, delivered.Location), + () => Assert.Equal(["DQ0003"], provider.FixableDiagnosticIds)); + + const string source = """ + using DimensionalQuantities.TypeSystem; + using Length = DimensionalQuantities.TypeSystem.Quantity>; + class Example + { + Quantity> value; + } + """; + using AdhocWorkspace workspace = new(); + Project project = workspace.AddProject("Consumer", LanguageNames.CSharp) + .WithParseOptions(new CSharpParseOptions(LanguageVersion.Preview)) + .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)) + .AddMetadataReferences(((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator) + .Where(path => !Path.GetFileName(path).StartsWith("DimensionalQuantities", StringComparison.Ordinal)) + .Select(path => MetadataReference.CreateFromFile(path))) + .AddMetadataReference(MetadataReference.CreateFromFile(Path.Combine(extracted, "lib/netstandard2.0/DimensionalQuantities.dll"))); + Document document = project.AddDocument("Consumer.cs", SourceText.From(source)); + Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; + Diagnostic[] setupErrors = [.. compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)]; + if (setupErrors.Length > 0) + { + throw new InvalidOperationException("Invalid code-fix fixture:" + Environment.NewLine + string.Join(Environment.NewLine, setupErrors.Select(diagnostic => diagnostic.ToString()))); + } + SyntaxNode root = (await document.GetSyntaxRootAsync(TestContext.Current.CancellationToken))!; + GenericNameSyntax quantity = root.DescendantNodes().OfType().Single().Declaration.Type.DescendantNodesAndSelf().OfType().First(); + Diagnostic diagnostic = Diagnostic.Create(new DiagnosticDescriptor("DQ0003", "Alias", "Use alias", "Usage", DiagnosticSeverity.Info, true), + quantity.GetLocation(), ImmutableDictionary.Empty.Add("AliasName", "Length")); + List actions = []; + await provider.RegisterCodeFixesAsync(new CodeFixContext(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); + CodeAction action = Assert.Single(actions); + ApplyChangesOperation operation = Assert.Single((await action.GetOperationsAsync(TestContext.Current.CancellationToken)).OfType()); + string updated = (await operation.ChangedSolution.GetDocument(document.Id)!.GetTextAsync(TestContext.Current.CancellationToken)).ToString(); + Compilation updatedCompilation = (await operation.ChangedSolution.GetDocument(document.Id)!.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; + Assert.Multiple( + () => Assert.Equal("Use Length", action.Title), + () => Assert.Contains(""" + class Example + { + Length value; + } + """, updated), + () => Assert.Empty(updatedCompilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error))); + } + finally { loadContext.Unload(); } + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs b/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs new file mode 100644 index 0000000..35b3916 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs @@ -0,0 +1,147 @@ +using System.Diagnostics; +using System.IO.Compression; +using System.Reflection; +using System.Xml.Linq; + +namespace DimensionalQuantities.IntegrationTests.Delivery; + +internal sealed class PackageSandbox : IDisposable +{ + public string Root { get; } = Path.Combine(Path.GetTempPath(), "dq-consumer-" + Guid.NewGuid().ToString("N")); + public string Feed => Path.Combine(Root, "feed"); + public string Consumer => Path.Combine(Root, "consumer"); + public string Cache => Path.Combine(Root, "packages"); + public string Version { get; private set; } = ""; + + public PackageSandbox() + { + Directory.CreateDirectory(Feed); + Directory.CreateDirectory(Consumer); + File.WriteAllText(Path.Combine(Root, "NuGet.Config"), $""); + } + + public async Task Pack(params string[] optionalPackages) + { + string repository = AppContext.BaseDirectory; + while (!File.Exists(Path.Combine(repository, "global.json"))) + { + repository = Directory.GetParent(repository)!.FullName; + } + + File.Copy(Path.Combine(repository, "global.json"), Path.Combine(Root, "global.json"), overwrite: true); + string configuration = typeof(PackageSandbox).Assembly.GetCustomAttribute()!.Configuration; + + foreach (string id in new[] { "DimensionalQuantities" }.Concat(optionalPackages).Distinct()) + { + ProcessResult result = await Run(repository, "pack", Path.Combine(repository, "src", id, id + ".csproj"), "-c", configuration, "--no-build", "--no-restore", "-o", Feed, "-p:NuspecOutputPath=" + Path.Combine(Root, "nuspec", id), "--nologo"); + result.EnsureSuccess(); + } + + using ZipArchive archive = ZipFile.OpenRead(ArchivePath("DimensionalQuantities")); + using Stream stream = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open(); + Version = XDocument.Load(stream).Descendants().Single(e => e.Name.LocalName == "version").Value; + } + + public string ArchivePath(string id, bool symbols = false) => Directory.GetFiles(Feed, id + ".*." + (symbols ? "snupkg" : "nupkg")) + .Single(path => Path.GetFileName(path).StartsWith(id + ".", StringComparison.Ordinal) && + !Path.GetFileName(path)[(id.Length + 1)..].StartsWith("Extensions.", StringComparison.Ordinal)); + + public PackageSandbox CreateConsumer() + { + PackageSandbox consumer = new(); + consumer.Version = Version; + File.Copy(Path.Combine(Root, "global.json"), Path.Combine(consumer.Root, "global.json")); + foreach (string archive in Directory.GetFiles(Feed)) + { + File.Copy(archive, Path.Combine(consumer.Feed, Path.GetFileName(archive))); + } + return consumer; + } + + public async Task PackProducer(string id, string source, params string[] packageIds) + { + string directory = Path.Combine(Root, id); + Directory.CreateDirectory(directory); + string references = string.Join("\n", packageIds.Select(packageId => $"")); + File.WriteAllText(Path.Combine(directory, id + ".csproj"), $$""" + + + net11.0 + preview + enable + {{Version}} + + + {{references}} + + + """); + File.WriteAllText(Path.Combine(directory, id + ".cs"), source); + (await Run(directory, "restore", "--configfile", Path.Combine(Root, "NuGet.Config"), "--packages", Cache, "--nologo")).EnsureSuccess(); + (await Run(directory, "pack", "-c", "Release", "--no-restore", "-o", Feed, "--nologo")).EnsureSuccess(); + } + + public void WriteConsumer(string source, params string[] packageIds) + { + string references = string.Join("\n", packageIds.Select(id => $"")); + File.WriteAllText(Path.Combine(Consumer, "Consumer.csproj"), $$""" + + net11.0Exepreviewenable + {{references}} + + """); + File.WriteAllText(Path.Combine(Consumer, "Program.cs"), source); + } + + public async Task BuildConsumer() + { + (await Run(Consumer, "restore", "--configfile", Path.Combine(Root, "NuGet.Config"), "--packages", Cache, "--nologo")).EnsureSuccess(); + return await Run(Consumer, "build", "-c", "Release", "--no-restore", "--nologo"); + } + + public async Task ExecuteConsumer() + { + (await BuildConsumer()).EnsureSuccess(); + return await ExecuteBuiltConsumer(); + } + + public async Task ExecuteBuiltConsumer() + { + ProcessResult result = await Run(Consumer, Path.Combine(Consumer, "bin", "Release", "net11.0", "Consumer.dll")); + result.EnsureSuccess(); + return result.Output.Trim(); + } + + public async Task Run(string workingDirectory, params string[] arguments) + { + ProcessStartInfo start = new("dotnet") { WorkingDirectory = workingDirectory, RedirectStandardOutput = true, RedirectStandardError = true }; + foreach (string argument in arguments) + { + start.ArgumentList.Add(argument); + } + + if (workingDirectory == Consumer) + { + start.Environment["NUGET_PACKAGES"] = Cache; + } + + using Process process = Process.Start(start)!; + Task stdout = process.StandardOutput.ReadToEndAsync(); + Task stderr = process.StandardError.ReadToEndAsync(); + await process.WaitForExitAsync(); + return new(process.ExitCode, await stdout + "\n" + await stderr); + } + + public void Dispose() => Directory.Delete(Root, recursive: true); + + internal sealed record ProcessResult(int ExitCode, string Output) + { + public void EnsureSuccess() + { + if (ExitCode != 0) + { + throw new InvalidOperationException($"dotnet exited {ExitCode}:\n{Output}"); + } + } + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj index c73a812..aa3c626 100644 --- a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj +++ b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj @@ -9,15 +9,16 @@ + + - - - - - - - + + + + + + diff --git a/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveCollection.cs b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveCollection.cs new file mode 100644 index 0000000..2ae2ed2 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveCollection.cs @@ -0,0 +1,8 @@ +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Fixtures; + +[CollectionDefinition] +public sealed class PackageArchiveCollection : ICollectionFixture +{ +} diff --git a/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveFixture.cs b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveFixture.cs new file mode 100644 index 0000000..f1e2a67 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageArchiveFixture.cs @@ -0,0 +1,32 @@ +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Fixtures; + +public sealed class PackageArchiveFixture : IAsyncLifetime +{ + internal PackageSandbox Packages { get; } = new(); + + public async ValueTask InitializeAsync() + { + try + { + await Packages.Pack( + "DimensionalQuantities.Extensions.Metric", + "DimensionalQuantities.Extensions.Imperial", + "DimensionalQuantities.Extensions.Nautical", + "DimensionalQuantities.Extensions.CgsEmag"); + } + catch + { + Packages.Dispose(); + throw; + } + } + + public ValueTask DisposeAsync() + { + Packages.Dispose(); + return ValueTask.CompletedTask; + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryCollection.cs b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryCollection.cs new file mode 100644 index 0000000..bcad342 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryCollection.cs @@ -0,0 +1,8 @@ +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Fixtures; + +[CollectionDefinition] +public sealed class PackageDeliveryCollection : ICollectionFixture +{ +} diff --git a/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryFixture.cs b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryFixture.cs new file mode 100644 index 0000000..c762cf0 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageDeliveryFixture.cs @@ -0,0 +1,34 @@ +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Fixtures; + +public sealed class PackageDeliveryFixture : IAsyncLifetime +{ + private readonly PackageSandbox _packages = new(); + + internal PackageSandbox CreateConsumer() => _packages.CreateConsumer(); + + public async ValueTask InitializeAsync() + { + try + { + await _packages.Pack( + "DimensionalQuantities.Extensions.Metric", + "DimensionalQuantities.Extensions.Imperial", + "DimensionalQuantities.Extensions.Nautical", + "DimensionalQuantities.Extensions.CgsEmag"); + } + catch + { + _packages.Dispose(); + throw; + } + } + + public ValueTask DisposeAsync() + { + _packages.Dispose(); + return ValueTask.CompletedTask; + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageInteroperabilityFixture.cs b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageInteroperabilityFixture.cs new file mode 100644 index 0000000..1c157bf --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Fixtures/PackageInteroperabilityFixture.cs @@ -0,0 +1,109 @@ +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Fixtures; + +public sealed class PackageInteroperabilityFixture : IAsyncLifetime +{ + private readonly PackageSandbox _sandbox = new(); + + public async ValueTask InitializeAsync() + { + try + { + await _sandbox.Pack("DimensionalQuantities.Extensions.Metric"); + await _sandbox.PackProducer("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 List Values() => [Create(), Create()]; + public static Measurement Measure() => new(); + } + + public sealed class Measurement + { + public Voltage Value => Producer.Create(); + } + """, "DimensionalQuantities"); + await _sandbox.PackProducer("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(IEnumerable values) + { + double total = 0; + foreach (Voltage value in values) + { + total += value.AsVolts(); + } + + return total; + } + } + """, "DimensionalQuantities.Extensions.Metric"); + _sandbox.WriteConsumer(""" + using System.Text.Json; + using DimensionalQuantities.Extensions.Metric; + using PackageA; + + Type produced = typeof(Producer).GetMethod("Create")!.ReturnType; + Type independentlyProduced = typeof(PackageB.Consumer).GetMethod("Create")!.ReturnType; + Type accepted = typeof(PackageB.Consumer).GetMethod("Read")!.GetParameters().Single().ParameterType; + Type intermediateFromA = typeof(Producer).GetMethod("CreateIntermediate")!.ReturnType; + Type intermediateFromB = typeof(PackageB.Consumer).GetMethod("CreateIntermediate")!.ReturnType; + Type intermediateAccepted = typeof(PackageB.Consumer).GetMethod("ReadIntermediate")!.GetParameters().Single().ParameterType; + LengthCurrent intermediate = Producer.CreateIntermediate(); + LengthTimeCurrent extended = intermediate * Time.FromSeconds(4); + + Console.WriteLine(JsonSerializer.Serialize(new + { + SharedTypes = new + { + NamedProducers = produced == independentlyProduced, + NamedConsumer = produced == accepted, + IntermediateProducers = intermediateFromA == intermediateFromB, + IntermediateConsumer = intermediateFromA == intermediateAccepted, + IntermediateRuntime = intermediateFromA.Assembly == typeof(Length).Assembly, + ExtendedRuntime = extended.GetType().Assembly == typeof(Length).Assembly + }, + Values = new + { + Direct = PackageB.Consumer.Read(Producer.Create()), + Collection = PackageB.Consumer.Sum(Producer.Values()), + Contained = PackageB.Consumer.Read(Producer.Measure().Value), + Prefixed = Producer.Create().AsPrefixedUnits(3), + Product = (Producer.Create() * Current.FromAmps(4)).AsWatts(), + Intermediate = PackageB.Consumer.ReadIntermediate(intermediate), + IndependentIntermediate = PackageB.Consumer.ReadIntermediate(PackageB.Consumer.CreateIntermediate()), + IntermediateProduct = extended.AsSiBaseUnit() + } + })); + """, "ProjectA", "ProjectB", "DimensionalQuantities.Extensions.Metric"); + + (await _sandbox.BuildConsumer()).EnsureSuccess(); + } + catch + { + _sandbox.Dispose(); + throw; + } + } + + internal Task ExecuteConsumer() => _sandbox.ExecuteBuiltConsumer(); + + public ValueTask DisposeAsync() + { + _sandbox.Dispose(); + return ValueTask.CompletedTask; + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs new file mode 100644 index 0000000..0787f5a --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs @@ -0,0 +1,196 @@ +using System.IO.Compression; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.PortableExecutable; +using System.Xml.Linq; +using DimensionalQuantities.IntegrationTests.Delivery; +using DimensionalQuantities.IntegrationTests.Fixtures; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +[Collection(typeof(PackageArchiveCollection))] +public sealed class PackageArchiveTests +{ + private readonly PackageArchiveFixture _fixture; + + public PackageArchiveTests(PackageArchiveFixture fixture) + { + _fixture = fixture; + } + + [Fact] + public async Task PackedRuntimeMatchesExecutingTestConfiguration() + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath("DimensionalQuantities")); + using Stream source = archive.GetEntry("lib/netstandard2.0/DimensionalQuantities.dll")!.Open(); + using MemoryStream binary = new(); + await source.CopyToAsync(binary, TestContext.Current.CancellationToken); + binary.Position = 0; + using PEReader pe = new(binary); + MetadataReader metadata = pe.GetMetadataReader(); + CustomAttribute attribute = Assert.Single(metadata.GetAssemblyDefinition().GetCustomAttributes().Select(metadata.GetCustomAttribute), candidate => + { + MemberReference constructor = metadata.GetMemberReference((MemberReferenceHandle)candidate.Constructor); + TypeReference type = metadata.GetTypeReference((TypeReferenceHandle)constructor.Parent); + return metadata.GetString(type.Namespace) == "System.Reflection" && metadata.GetString(type.Name) == nameof(AssemblyConfigurationAttribute); + }); + BlobReader value = metadata.GetBlobReader(attribute.Value); + value.ReadUInt16(); + string? actual = value.ReadSerializedString(); + string expected = typeof(PackageArchiveTests).Assembly.GetCustomAttribute()!.Configuration; + Assert.Equal(expected, actual); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public void RuntimePackageShipsExpectedNetstandardBinary(string id) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + ZipArchiveEntry binary = archive.GetEntry($"lib/netstandard2.0/{id}.dll")!; + Assert.NotNull(binary); + using MemoryStream contents = new(); + using (Stream stream = binary.Open()) + { + stream.CopyTo(contents); + } + contents.Position = 0; + using PEReader pe = new(contents); + MetadataReader metadata = pe.GetMetadataReader(); + Assert.Equal(id, metadata.GetString(metadata.GetAssemblyDefinition().Name)); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public void RuntimeBinaryDoesNotReferenceBuildTooling(string id) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + ZipArchiveEntry binary = archive.GetEntry($"lib/netstandard2.0/{id}.dll")!; + Assert.NotNull(binary); + using MemoryStream contents = new(); + using (Stream stream = binary.Open()) + { + stream.CopyTo(contents); + } + contents.Position = 0; + using PEReader pe = new(contents); + MetadataReader metadata = pe.GetMetadataReader(); + Assert.DoesNotContain(metadata.AssemblyReferences.Select(handle => metadata.GetString(metadata.GetAssemblyReference(handle).Name)), + name => name.StartsWith("Microsoft.CodeAnalysis", StringComparison.Ordinal) || name is "JetBrains.Annotations" or "PolySharp"); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public void RuntimePackageDeclaresExactDependencyClosure(string id) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + using Stream manifest = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open(); + XDocument nuspec = XDocument.Load(manifest); + XElement[] dependencies = nuspec.Descendants().Where(e => e.Name.LocalName == "dependency").ToArray(); + if (id == "DimensionalQuantities") + { + Assert.Empty(dependencies); + } + else + { + XElement dependency = Assert.Single(dependencies); + Assert.Multiple( + () => Assert.Equal("DimensionalQuantities", (string?)dependency.Attribute("id")), + () => Assert.Equal($"[{sandbox.Version}]", (string?)dependency.Attribute("version"))); + } + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public void RuntimePackageRecordsGitRepositoryProvenance(string id) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + using Stream manifest = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open(); + XDocument nuspec = XDocument.Load(manifest); + Assert.Contains(nuspec.Descendants(), e => e.Name.LocalName == "repository" && (string?)e.Attribute("type") == "git"); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public void SymbolPackageContainsPortableSymbolsMatchingRuntimeBinary(string id) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + using ZipArchive symbols = ZipFile.OpenRead(sandbox.ArchivePath(id, symbols: true)); + AssertPortablePair(archive.GetEntry($"lib/netstandard2.0/{id}.dll")!, symbols.GetEntry($"lib/netstandard2.0/{id}.pdb")!); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Roslyn")] + [InlineData("DimensionalQuantities.Roslyn.CodeFixes")] + public void CorePackageShipsCompilerAssetsWithMatchingPortableSymbols(string name) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath("DimensionalQuantities")); + AssertPortablePair(archive.GetEntry($"analyzers/dotnet/cs/{name}.dll")!, archive.GetEntry($"analyzers/dotnet/cs/{name}.pdb")!); + } + + private static void AssertPortablePair(ZipArchiveEntry dll, ZipArchiveEntry pdb) + { + Assert.Multiple( + () => Assert.NotNull(dll), + () => Assert.NotNull(pdb)); + using MemoryStream binary = new(); + using (Stream stream = dll.Open()) + { + stream.CopyTo(binary); + } + + binary.Position = 0; + using PEReader pe = new(binary); + using MemoryStream symbolStream = new(); + using (Stream stream = pdb.Open()) + { + stream.CopyTo(symbolStream); + } + + symbolStream.Position = 0; + using MetadataReaderProvider provider = MetadataReaderProvider.FromPortablePdbStream(symbolStream); + MetadataReader metadata = provider.GetMetadataReader(); + CodeViewDebugDirectoryData codeView = pe.ReadCodeViewDebugDirectoryData(Assert.Single(pe.ReadDebugDirectory(), entry => entry.Type == DebugDirectoryEntryType.CodeView)); + Assert.Multiple( + () => Assert.Equal(new Guid(metadata.DebugMetadataHeader!.Id.Take(16).ToArray()), codeView.Guid), + () => Assert.Equal(BitConverter.ToUInt32(metadata.DebugMetadataHeader!.Id.AsSpan()[16..]), + Assert.Single(pe.ReadDebugDirectory(), entry => entry.Type == DebugDirectoryEntryType.CodeView).Stamp), + () => Assert.NotEmpty(metadata.Documents), + () => Assert.All(metadata.Documents, handle => + { + Document document = metadata.GetDocument(handle); + Assert.Multiple( + () => Assert.NotEmpty(metadata.GetString(document.Name)), + () => Assert.NotEmpty(metadata.GetBlobBytes(document.Hash)), + () => Assert.NotEqual(Guid.Empty, metadata.GetGuid(document.HashAlgorithm))); + })); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageInteroperabilityTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageInteroperabilityTests.cs new file mode 100644 index 0000000..eda4be5 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageInteroperabilityTests.cs @@ -0,0 +1,38 @@ +using System.Text.Json; +using DimensionalQuantities.IntegrationTests.Fixtures; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +public sealed class PackageInteroperabilityTests : IClassFixture +{ + private readonly PackageInteroperabilityFixture _fixture; + + public PackageInteroperabilityTests(PackageInteroperabilityFixture fixture) + { + _fixture = fixture; + } + + [Fact] + public async Task IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() + { + using JsonDocument result = JsonDocument.Parse(await _fixture.ExecuteConsumer()); + JsonElement sharedTypes = result.RootElement.GetProperty("SharedTypes"); + JsonElement values = result.RootElement.GetProperty("Values"); + Assert.Multiple( + () => Assert.True(sharedTypes.GetProperty("NamedProducers").GetBoolean()), + () => Assert.True(sharedTypes.GetProperty("NamedConsumer").GetBoolean()), + () => Assert.True(sharedTypes.GetProperty("IntermediateProducers").GetBoolean()), + () => Assert.True(sharedTypes.GetProperty("IntermediateConsumer").GetBoolean()), + () => Assert.True(sharedTypes.GetProperty("IntermediateRuntime").GetBoolean()), + () => Assert.True(sharedTypes.GetProperty("ExtendedRuntime").GetBoolean()), + () => Assert.Equal(6d, values.GetProperty("Direct").GetDouble()), + () => Assert.Equal(12d, values.GetProperty("Collection").GetDouble()), + () => Assert.Equal(6d, values.GetProperty("Contained").GetDouble()), + () => Assert.Equal(0.006d, values.GetProperty("Prefixed").GetDouble(), 12), + () => Assert.Equal(24d, values.GetProperty("Product").GetDouble()), + () => Assert.Equal(6d, values.GetProperty("Intermediate").GetDouble()), + () => Assert.Equal(10d, values.GetProperty("IndependentIntermediate").GetDouble()), + () => Assert.Equal(24d, values.GetProperty("IntermediateProduct").GetDouble())); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs new file mode 100644 index 0000000..e69d1d1 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs @@ -0,0 +1,118 @@ +using System.Text.Json; +using DimensionalQuantities.IntegrationTests.Delivery; +using DimensionalQuantities.IntegrationTests.Fixtures; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +[Collection(typeof(PackageDeliveryCollection))] +public sealed class PackageReferenceTests +{ + private readonly PackageDeliveryFixture _fixture; + + public PackageReferenceTests(PackageDeliveryFixture fixture) + { + _fixture = fixture; + } + + [Fact] + public async Task CorePackageActivatesGeneratorAndRunsWithoutToolingRuntimeDependencies() + { + using PackageSandbox sandbox = _fixture.CreateConsumer(); + sandbox.WriteConsumer(""" + Console.WriteLine((Length.FromMetres(6) * Current.FromAmps(2)).AsSiBaseUnit()); + """, "DimensionalQuantities"); + string output = await sandbox.ExecuteConsumer(); + using JsonDocument dependencies = JsonDocument.Parse(File.ReadAllText(Path.Combine(sandbox.Consumer, "bin/Release/net11.0/Consumer.deps.json"))); + Assert.Multiple( + () => Assert.Equal("12", output), + () => Assert.Equal(["Consumer", "DimensionalQuantities"], dependencies.RootElement.GetProperty("libraries").EnumerateObject().Select(p => p.Name.Split('/')[0]).Order().ToArray())); + } + + [Fact] + public async Task CorePackageDeliversDimensionalMismatchAnalyzer() + { + using PackageSandbox sandbox = _fixture.CreateConsumer(); + sandbox.WriteConsumer(""" + Console.WriteLine(Length.FromMetres(1) + Time.FromSeconds(1)); + """, "DimensionalQuantities"); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error DQ0001:", result.Output)); + } + + [Theory] + [InlineData("Metric", "Voltage.FromVolts(2)")] + [InlineData("Imperial", "Length.FromFeet(2)")] + [InlineData("Nautical", "Length.FromNauticalMiles(2)")] + [InlineData("CgsEmag", "MagneticFluxDensity.FromGauss(2)")] + public async Task OptionalPackageAloneSuppliesMatchingCoreAndCallableConversions(string extension, string expression) + { + string id = "DimensionalQuantities.Extensions." + extension; + using PackageSandbox sandbox = _fixture.CreateConsumer(); + sandbox.WriteConsumer($$""" + using {{id}}; + Console.WriteLine(({{expression}}).AsSiBaseUnit() > 0); + """, id); + string output = await sandbox.ExecuteConsumer(); + using JsonDocument assets = JsonDocument.Parse(File.ReadAllText(Path.Combine(sandbox.Consumer, "obj/project.assets.json"))); + string[] direct = assets.RootElement.GetProperty("project").GetProperty("frameworks").EnumerateObject().Single().Value.GetProperty("dependencies").EnumerateObject().Select(p => p.Name).ToArray(); + Assert.Multiple( + () => Assert.Equal("True", output), + () => Assert.True(assets.RootElement.GetProperty("libraries").TryGetProperty("DimensionalQuantities/" + sandbox.Version, out _)), + () => Assert.Equal([id], direct)); + } + + [Theory] + [InlineData("Metric", "Voltage.FromVolts(2)")] + [InlineData("Imperial", "Length.FromFeet(2)")] + [InlineData("Nautical", "Length.FromNauticalMiles(2)")] + [InlineData("CgsEmag", "MagneticFluxDensity.FromGauss(2)")] + public async Task OptionalConversionsRequireNamespaceImport(string extension, string expression) + { + string id = "DimensionalQuantities.Extensions." + extension; + using PackageSandbox sandbox = _fixture.CreateConsumer(); + sandbox.WriteConsumer($$""" + Console.WriteLine(({{expression}}).AsSiBaseUnit()); + """, id); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error CS0117:", result.Output)); + } + + [Theory] + [InlineData("Voltage.FromVolts(2)")] + [InlineData("Length.FromFeet(2)")] + [InlineData("Length.FromNauticalMiles(2)")] + [InlineData("MagneticFluxDensity.FromGauss(2)")] + public async Task CorePackageDoesNotSupplyOptionalConversions(string expression) + { + using PackageSandbox sandbox = _fixture.CreateConsumer(); + sandbox.WriteConsumer($$""" + Console.WriteLine(({{expression}}).AsSiBaseUnit()); + """, "DimensionalQuantities"); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error CS0117:", result.Output)); + } + + [Fact] + public async Task CompatibleOptionalPackagesComposeThroughOneRuntimeType() + { + using PackageSandbox sandbox = _fixture.CreateConsumer(); + string[] ids = ["DimensionalQuantities.Extensions.Metric", "DimensionalQuantities.Extensions.Imperial", "DimensionalQuantities.Extensions.Nautical", "DimensionalQuantities.Extensions.CgsEmag"]; + sandbox.WriteConsumer(""" + using DimensionalQuantities.Extensions.Metric; + using DimensionalQuantities.Extensions.Imperial; + using DimensionalQuantities.Extensions.Nautical; + using DimensionalQuantities.Extensions.CgsEmag; + Length total = Length.FromFeet(1) + Length.FromNauticalMiles(1); + Energy work = Energy.FromJoules(2) + Energy.FromErgs(10_000_000); + Console.WriteLine(total.AsSiBaseUnit() > 1852 && work.AsSiBaseUnit() == 3); + """, ids); + Assert.Equal("True", await sandbox.ExecuteConsumer()); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageSourceTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageSourceTests.cs new file mode 100644 index 0000000..e2650e5 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageSourceTests.cs @@ -0,0 +1,113 @@ +using System.Buffers.Binary; +using System.Diagnostics; +using System.IO.Compression; +using System.Reflection; +using System.Reflection.Metadata; +using System.Text.Json; +using DimensionalQuantities.IntegrationTests.Delivery; +using DimensionalQuantities.IntegrationTests.Fixtures; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +[Collection(typeof(PackageArchiveCollection))] +public sealed class PackageSourceTests +{ + private readonly PackageArchiveFixture _fixture; + + public PackageSourceTests(PackageArchiveFixture fixture) + { + _fixture = fixture; + } + + [Theory] + [InlineData("DimensionalQuantities", "lib/netstandard2.0", "DimensionalQuantities")] + [InlineData("DimensionalQuantities", "analyzers/dotnet/cs", "DimensionalQuantities")] + [InlineData("DimensionalQuantities", "analyzers/dotnet/cs", "DimensionalQuantities.Roslyn")] + [InlineData("DimensionalQuantities", "analyzers/dotnet/cs", "DimensionalQuantities.Roslyn.CodeFixes")] + [InlineData("DimensionalQuantities.Extensions.Metric", "lib/netstandard2.0", "DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial", "lib/netstandard2.0", "DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical", "lib/netstandard2.0", "DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag", "lib/netstandard2.0", "DimensionalQuantities.Extensions.CgsEmag")] + public async Task PackagedSymbolsMapSourceToCurrentCommit(string id, string directory, string assembly) + { + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive symbols = ZipFile.OpenRead(sandbox.ArchivePath(id, symbols: directory == "lib/netstandard2.0")); + using Stream stream = symbols.GetEntry($"{directory}/{assembly}.pdb")!.Open(); + using MemoryStream pdb = new(); + await stream.CopyToAsync(pdb, TestContext.Current.CancellationToken); + pdb.Position = 0; + using MetadataReaderProvider provider = MetadataReaderProvider.FromPortablePdbStream(pdb); + MetadataReader reader = provider.GetMetadataReader(); + Guid sourceLinkKind = new("CC110556-A091-4D38-9FEC-25AB9A351A6A"); + CustomDebugInformation sourceLink = Assert.Single(reader.CustomDebugInformation.Select(reader.GetCustomDebugInformation), + info => reader.GetGuid(info.Kind) == sourceLinkKind); + using JsonDocument mapping = JsonDocument.Parse(reader.GetBlobBytes(sourceLink.Value)); + string commit = ReadCurrentCommit(); + + Assert.Contains(mapping.RootElement.GetProperty("documents").EnumerateObject(), + entry => entry.Value.GetString() == $"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*"); + } + + [Theory] + [InlineData("Metric")] + [InlineData("Imperial")] + [InlineData("Nautical")] + [InlineData("CgsEmag")] + public async Task ExtensionSymbolsEmbedGeneratedSourceMatchingBuildOutput(string extension) + { + string id = "DimensionalQuantities.Extensions." + extension; + PackageSandbox sandbox = _fixture.Packages; + using ZipArchive symbols = ZipFile.OpenRead(sandbox.ArchivePath(id, symbols: true)); + using Stream stream = symbols.GetEntry($"lib/netstandard2.0/{id}.pdb")!.Open(); + using MemoryStream pdb = new(); + await stream.CopyToAsync(pdb, TestContext.Current.CancellationToken); + pdb.Position = 0; + using MetadataReaderProvider provider = MetadataReaderProvider.FromPortablePdbStream(pdb); + MetadataReader reader = provider.GetMetadataReader(); + string fileName = $"{id}.{extension}Units.g.cs"; + DocumentHandle document = Assert.Single(reader.Documents, + handle => Path.GetFileName(reader.GetString(reader.GetDocument(handle).Name)) == fileName); + Guid embeddedSourceKind = new("0E8A571B-6926-466E-B4AD-8AB04611F5FE"); + CustomDebugInformation embedded = Assert.Single(reader.GetCustomDebugInformation(document).Select(reader.GetCustomDebugInformation), + info => reader.GetGuid(info.Kind) == embeddedSourceKind); + byte[] actual = DecodeEmbeddedSource(reader.GetBlobBytes(embedded.Value)); + string configuration = typeof(PackageSourceTests).Assembly.GetCustomAttribute()!.Configuration; + byte[] expected = await File.ReadAllBytesAsync(Path.Combine(SourceDirectory, id, "obj", configuration, "netstandard2.0", "generated", + "DimensionalQuantities.Roslyn", "DimensionalQuantities.Roslyn.Generators.QuantityGenerator", fileName), TestContext.Current.CancellationToken); + + Assert.Equal(expected, actual); + } + + private static string SourceDirectory => Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); + + private static string ReadCurrentCommit() + { + ProcessStartInfo start = new("git") { WorkingDirectory = SourceDirectory, RedirectStandardOutput = true, RedirectStandardError = true }; + start.ArgumentList.Add("rev-parse"); + start.ArgumentList.Add("HEAD"); + using Process process = Process.Start(start)!; + string commit = process.StandardOutput.ReadToEnd().Trim(); + string error = process.StandardError.ReadToEnd(); + process.WaitForExit(); + if (process.ExitCode != 0) + { + throw new InvalidOperationException($"git rev-parse HEAD failed: {error}"); + } + return commit; + } + + private static byte[] DecodeEmbeddedSource(byte[] blob) + { + int uncompressedSize = BinaryPrimitives.ReadInt32LittleEndian(blob); + if (uncompressedSize == 0) + { + return blob[sizeof(int)..]; + } + using MemoryStream compressed = new(blob, sizeof(int), blob.Length - sizeof(int)); + using DeflateStream deflate = new(compressed, CompressionMode.Decompress); + using MemoryStream source = new(); + deflate.CopyTo(source); + return source.ToArray(); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs deleted file mode 100644 index 28343f7..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs +++ /dev/null @@ -1,6 +0,0 @@ -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -[CollectionDefinition("MSBuild", DisableParallelization = true)] -public sealed class MsbuildCollection; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs deleted file mode 100644 index 5762478..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs +++ /dev/null @@ -1,53 +0,0 @@ -using System.IO.Compression; -using System.Reflection; -using Microsoft.Build.Evaluation; -using Microsoft.Build.Execution; -using Microsoft.Build.Utilities.ProjectCreation; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -internal static class PackageTestSupport -{ - public static Package AddPackedPackage(PackageRepository repository, FileInfo archive) - { - repository.Package(archive, out Package package); - // ProjectCreation rewrites the nuspec without dependency groups; restore the packed manifest for transitive consumers. - using ZipArchive zip = ZipFile.OpenRead(archive.FullName); - ZipArchiveEntry manifest = zip.Entries.Single(entry => entry.Name.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase)); - using Stream source = manifest.Open(); - using Stream destination = File.Create(repository.GetManifestFilePath(package.Id, package.Version)); - source.CopyTo(destination); - return package; - } - - public static FileInfo PackLibrary(string sourceProject, string scratch) - { - string packageOutput = Path.Combine(scratch, "package"); - Directory.CreateDirectory(packageOutput); - Dictionary properties = new() - { - ["Configuration"] = typeof(PackageTestSupport).Assembly.GetCustomAttribute()!.Configuration, - ["NoBuild"] = "true", - ["PackageOutputPath"] = packageOutput, - ["NuGetAudit"] = "false", - }; - using ProjectCollection collection = new(properties); - Project project = collection.LoadProject(sourceProject); - string packageId = project.GetPropertyValue("PackageId"); - string packageVersion = project.GetPropertyValue("PackageVersion"); - using BuildOutput output = BuildOutput.Create(); - BuildParameters parameters = new(collection) { Loggers = [output] }; - BuildRequestData request = new(project.CreateProjectInstance(), ["Pack"]); - BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, request); - if (result.OverallResult != BuildResultCode.Success) - { - throw new InvalidOperationException($"Pack failed.{Environment.NewLine}{output.GetConsoleLog()}"); - } - FileInfo nupkg = new(Path.Combine(packageOutput, $"{packageId}.{packageVersion}.nupkg")); - if (!nupkg.Exists) - { - throw new FileNotFoundException("Pack did not create the expected package", nupkg.FullName); - } - return nupkg; - } -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs deleted file mode 100644 index 3413f08..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs +++ /dev/null @@ -1,493 +0,0 @@ -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 -{ - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-").FullName; - - static PackagedGeneratorTests() - { - // MSBuild must be located before any Microsoft.Build type is loaded. - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } - } - - [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", """ - public static class Consumer - { - public static double ConvertLength() => Length.FromMetres(2.5).AsMetres(); - public static double ConvertCurrent() => Current.FromAmps(3).AsAmps(); - public static double CalculateArea() => (Length.FromMetres(2) * Length.FromMetres(3)).AsSiBaseUnit(); - public static double NamedArea() => Area.FromSiBaseUnit(6).AsSiBaseUnit(); - } - """, core); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("CoreConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CoreConsumer"), "CoreConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(2.5, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(3, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(6, InvokeDouble(type, "CalculateArea")), - () => Assert.Equal(6, InvokeDouble(type, "NamedArea"))); - } - - [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 DimensionalQuantities.Extensions.Metric; - - public static class Consumer - { - public static double ConvertVoltage(double volts) => Voltage.FromVolts(volts).AsVolts(); - public static double MultiplyVoltageCurrent(double volts, double amps) - { - Power power = Voltage.FromVolts(volts) * Current.FromAmps(amps); - return power.AsWatts(); - } - } - """, metric); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("MetricConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("MetricConsumer"), "MetricConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(12.5, InvokeDouble(type, "ConvertVoltage", 12.5)), - () => Assert.Equal(25, InvokeDouble(type, "MultiplyVoltageCurrent", 12.5, 2.0))); - } - - [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 DimensionalQuantities.Extensions.Imperial; - - public static class Consumer - { - public static double ConvertLength() => Length.FromFeet(6).AsSiBaseUnit(); - public static double ConvertTemperature() => Temperature.FromRankine(491.67).AsSiBaseUnit(); - } - """, imperial); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("ImperialConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(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 DimensionalQuantities.Extensions.Nautical; - - public static class Consumer - { - public static double ConvertLength() => Length.FromNauticalMiles(1).AsSiBaseUnit(); - public static double ConvertSpeed() => Speed.FromKnots(1).AsSiBaseUnit(); - } - """, nautical); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("NauticalConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("NauticalConsumer"), "NauticalConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1852, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(1852d / 3600d, InvokeDouble(type, "ConvertSpeed"))); - } - - [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 DimensionalQuantities.Extensions.CgsEmag; - - public static class Consumer - { - public static double ConvertFluxDensity() => MagneticFluxDensity.FromGauss(10_000).AsSiBaseUnit(); - public static double ConvertCurrent() => Current.FromAbamperes(1).AsSiBaseUnit(); - public static double ConvertCharge() => ElectricCharge.FromAbcoulombs(1).AsSiBaseUnit(); - } - """, cgsEmag); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("CgsEmagConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CgsEmagConsumer"), "CgsEmagConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1, InvokeDouble(type, "ConvertFluxDensity")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCharge"))); - } - - [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", """ - public static class Consumer - { - public static double Convert() => Voltage.FromVolts(12.5).AsVolts(); - } - """, metric); - consumer.TryBuild(restore: true, out bool built, out BuildOutput output); - using (output) - { - string log = output.GetConsoleLog(); - Assert.Multiple( - () => Assert.False(built, log), - () => Assert.Contains(output.ErrorEvents, error => error.Code == "CS0117" && error.Message!.Contains("FromVolts", StringComparison.Ordinal)), - () => Assert.DoesNotContain(output.ErrorEvents, error => error.Code is "CS8032" or "CS8785" or "AD0001"), - () => Assert.DoesNotContain(output.WarningEvents, warning => warning.Code is "CS8032" or "CS8785" or "AD0001")); - } - } - - [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); - } - -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs deleted file mode 100644 index 03ce449..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs +++ /dev/null @@ -1,173 +0,0 @@ -using System.Buffers.Binary; -using System.Diagnostics; -using System.Reflection; -using System.IO.Compression; -using System.Reflection.Metadata; -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 -{ - 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; - - static SymbolPackageTests() - { - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } - } - - [Fact] - public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() - { - (FileInfo package, FileInfo symbols) = Pack("DimensionalQuantities"); - using ZipArchive binaries = ZipFile.OpenRead(package.FullName); - using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); - string commit = GetCurrentCommit(); - foreach (string stem in new[] - { - "lib/netstandard2.0/DimensionalQuantities", - "analyzers/dotnet/cs/DimensionalQuantities", - "analyzers/dotnet/cs/DimensionalQuantities.Roslyn", - "analyzers/dotnet/cs/DimensionalQuantities.Roslyn.CodeFixes", - }) - { - SymbolDetails details = ReadSymbolDetails(binaries, symbolArchive, stem); - Assert.Multiple( - () => Assert.Equal(details.AssemblyGuid, details.PdbGuid), - () => Assert.Equal(details.AssemblyStamp, details.PdbStamp), - () => Assert.Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*", details.SourceUrls)); - } - } - - [Theory] - [InlineData("Metric")] - [InlineData("Imperial")] - [InlineData("Nautical")] - [InlineData("CgsEmag")] - public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string extension) - { - string projectName = "DimensionalQuantities.Extensions." + extension; - (FileInfo package, FileInfo symbols) = Pack(projectName); - using ZipArchive binaries = ZipFile.OpenRead(package.FullName); - using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); - SymbolDetails details = ReadSymbolDetails(binaries, symbolArchive, "lib/netstandard2.0/" + projectName, - projectName + "." + extension + "Units.g.cs"); - string commit = GetCurrentCommit(); - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - string configuration = typeof(SymbolPackageTests).Assembly.GetCustomAttribute()!.Configuration; - byte[] generatedSource = File.ReadAllBytes(Path.Combine(sourceDirectory, projectName, "obj", configuration, "netstandard2.0", - "generated", "DimensionalQuantities.Roslyn", "DimensionalQuantities.Roslyn.Generators.QuantityGenerator", projectName + "." + extension + "Units.g.cs")); - Assert.Multiple( - () => Assert.Equal(details.AssemblyGuid, details.PdbGuid), - () => Assert.Equal(details.AssemblyStamp, details.PdbStamp), - () => Assert.Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*", details.SourceUrls), - () => Assert.Equal(generatedSource, details.EmbeddedGeneratedSource)); - } - - private (FileInfo Package, FileInfo Symbols) Pack(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); - } - - private static SymbolDetails ReadSymbolDetails(ZipArchive binaries, ZipArchive symbols, string stem, string? generatedFileName = null) - { - byte[] assemblyBytes = ReadEntry(binaries, stem + ".dll"); - byte[] pdbBytes = ReadEntry(symbols, stem + ".pdb"); - using PEReader assembly = new(new MemoryStream(assemblyBytes)); - using MetadataReaderProvider pdb = MetadataReaderProvider.FromPortablePdbStream(new MemoryStream(pdbBytes)); - DebugDirectoryEntry codeView = assembly.ReadDebugDirectory().Single(entry => entry.Type == DebugDirectoryEntryType.CodeView); - CodeViewDebugDirectoryData codeViewData = assembly.ReadCodeViewDebugDirectoryData(codeView); - MetadataReader reader = pdb.GetMetadataReader(); - byte[] pdbId = reader.DebugMetadataHeader!.Id.ToArray(); - string sourceLink = reader.CustomDebugInformation - .Select(reader.GetCustomDebugInformation) - .Where(info => reader.GetGuid(info.Kind) == _sourceLinkKind) - .Select(info => Encoding.UTF8.GetString(reader.GetBlobBytes(info.Value))) - .Single(); - using JsonDocument sourceLinkDocument = JsonDocument.Parse(sourceLink); - string[] sourceUrls = sourceLinkDocument.RootElement.GetProperty("documents").EnumerateObject() - .Select(mapping => mapping.Value.GetString()!).ToArray(); - byte[]? embeddedGeneratedSource = reader.Documents - .Where(handle => generatedFileName is not null && reader.GetString(reader.GetDocument(handle).Name).EndsWith(generatedFileName, StringComparison.Ordinal)) - .SelectMany(handle => reader.GetCustomDebugInformation(handle)) - .Select(reader.GetCustomDebugInformation) - .Where(info => reader.GetGuid(info.Kind) == _embeddedSourceKind) - .Select(info => DecodeEmbeddedSource(reader.GetBlobBytes(info.Value))) - .SingleOrDefault(); - return new(codeViewData.Guid, codeView.Stamp, new Guid(pdbId.AsSpan(0, 16)), BitConverter.ToUInt32(pdbId, 16), sourceUrls, embeddedGeneratedSource); - } - - private static byte[] DecodeEmbeddedSource(byte[] blob) - { - if (blob.Length < sizeof(int)) - { - throw new InvalidDataException("Embedded source blob is too short."); - } - int uncompressedSize = BinaryPrimitives.ReadInt32LittleEndian(blob); - if (uncompressedSize == 0) - { - return blob[sizeof(int)..]; - } - if (uncompressedSize < 0) - { - throw new InvalidDataException("Embedded source has an invalid uncompressed size."); - } - using MemoryStream compressed = new(blob, sizeof(int), blob.Length - sizeof(int)); - using DeflateStream deflate = new(compressed, CompressionMode.Decompress); - using MemoryStream source = new(); - deflate.CopyTo(source); - byte[] bytes = source.ToArray(); - if (bytes.Length != uncompressedSize) - { - throw new InvalidDataException("Embedded source length does not match its header."); - } - return bytes; - } - - private static byte[] ReadEntry(ZipArchive archive, string path) - { - ZipArchiveEntry entry = archive.GetEntry(path) ?? throw new InvalidOperationException($"Package does not contain {path}."); - using Stream stream = entry.Open(); - using MemoryStream bytes = new(); - stream.CopyTo(bytes); - return bytes.ToArray(); - } - - private static string GetCurrentCommit() - { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..", "..")); - ProcessStartInfo start = new("git") { WorkingDirectory = sourceDirectory, RedirectStandardOutput = true, RedirectStandardError = true }; - start.ArgumentList.Add("rev-parse"); - start.ArgumentList.Add("HEAD"); - using Process process = Process.Start(start) ?? throw new InvalidOperationException("Could not start git."); - string commit = process.StandardOutput.ReadToEnd().Trim(); - string error = process.StandardError.ReadToEnd(); - process.WaitForExit(); - if (process.ExitCode != 0) - { - throw new InvalidOperationException($"git rev-parse HEAD failed: {error}"); - } - return commit; - } - - 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 deleted file mode 100644 index c7368cb..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs +++ /dev/null @@ -1,120 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Analyzers; -using Microsoft.CodeAnalysis; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -public sealed class DimensionMismatchAnalyzerTests -{ - [Theory] - [InlineData("+")] - [InlineData("-")] - [InlineData("<")] - [InlineData(">")] - [InlineData("<=")] - [InlineData(">=")] - [InlineData("==")] - [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))); - } - - [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) - { - 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)); - } - - [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) { }")] - public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) - { - ImmutableArray result = await AnalyzerTestCompilation.Analyze($"public class Consumer {{ {member} }}", new DimensionMismatchAnalyzer()); - Assert.Empty(result); - } - - [Theory] - [InlineData("+=")] - [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); - } - - [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); - } - - [Fact] - public async Task ExistingUserOperatorIsRespected() - { - const string source = """ - public static class Custom - { - 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); - } - - [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); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs deleted file mode 100644 index 36010d3..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs +++ /dev/null @@ -1,72 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Analyzers; -using Microsoft.CodeAnalysis; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -public sealed class QuantityEncodingAnalyzerTests -{ - private const string LengthType = "Quantity>"; - - [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))); - } - - [Theory] - [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] - [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)); - } - - [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) - { - 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)); - } - - [Theory] - [InlineData("Quantity")] - [InlineData("Power")] - 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); - } - - [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; } }")] - public async Task DeliberateAliasesOpenGenericsAndUnrelatedTypesAreAllowed(string source) - { - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer()); - Assert.Empty(result); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs deleted file mode 100644 index e2e6779..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs +++ /dev/null @@ -1,94 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Analyzers; -using DimensionalQuantities.Roslyn.CodeFixes; -using DimensionalQuantities.Roslyn.Tests.Analyzers; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CodeActions; -using Microsoft.CodeAnalysis.CodeFixes; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.CodeAnalysis.Text; -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)] - 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)); - } - - [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); - } - - [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")) - { - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - } - Assert.Empty(actions); - } - - private static Document CreateDocument(AdhocWorkspace workspace, string source) - { - 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")) - { - workspace.AddDocument(project.Id, Path.GetFileName(tree.FilePath), tree.GetText()); - } - return workspace.CurrentSolution.GetDocument(userDocument.Id)!; - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs new file mode 100644 index 0000000..4de70ef --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs @@ -0,0 +1,394 @@ +using DimensionalQuantities.Roslyn.CodeFixes; +using DimensionalQuantities.Roslyn.Analyzers; +using Microsoft.CodeAnalysis.CSharp.Testing; +using DimensionalQuantities.Roslyn.Tests.Framework; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; + +public sealed class QuantityAliasFixTests +{ + private const string RawLength = "Quantity>"; + private const string RawTime = "Quantity>"; + private const string RawLengthCurrent = "Quantity>"; + + [Theory] + [InlineData(RawTime, "Time")] + [InlineData(RawLengthCurrent, "LengthCurrent")] + public async Task FixUsesTheSuggestedNonLengthAlias(string rawType, string alias) + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + {|#0:{{rawType}}|} field; + } + """, + FixedCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + {{alias}} field; + } + """, + CodeActionEquivalenceKey = "UseAlias:" + alias, + CodeActionVerifier = (action, verifier) => Assert.Equal("Use " + alias, action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, alias)); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public void ProviderAdvertisesOnlyAliasSuggestionAndActualBatchFixer() + { + QuantityAliasCodeFixProvider provider = new(); + Assert.Multiple( + () => Assert.Equal(new[] { "DQ0003" }, provider.FixableDiagnosticIds), + () => Assert.Same(Microsoft.CodeAnalysis.CodeFixes.WellKnownFixAllProviders.BatchFixer, provider.GetFixAllProvider())); + } + + [Theory] + [InlineData( + """ + {0} field; + """, + """ + Length field; + """)] + [InlineData( + """ + {0}?[] field; + """, + """ + Length?[] field; + """)] + [InlineData( + """ + System.Collections.Generic.List<{0}> field; + """, + """ + System.Collections.Generic.List field; + """)] + [InlineData( + """ + global::DimensionalQuantities.TypeSystem.{0} field; + """, + """ + Length field; + """)] + [InlineData( + """ + /* before */ {0} /* after */ field; + """, + """ + /* before */ Length /* after */ field; + """)] + public async Task TypeReplacementPreservesWrappersAndExteriorSyntax(string declaration, string fixedDeclaration) + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + {{string.Format(declaration, "{|#0:" + RawLength + "|}")}} + } + """, + FixedCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + {{fixedDeclaration}} + } + """, + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData( + """ + class Length + { + } + """)] + [InlineData( + """ + using Length = System.String; + """)] + public async Task DifferentlyBoundAliasWithholdsFix(string shadow) + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + namespace Consumer + { + {{shadow}} + + class Measurement + { + {|#0:{{RawLength}}|} field; + } + } + """, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task SameTypeVisibleAliasIsEligible() + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + namespace Consumer + { + using Length = {{RawLength}}; + + class Measurement + { + {|#0:{{RawLength}}|} field; + } + } + """, + FixedCode = $$""" + using DimensionalQuantities.TypeSystem; + + namespace Consumer + { + using Length = {{RawLength}}; + + class Measurement + { + Length field; + } + } + """, + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData( + """ + nameof({0}) + """)] + [InlineData( + """ + nameof(System.Collections.Generic.List<{0}>) + """)] + public async Task RealNameofOperationWithholdsFix(string expression) + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + string name = {{string.Format(expression, "{|#0:" + RawLength + "|}")}}; + } + """, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task OrdinaryInvocationNamedNameofIsEligible() + { + QuantityCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + static string @nameof(System.Type type) => type.Name; + string name = @nameof(typeof({|#0:{{RawLength}}|})); + } + """, + FixedCode = """ + using DimensionalQuantities.TypeSystem; + + class Measurement + { + static string @nameof(System.Type type) => type.Name; + string name = @nameof(typeof(Length)); + } + """, + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task LengthFixAllChangesEligibleSitesAcrossDocumentsAndKeepsOtherAliases() + { + QuantityCodeFixTest test = new() + { + CodeActionEquivalenceKey = "UseAlias:Length", + NumberOfIncrementalIterations = 3, + NumberOfFixAllIterations = 1, + NumberOfFixAllInDocumentIterations = 2 + }; + test.TestState.Sources.Add(("Measurements.cs", $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + {|#0:{{RawLength}}|} first; + {|#1:{{RawLength}}|} second; + {|#2:{{RawTime}}|} time; + string name = nameof({|#3:{{RawLength}}|}); + } + """)); + test.TestState.Sources.Add(("Other.cs", $$""" + using DimensionalQuantities.TypeSystem; + + class Other + { + {|#4:{{RawLength}}|} value; + } + + namespace Hidden + { + class Length + { + } + + class Shadowed + { + {|#5:{{RawLength}}|} value; + } + } + """)); + test.FixedState.Sources.Add(("Measurements.cs", $$""" + using DimensionalQuantities.TypeSystem; + + class Measurement + { + Length first; + Length second; + {|#2:{{RawTime}}|} time; + string name = nameof({|#3:{{RawLength}}|}); + } + """)); + test.FixedState.Sources.Add(("Other.cs", $$""" + using DimensionalQuantities.TypeSystem; + + class Other + { + Length value; + } + + namespace Hidden + { + class Length + { + } + + class Shadowed + { + {|#5:{{RawLength}}|} value; + } + } + """)); + foreach (int location in new[] { 0, 1, 3, 4, 5 }) + { + test.ExpectedDiagnostics.Add(Suggestion(location, "Length")); + } + + test.ExpectedDiagnostics.Add(Suggestion(2, "Time")); + test.FixedState.ExpectedDiagnostics.AddRange(new[] { Suggestion(2, "Time"), Suggestion(3, "Length"), Suggestion(5, "Length") }); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("", "")] + [InlineData( + """ + using First; + using Second; + """, + """ + namespace First + { + public class Length + { + } + } + + namespace Second + { + public class Length + { + } + } + """)] + [InlineData( + """ + using Length = Hidden.Container.Length; + """, + """ + namespace Hidden + { + public class Container + { + private class Length + { + } + } + } + """)] + public async Task MissingAmbiguousOrInaccessibleReplacementWithholdsFix(string directives, string declarations) + { + CSharpCodeFixTest test = new() + { + TestCode = $$""" + using DimensionalQuantities.TypeSystem; + {{directives}} + + class Measurement + { + {|#0:{{RawLength}}|} field; + } + + {{declarations}} + """, + CompilerDiagnostics = CompilerDiagnostics.None, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + QuantityTestEnvironment.Configure(test); + test.ExpectedDiagnostics.Add(Suggestion(0, "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/Diagnostics/DimensionMismatchTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs new file mode 100644 index 0000000..cd82836 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs @@ -0,0 +1,487 @@ +using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.Tests.Framework; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Testing; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.Diagnostics; + +public sealed class DimensionMismatchTests +{ + [Theory] + [InlineData("+")] + [InlineData("-")] + [InlineData("<")] + [InlineData(">")] + [InlineData("<=")] + [InlineData(">=")] + [InlineData("==")] + [InlineData("!=")] + public async Task IncompatibleBinaryOperandsReportWholeExpression(string operation) + { + QuantityAnalyzerTest test = Invalid($$""" + class Calculation + { + object Apply(Length distance, Time duration) => {|#0:distance {{operation}} duration|}; + } + """); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Time")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("+=")] + [InlineData("-=")] + public async Task IncompatibleCompoundAssignmentReportsWholeAssignment(string operation) + { + QuantityAnalyzerTest test = Invalid($$""" + class Calculation + { + void Apply(Length distance, Time duration) + { + {|#0:distance {{operation}} duration|}; + } + } + """); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Time")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData(""" + Length value = {|#0:Time.FromSiBaseUnit(2)|}; + """)] + [InlineData(""" + Length Value + { + get; + } = {|#0:Time.FromSiBaseUnit(2)|}; + """)] + [InlineData(""" + void Apply(Time duration) + { + Length value = {|#0:duration|}; + } + """)] + [InlineData(""" + void Apply(Length value, Time duration) + { + value = {|#0:duration|}; + } + """)] + [InlineData(""" + void Apply(Time duration) + { + Length first = default, second = {|#0:duration|}; + } + """)] + public async Task DestinationMismatchReportsSourceExpression(string member) + { + QuantityAnalyzerTest test = Invalid($$""" + class Calculation + { + {{member}} + } + """); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData(""" + Length Apply(Time duration) + { + return {|#0:duration|}; + } + """)] + [InlineData(""" + void Apply(Time duration) + { + Length Local() + { + return {|#0:duration|}; + } + } + """)] + [InlineData(""" + Time duration; + Length Value + { + get + { + return {|#0:duration|}; + } + } + """)] + [InlineData(""" + Length Apply(Time duration) => {|#0:duration|}; + """)] + [InlineData(""" + Time duration; + Length Value => {|#0:duration|}; + """)] + [InlineData(""" + Time duration; + Length this[int index] => {|#0:duration|}; + """)] + public async Task ReturnMismatchUsesDeclaredDestination(string member) + { + QuantityAnalyzerTest test = Invalid($$""" + class Calculation + { + {{member}} + } + """); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData(""" + Accept({|#0:duration|}); + """, + """ + void Accept(Length value) + { + } + """)] + [InlineData(""" + Accept(other: 1, value: {|#0:duration|}); + """, + """ + void Accept(Length value, int other) + { + } + """)] + [InlineData(""" + System.Action accept = _ => + { + }; + accept({|#0:duration|}); + """, "")] + [InlineData(""" + _ = new Parcel({|#0:duration|}); + """, + """ + class Parcel + { + public Parcel(Length value) + { + } + } + """)] + [InlineData(""" + Parcel parcel = new({|#0:duration|}); + """, + """ + class Parcel + { + public Parcel(Length value) + { + } + } + """)] + public async Task RecoverableArgumentMappingReportsExpectedDimension(string statement, string declaration) + { + QuantityAnalyzerTest test = Invalid($$""" + class Calculation + { + void Apply(Time duration) + { + {{statement}} + } + {{declaration}} + } + """); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData(""" + Accept(duration); + """, + """ + void Accept(Length value) + { + } + void Accept(Mass value) + { + } + """)] + [InlineData(""" + Accept(missing: duration); + """, + """ + void Accept(Length value) + { + } + """)] + public async Task UnknownOrAmbiguousArgumentsDoNotGuessDestination(string call, string declarations) + { + await Invalid($$""" + class Calculation + { + void Apply(Time duration) + { + {{call}} + } + {{declarations}} + } + """).RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task NullableQuantitiesRetainTheirDimensions() + { + QuantityAnalyzerTest test = Invalid(""" + class Calculation + { + Length? Apply(Time? duration) => {|#0:duration|}; + } + """); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData(""" + var sum = a + b; + """)] + [InlineData(""" + a += b; + """)] + [InlineData(""" + var same = a <= b; + """)] + [InlineData(""" + Length? lifted = a; + """)] + [InlineData(""" + var product = a * t; + """)] + [InlineData(""" + var ratio = a / t; + """)] + [InlineData(""" + var native = 1 + 2; + """)] + [InlineData(""" + object boxed = a; + """)] + public async Task SameDimensionAndNativeBindingRemainAccepted(string statement) + { + QuantityAnalyzerTest test = new() + { + TestCode = $$""" + class Calculation + { + void Apply(Length a, Length b, Time t) + { + {{statement}} + } + } + """ + }; + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task SupportedUserOperatorKeepsItsOwnBinding() + { + QuantityAnalyzerTest test = new() + { + TestCode = """ + class Calculation + { + public static string operator +(Calculation value, Time duration) => "supported"; + string Apply(Calculation value, Time duration) => value + duration; + } + """ + }; + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("System.Collections.Generic.List