From f527576bb56f58156fa0a133b9e989209532425f Mon Sep 17 00:00:00 2001 From: James McMahon Date: Sat, 14 Nov 2026 23:39:34 +0000 Subject: [PATCH] test: migrate test suite to TUnit --- .../CgsEmagConversionsTests.cs | 117 +-- ...Quantities.Extensions.CgsEmag.Tests.csproj | 6 +- ...uantities.Extensions.Imperial.Tests.csproj | 6 +- .../ImperialConversionsTests.cs | 153 +-- ...lQuantities.Extensions.Metric.Tests.csproj | 6 +- .../MetricConversionsTests.cs | 103 ++- ...uantities.Extensions.Nautical.Tests.csproj | 6 +- .../NauticalConversionsTests.cs | 31 +- ...ensionalQuantities.IntegrationTests.csproj | 6 +- .../Packaging/MsbuildCollection.cs | 6 - .../Packaging/PackageDeliveryFixture.cs | 13 +- .../PackageInteroperabilityFixture.cs | 13 +- .../Packaging/PackageInteroperabilityTests.cs | 76 +- .../Packaging/PackagedGeneratorTests.cs | 88 +- .../Packaging/SymbolPackageFixture.cs | 13 +- .../Packaging/SymbolPackageTests.cs | 44 +- .../DimensionMismatchAnalyzerTests.cs | 92 +- .../QuantityEncodingAnalyzerTests.cs | 44 +- .../QuantityAliasCodeFixProviderTests.cs | 26 +- .../DimensionalQuantities.Roslyn.Tests.csproj | 6 +- .../Discovery/ArithmeticDiscoveryTests.cs | 102 +- .../Discovery/DiscoverySeedCollectorTests.cs | 12 +- .../EnglishExponentDiscoveryTests.cs | 76 +- .../MetadataQuantityDiscoveryTests.cs | 42 +- .../Discovery/PowerDiscoveryTests.cs | 88 +- .../Discovery/PowerMethodDiscoveryTests.cs | 116 +-- .../QuantityDiscoveryCoordinatorTests.cs | 563 ++++++------ .../Discovery/QuantityNameDiscoveryTests.cs | 52 +- .../Discovery/QuantityTypeReaderTests.cs | 50 +- .../Discovery/TypeSystemNumberReaderTests.cs | 52 +- .../Framework/QuantityCodeFixTest.cs | 3 +- .../ArithmeticSourceEmitterTests.cs | 41 +- .../Generators/CoreConversionBoundaryTests.cs | 30 +- .../DefaultQuantityDiscoveryTests.cs | 52 +- .../EnglishExponentAliasEmitterTests.cs | 48 +- .../FractionalPrefixEmitterTests.cs | 14 +- .../Generators/GenerationDiagnosticTests.cs | 98 +- .../PowerMethodSourceEmitterTests.cs | 55 +- .../Generators/PowerSourceEmitterTests.cs | 21 +- .../Generators/QuantityDiscoveryTests.cs | 166 ++-- .../Generators/QuantityGeneratorTests.cs | 868 ++++++++++-------- .../Generators/QuantitySourceEmitterTests.cs | 59 +- .../UnitConversionSourceEmitterTests.cs | 55 +- .../Generators/UnitProviderGenerationTests.cs | 87 +- .../Generators/UnitProviderReaderTests.cs | 97 +- .../DimensionalQuantities.Tests.csproj | 6 +- .../Dimensions/DimensionTests.cs | 147 +-- .../Naming/DimensionNameGeneratorTests.cs | 173 ++-- .../Naming/DimensionNameParserTests.cs | 99 +- .../Numerics/EnglishRationalParserTests.cs | 307 ++++--- .../Numerics/RationalTests.Conversions.cs | 197 ++-- .../Numerics/RationalTests.Text.cs | 153 +-- .../Numerics/RationalTests.cs | 229 ++--- .../TypeSystem/QuantityTests.cs | 281 +++--- .../TypeSystem/TypeSystemNumberCodecTests.cs | 129 +-- .../TypeSystem/TypeSystemNumbersTests.cs | 73 +- .../Units/UnitExpressionTests.cs | 253 ++--- 57 files changed, 3015 insertions(+), 2734 deletions(-) delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs diff --git a/src/DimensionalQuantities.Extensions.CgsEmag.Tests/CgsEmagConversionsTests.cs b/src/DimensionalQuantities.Extensions.CgsEmag.Tests/CgsEmagConversionsTests.cs index ae9df6b..cfa64a8 100644 --- a/src/DimensionalQuantities.Extensions.CgsEmag.Tests/CgsEmagConversionsTests.cs +++ b/src/DimensionalQuantities.Extensions.CgsEmag.Tests/CgsEmagConversionsTests.cs @@ -1,83 +1,92 @@ -using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Extensions.CgsEmag; -using Xunit; namespace DimensionalQuantities.Extensions.CgsEmag.Tests; public sealed class CgsEmagConversionsTests { - [Fact] - public void MechanicalUnitsConvertToCoherentSi() + [Test] + public async Task MechanicalUnitsConvertToCoherentSi() { - Assert.Multiple( - () => Assert.Equal(1e-5, Force.FromDynes(1).AsSiBaseUnit()), - () => Assert.Equal(1e-7, Energy.FromErgs(1).AsSiBaseUnit()), - () => Assert.Equal(0.1, Pressure.FromBaryes(1).AsSiBaseUnit()), - () => Assert.Equal(0.01, Acceleration.FromGals(1).AsSiBaseUnit())); + using (Assert.Multiple()) + { + await Assert.That(Force.FromDynes(1).AsSiBaseUnit()).IsEqualTo(1e-5); + await Assert.That(Energy.FromErgs(1).AsSiBaseUnit()).IsEqualTo(1e-7); + await Assert.That(Pressure.FromBaryes(1).AsSiBaseUnit()).IsEqualTo(0.1); + await Assert.That(Acceleration.FromGals(1).AsSiBaseUnit()).IsEqualTo(0.01); + } } - [Fact] - public void ElectromagneticUnitsConvertToCoherentSi() + [Test] + public async Task ElectromagneticUnitsConvertToCoherentSi() { - Assert.Multiple( - () => Assert.Equal(10, Current.FromAbamperes(1).AsSiBaseUnit()), - () => Assert.Equal(10, Current.FromBiots(1).AsSiBaseUnit()), - () => Assert.Equal(10, ElectricCharge.FromAbcoulombs(1).AsSiBaseUnit()), - () => Assert.Equal(1e-8, Voltage.FromAbvolts(1).AsSiBaseUnit()), - () => Assert.Equal(1e-9, Resistance.FromAbohms(1).AsSiBaseUnit()), - () => Assert.Equal(1e-9, Inductance.FromAbhenries(1).AsSiBaseUnit()), - () => Assert.Equal(1e9, Capacitance.FromAbfarads(1).AsSiBaseUnit()), - () => Assert.Equal(1e-8, MagneticFlux.FromMaxwells(1).AsSiBaseUnit()), - () => Assert.Equal(1e-4, MagneticFluxDensity.FromGauss(1).AsSiBaseUnit())); + using (Assert.Multiple()) + { + await Assert.That(Current.FromAbamperes(1).AsSiBaseUnit()).IsEqualTo(10); + await Assert.That(Current.FromBiots(1).AsSiBaseUnit()).IsEqualTo(10); + await Assert.That(ElectricCharge.FromAbcoulombs(1).AsSiBaseUnit()).IsEqualTo(10); + await Assert.That(Voltage.FromAbvolts(1).AsSiBaseUnit()).IsEqualTo(1e-8); + await Assert.That(Resistance.FromAbohms(1).AsSiBaseUnit()).IsEqualTo(1e-9); + await Assert.That(Inductance.FromAbhenries(1).AsSiBaseUnit()).IsEqualTo(1e-9); + await Assert.That(Capacitance.FromAbfarads(1).AsSiBaseUnit()).IsEqualTo(1e9); + await Assert.That(MagneticFlux.FromMaxwells(1).AsSiBaseUnit()).IsEqualTo(1e-8); + await Assert.That(MagneticFluxDensity.FromGauss(1).AsSiBaseUnit()).IsEqualTo(1e-4); + } double oersted = MagneticFieldStrength.FromOersteds(1).AsSiBaseUnit(); - Assert.InRange(oersted, 1000 / (4 * Math.PI) - 1e-12, 1000 / (4 * Math.PI) + 1e-12); + await Assert.That(oersted >= 1000 / (4 * Math.PI) - 1e-12 && oersted <= 1000 / (4 * Math.PI) + 1e-12).IsTrue(); } - [Fact] - public void AccessorsReturnOriginalCgsMagnitude() + [Test] + public async Task AccessorsReturnOriginalCgsMagnitude() { - Assert.Multiple( - () => Assert.Equal(1, Force.FromSiBaseUnit(1e-5).AsDynes()), - () => Assert.Equal(1, Energy.FromSiBaseUnit(1e-7).AsErgs()), - () => Assert.Equal(1, Pressure.FromSiBaseUnit(0.1).AsBaryes()), - () => Assert.Equal(1, Acceleration.FromSiBaseUnit(0.01).AsGals()), - () => Assert.Equal(1, Current.FromSiBaseUnit(10).AsAbamperes()), - () => Assert.Equal(1, Current.FromSiBaseUnit(10).AsBiots()), - () => Assert.Equal(1, ElectricCharge.FromSiBaseUnit(10).AsAbcoulombs()), - () => Assert.Equal(1, Voltage.FromSiBaseUnit(1e-8).AsAbvolts()), - () => Assert.Equal(1, Resistance.FromSiBaseUnit(1e-9).AsAbohms()), - () => Assert.Equal(1, Inductance.FromSiBaseUnit(1e-9).AsAbhenries()), - () => Assert.Equal(1, Capacitance.FromSiBaseUnit(1e9).AsAbfarads()), - () => Assert.Equal(1, MagneticFlux.FromSiBaseUnit(1e-8).AsMaxwells()), - () => Assert.Equal(1, MagneticFluxDensity.FromSiBaseUnit(1e-4).AsGauss())); + using (Assert.Multiple()) + { + await Assert.That(Force.FromSiBaseUnit(1e-5).AsDynes()).IsEqualTo(1); + await Assert.That(Energy.FromSiBaseUnit(1e-7).AsErgs()).IsEqualTo(1); + await Assert.That(Pressure.FromSiBaseUnit(0.1).AsBaryes()).IsEqualTo(1); + await Assert.That(Acceleration.FromSiBaseUnit(0.01).AsGals()).IsEqualTo(1); + await Assert.That(Current.FromSiBaseUnit(10).AsAbamperes()).IsEqualTo(1); + await Assert.That(Current.FromSiBaseUnit(10).AsBiots()).IsEqualTo(1); + await Assert.That(ElectricCharge.FromSiBaseUnit(10).AsAbcoulombs()).IsEqualTo(1); + await Assert.That(Voltage.FromSiBaseUnit(1e-8).AsAbvolts()).IsEqualTo(1); + await Assert.That(Resistance.FromSiBaseUnit(1e-9).AsAbohms()).IsEqualTo(1); + await Assert.That(Inductance.FromSiBaseUnit(1e-9).AsAbhenries()).IsEqualTo(1); + await Assert.That(Capacitance.FromSiBaseUnit(1e9).AsAbfarads()).IsEqualTo(1); + await Assert.That(MagneticFlux.FromSiBaseUnit(1e-8).AsMaxwells()).IsEqualTo(1); + await Assert.That(MagneticFluxDensity.FromSiBaseUnit(1e-4).AsGauss()).IsEqualTo(1); + } double oersted = MagneticFieldStrength.FromSiBaseUnit(1000 / (4 * Math.PI)).AsOersteds(); - Assert.InRange(oersted, 1 - 1e-14, 1 + 1e-14); + await Assert.That(oersted >= 1 - 1e-14 && oersted <= 1 + 1e-14).IsTrue(); } - [Fact] - public void SharedDimensionAliasesUseTheConversions() + [Test] + public async Task SharedDimensionAliasesUseTheConversions() { - Assert.Multiple( - () => Assert.Equal(1e-7, Torque.FromErgs(1).AsSiBaseUnit()), - () => Assert.Equal(0.1, Stress.FromBaryes(1).AsSiBaseUnit()), - () => Assert.Equal(0.1, YoungsModulus.FromBaryes(1).AsSiBaseUnit()), - () => Assert.Equal(1e-8, FluxLinkage.FromMaxwells(1).AsSiBaseUnit()), - () => Assert.Equal(1e-4, RemanentFluxDensity.FromGauss(1).AsSiBaseUnit())); + using (Assert.Multiple()) + { + await Assert.That(Torque.FromErgs(1).AsSiBaseUnit()).IsEqualTo(1e-7); + await Assert.That(Stress.FromBaryes(1).AsSiBaseUnit()).IsEqualTo(0.1); + await Assert.That(YoungsModulus.FromBaryes(1).AsSiBaseUnit()).IsEqualTo(0.1); + await Assert.That(FluxLinkage.FromMaxwells(1).AsSiBaseUnit()).IsEqualTo(1e-8); + await Assert.That(RemanentFluxDensity.FromGauss(1).AsSiBaseUnit()).IsEqualTo(1e-4); + } } - [Fact] - public void ProviderDoesNotGeneratePrefixConversions() + [Test] + public async Task ProviderDoesNotGeneratePrefixConversions() { string[] names = Assembly.Load("DimensionalQuantities.Extensions.CgsEmag").GetExportedTypes() .Where(type => type.Namespace == "DimensionalQuantities.Extensions.CgsEmag") .SelectMany(type => type.GetMethods()).Select(method => method.Name).ToArray(); - Assert.Multiple( - () => Assert.DoesNotContain("FromPrefixedUnits", names), - () => Assert.DoesNotContain("AsPrefixedUnits", names), - () => Assert.DoesNotContain("FromKiloGauss", names), - () => Assert.DoesNotContain("AsKiloGauss", names)); + using (Assert.Multiple()) + { + await Assert.That(names.Contains("FromPrefixedUnits")).IsFalse(); + await Assert.That(names.Contains("AsPrefixedUnits")).IsFalse(); + await Assert.That(names.Contains("FromKiloGauss")).IsFalse(); + await Assert.That(names.Contains("AsKiloGauss")).IsFalse(); + } } } diff --git a/src/DimensionalQuantities.Extensions.CgsEmag.Tests/DimensionalQuantities.Extensions.CgsEmag.Tests.csproj b/src/DimensionalQuantities.Extensions.CgsEmag.Tests/DimensionalQuantities.Extensions.CgsEmag.Tests.csproj index 7fe7d81..2800041 100644 --- a/src/DimensionalQuantities.Extensions.CgsEmag.Tests/DimensionalQuantities.Extensions.CgsEmag.Tests.csproj +++ b/src/DimensionalQuantities.Extensions.CgsEmag.Tests/DimensionalQuantities.Extensions.CgsEmag.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Extensions.Imperial.Tests/DimensionalQuantities.Extensions.Imperial.Tests.csproj b/src/DimensionalQuantities.Extensions.Imperial.Tests/DimensionalQuantities.Extensions.Imperial.Tests.csproj index 3ea9b45..125ecfb 100644 --- a/src/DimensionalQuantities.Extensions.Imperial.Tests/DimensionalQuantities.Extensions.Imperial.Tests.csproj +++ b/src/DimensionalQuantities.Extensions.Imperial.Tests/DimensionalQuantities.Extensions.Imperial.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Extensions.Imperial.Tests/ImperialConversionsTests.cs b/src/DimensionalQuantities.Extensions.Imperial.Tests/ImperialConversionsTests.cs index eddeeb8..12009d5 100644 --- a/src/DimensionalQuantities.Extensions.Imperial.Tests/ImperialConversionsTests.cs +++ b/src/DimensionalQuantities.Extensions.Imperial.Tests/ImperialConversionsTests.cs @@ -1,100 +1,113 @@ -using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Extensions.Imperial; -using Xunit; namespace DimensionalQuantities.Extensions.Imperial.Tests; public sealed class ImperialConversionsTests { - [Fact] - public void LengthAndAreaUseInternationalFoot() + [Test] + public async Task LengthAndAreaUseInternationalFoot() { - Assert.Multiple( - () => Assert.Equal(0.0254, Length.FromInches(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.3048, Length.FromFeet(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.9144, Length.FromYards(1).AsSiBaseUnit(), 12), - () => Assert.Equal(1609.344, Length.FromMiles(1).AsSiBaseUnit(), 9), - () => Assert.Equal(20.1168, Length.FromChains(1).AsSiBaseUnit(), 10), - () => Assert.Equal(201.168, Length.FromFurlongs(1).AsSiBaseUnit(), 10), - () => Assert.Equal(0.09290304, Area.FromSquareFeet(1).AsSiBaseUnit(), 12), - () => Assert.Equal(4046.8564224, Area.FromAcres(1).AsSiBaseUnit(), 8), - () => Assert.Equal(5280, Length.FromMiles(1).AsFeet(), 9)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Length.FromInches(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.0254, 12)); + await Assert.That(Math.Round(Length.FromFeet(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.3048, 12)); + await Assert.That(Math.Round(Length.FromYards(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.9144, 12)); + await Assert.That(Math.Round(Length.FromMiles(1).AsSiBaseUnit(), 9)).IsEqualTo(Math.Round(1609.344, 9)); + await Assert.That(Math.Round(Length.FromChains(1).AsSiBaseUnit(), 10)).IsEqualTo(Math.Round(20.1168, 10)); + await Assert.That(Math.Round(Length.FromFurlongs(1).AsSiBaseUnit(), 10)).IsEqualTo(Math.Round(201.168, 10)); + await Assert.That(Math.Round(Area.FromSquareFeet(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.09290304, 12)); + await Assert.That(Math.Round(Area.FromAcres(1).AsSiBaseUnit(), 8)).IsEqualTo(Math.Round(4046.8564224, 8)); + await Assert.That(Math.Round(Length.FromMiles(1).AsFeet(), 9)).IsEqualTo(Math.Round(5280d, 9)); + } } - [Fact] - public void VolumeKeepsUsAndImperialLiquidMeasuresDistinct() + [Test] + public async Task VolumeKeepsUsAndImperialLiquidMeasuresDistinct() { - Assert.Multiple( - () => Assert.Equal(0.000016387064, Volume.FromCubicInches(1).AsSiBaseUnit(), 15), - () => Assert.Equal(0.028316846592, Volume.FromCubicFeet(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.764554857984, Volume.FromCubicYards(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.003785411784, Volume.FromUSGallons(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.000946352946, Volume.FromUSQuarts(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.000473176473, Volume.FromUSPints(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.0000295735295625, Volume.FromUSFluidOunces(1).AsSiBaseUnit(), 15), - () => Assert.Equal(0.00454609, Volume.FromImperialGallons(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.0011365225, Volume.FromImperialQuarts(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.00056826125, Volume.FromImperialPints(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.0000284130625, Volume.FromImperialFluidOunces(1).AsSiBaseUnit(), 15), - () => Assert.Equal(128, Volume.FromUSGallons(1).AsUSFluidOunces(), 10), - () => Assert.Equal(160, Volume.FromImperialGallons(1).AsImperialFluidOunces(), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Volume.FromCubicInches(1).AsSiBaseUnit(), 15)).IsEqualTo(Math.Round(0.000016387064, 15)); + await Assert.That(Math.Round(Volume.FromCubicFeet(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.028316846592, 12)); + await Assert.That(Math.Round(Volume.FromCubicYards(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.764554857984, 12)); + await Assert.That(Math.Round(Volume.FromUSGallons(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.003785411784, 12)); + await Assert.That(Math.Round(Volume.FromUSQuarts(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.000946352946, 12)); + await Assert.That(Math.Round(Volume.FromUSPints(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.000473176473, 12)); + await Assert.That(Math.Round(Volume.FromUSFluidOunces(1).AsSiBaseUnit(), 15)).IsEqualTo(Math.Round(0.0000295735295625, 15)); + await Assert.That(Math.Round(Volume.FromImperialGallons(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.00454609, 12)); + await Assert.That(Math.Round(Volume.FromImperialQuarts(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.0011365225, 12)); + await Assert.That(Math.Round(Volume.FromImperialPints(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.00056826125, 12)); + await Assert.That(Math.Round(Volume.FromImperialFluidOunces(1).AsSiBaseUnit(), 15)).IsEqualTo(Math.Round(0.0000284130625, 15)); + await Assert.That(Math.Round(Volume.FromUSGallons(1).AsUSFluidOunces(), 10)).IsEqualTo(Math.Round(128d, 10)); + await Assert.That(Math.Round(Volume.FromImperialGallons(1).AsImperialFluidOunces(), 10)).IsEqualTo(Math.Round(160d, 10)); + } } - [Fact] - public void MassSpeedForceAndPressureUseTheirOwnDimensions() + [Test] + public async Task MassSpeedForceAndPressureUseTheirOwnDimensions() { - Assert.Multiple( - () => Assert.Equal(0.028349523125, Mass.FromOunces(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.45359237, Mass.FromPounds(1).AsSiBaseUnit(), 12), - () => Assert.Equal(6.35029318, Mass.FromStones(1).AsSiBaseUnit(), 10), - () => Assert.Equal(907.18474, Mass.FromUSShortTons(1).AsSiBaseUnit(), 8), - () => Assert.Equal(1016.0469088, Mass.FromImperialLongTons(1).AsSiBaseUnit(), 8), - () => Assert.Equal(0.44704, Speed.FromMilesPerHour(1).AsSiBaseUnit(), 12), - () => Assert.Equal(0.3048, Speed.FromFeetPerSecond(1).AsSiBaseUnit(), 12), - () => Assert.Equal(4.4482216152605, Force.FromPoundForces(1).AsSiBaseUnit(), 12), - () => Assert.Equal(4.4482216152605 / (0.0254 * 0.0254), Pressure.FromPsi(1).AsSiBaseUnit(), 9), - () => Assert.Equal(1, Stress.FromPsi(1).AsPsi(), 12), - () => Assert.Equal(1, YoungsModulus.FromPsi(1).AsPsi(), 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Mass.FromOunces(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.028349523125, 12)); + await Assert.That(Math.Round(Mass.FromPounds(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.45359237, 12)); + await Assert.That(Math.Round(Mass.FromStones(1).AsSiBaseUnit(), 10)).IsEqualTo(Math.Round(6.35029318, 10)); + await Assert.That(Math.Round(Mass.FromUSShortTons(1).AsSiBaseUnit(), 8)).IsEqualTo(Math.Round(907.18474, 8)); + await Assert.That(Math.Round(Mass.FromImperialLongTons(1).AsSiBaseUnit(), 8)).IsEqualTo(Math.Round(1016.0469088, 8)); + await Assert.That(Math.Round(Speed.FromMilesPerHour(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.44704, 12)); + await Assert.That(Math.Round(Speed.FromFeetPerSecond(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(0.3048, 12)); + await Assert.That(Math.Round(Force.FromPoundForces(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(4.4482216152605, 12)); + await Assert.That(Math.Round(Pressure.FromPsi(1).AsSiBaseUnit(), 9)).IsEqualTo(Math.Round(4.4482216152605 / (0.0254 * 0.0254), 9)); + await Assert.That(Math.Round(Stress.FromPsi(1).AsPsi(), 12)).IsEqualTo(Math.Round(1d, 12)); + await Assert.That(Math.Round(YoungsModulus.FromPsi(1).AsPsi(), 12)).IsEqualTo(Math.Round(1d, 12)); + } } - [Fact] - public void EnergyAndPowerUseExplicitBritishThermalUnitDefinition() + [Test] + public async Task EnergyAndPowerUseExplicitBritishThermalUnitDefinition() { - Assert.Multiple( - () => Assert.Equal(1.3558179483314004, Energy.FromFootPoundForces(1).AsSiBaseUnit(), 12), - () => Assert.Equal(1055.05585262, Energy.FromBritishThermalUnitsIT(1).AsSiBaseUnit(), 9), - () => Assert.Equal(745.69987158227022, Power.FromMechanicalHorsepower(1).AsSiBaseUnit(), 9), - () => Assert.Equal(1055.05585262 / 3600, Power.FromBritishThermalUnitsITPerHour(1).AsSiBaseUnit(), 12), - () => Assert.Equal(1, Energy.FromSiBaseUnit(1055.05585262).AsBritishThermalUnitsIT(), 12), - () => Assert.Equal(1, Power.FromSiBaseUnit(1055.05585262 / 3600).AsBritishThermalUnitsITPerHour(), 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Energy.FromFootPoundForces(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(1.3558179483314004, 12)); + await Assert.That(Math.Round(Energy.FromBritishThermalUnitsIT(1).AsSiBaseUnit(), 9)).IsEqualTo(Math.Round(1055.05585262, 9)); + await Assert.That(Math.Round(Power.FromMechanicalHorsepower(1).AsSiBaseUnit(), 9)).IsEqualTo(Math.Round(745.69987158227022, 9)); + await Assert.That(Math.Round(Power.FromBritishThermalUnitsITPerHour(1).AsSiBaseUnit(), 12)).IsEqualTo(Math.Round(1055.05585262 / 3600, 12)); + await Assert.That(Math.Round(Energy.FromSiBaseUnit(1055.05585262).AsBritishThermalUnitsIT(), 12)).IsEqualTo(Math.Round(1d, 12)); + await Assert.That(Math.Round(Power.FromSiBaseUnit(1055.05585262 / 3600).AsBritishThermalUnitsITPerHour(), 12)).IsEqualTo(Math.Round(1d, 12)); + } } - [Fact] - public void RankineUsesFiveNinthsKelvinPerDegree() + [Test] + public async Task RankineUsesFiveNinthsKelvinPerDegree() { - Assert.Multiple( - () => Assert.Equal(273.15, Temperature.FromRankine(491.67).AsKelvin(), 10), - () => Assert.Equal(491.67, Temperature.FromKelvin(273.15).AsRankine(), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Temperature.FromRankine(491.67).AsKelvin(), 10)).IsEqualTo(Math.Round(273.15, 10)); + await Assert.That(Math.Round(Temperature.FromKelvin(273.15).AsRankine(), 10)).IsEqualTo(Math.Round(491.67, 10)); + } } - [Fact] - public void FahrenheitConvertsToAndFromAbsoluteKelvin() + [Test] + public async Task FahrenheitConvertsToAndFromAbsoluteKelvin() { - Assert.Multiple( - () => Assert.Equal(273.15, Temperature.FromFahrenheit(32).AsKelvin(), 10), - () => Assert.Equal(32, Temperature.FromKelvin(273.15).AsFahrenheit(), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Temperature.FromFahrenheit(32).AsKelvin(), 10)).IsEqualTo(Math.Round(273.15, 10)); + await Assert.That(Math.Round(Temperature.FromKelvin(273.15).AsFahrenheit(), 10)).IsEqualTo(Math.Round(32d, 10)); + } } - [Fact] - public void ProviderDoesNotGenerateSiPrefixHelpers() + [Test] + public async Task ProviderDoesNotGenerateSiPrefixHelpers() { string[] names = Assembly.Load("DimensionalQuantities.Extensions.Imperial").GetExportedTypes() .Where(type => type.Namespace == "DimensionalQuantities.Extensions.Imperial") .SelectMany(type => type.GetMethods()).Select(method => method.Name).ToArray(); - Assert.Multiple( - () => Assert.DoesNotContain("FromKiloFeet", names), - () => Assert.DoesNotContain("AsMilliPounds", names), - () => Assert.DoesNotContain("FromPrefixedUnits", names), - () => Assert.DoesNotContain("AsPrefixedUnits", names)); + using (Assert.Multiple()) + { + await Assert.That(names.Contains("FromKiloFeet")).IsFalse(); + await Assert.That(names.Contains("AsMilliPounds")).IsFalse(); + await Assert.That(names.Contains("FromPrefixedUnits")).IsFalse(); + await Assert.That(names.Contains("AsPrefixedUnits")).IsFalse(); + } } } diff --git a/src/DimensionalQuantities.Extensions.Metric.Tests/DimensionalQuantities.Extensions.Metric.Tests.csproj b/src/DimensionalQuantities.Extensions.Metric.Tests/DimensionalQuantities.Extensions.Metric.Tests.csproj index 7e6f186..8ce48e0 100644 --- a/src/DimensionalQuantities.Extensions.Metric.Tests/DimensionalQuantities.Extensions.Metric.Tests.csproj +++ b/src/DimensionalQuantities.Extensions.Metric.Tests/DimensionalQuantities.Extensions.Metric.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Extensions.Metric.Tests/MetricConversionsTests.cs b/src/DimensionalQuantities.Extensions.Metric.Tests/MetricConversionsTests.cs index bb7359e..1badbb0 100644 --- a/src/DimensionalQuantities.Extensions.Metric.Tests/MetricConversionsTests.cs +++ b/src/DimensionalQuantities.Extensions.Metric.Tests/MetricConversionsTests.cs @@ -1,13 +1,12 @@ -using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Extensions.Metric; -using Xunit; namespace DimensionalQuantities.Extensions.Metric.Tests; public sealed class MetricConversionsTests { - [Fact] - public void CatalogueFactoriesConvertToExpectedSiValues() + [Test] + public async Task CatalogueFactoriesConvertToExpectedSiValues() { double[] result = [ @@ -38,31 +37,35 @@ public void CatalogueFactoriesConvertToExpectedSiValues() ]; double[] expected = [1d, 1d, 1d, 1d, 0.001d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void CelsiusConvertsToAndFromAbsoluteKelvin() + [Test] + public async Task CelsiusConvertsToAndFromAbsoluteKelvin() { - Assert.Multiple( - () => Assert.Equal(273.15, Temperature.FromCelsius(0).AsKelvin(), 10), - () => Assert.Equal(0, Temperature.FromKelvin(273.15).AsCelsius(), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Temperature.FromCelsius(0).AsKelvin(), 10)).IsEqualTo(Math.Round(273.15, 10)); + await Assert.That(Math.Round(Temperature.FromKelvin(273.15).AsCelsius(), 10)).IsEqualTo(Math.Round(0d, 10)); + } } - [Theory] - [InlineData(0d, 0d)] - [InlineData(60d, 2d)] - [InlineData(-120d, -4d)] - public void RpmConvertsToAndFromRadiansPerSecond(double rpm, double multiplesOfPi) + [Test] + [Arguments(0d, 0d)] + [Arguments(60d, 2d)] + [Arguments(-120d, -4d)] + public async Task RpmConvertsToAndFromRadiansPerSecond(double rpm, double multiplesOfPi) { double radiansPerSecond = multiplesOfPi * Math.PI; - Assert.Multiple( - () => Assert.Equal(radiansPerSecond, AngularVelocity.FromRpm(rpm).AsRadiansPerSecond(), 10), - () => Assert.Equal(rpm, AngularVelocity.FromRadiansPerSecond(radiansPerSecond).ToRpm(), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(AngularVelocity.FromRpm(rpm).AsRadiansPerSecond(), 10)).IsEqualTo(Math.Round(radiansPerSecond, 10)); + await Assert.That(Math.Round(AngularVelocity.FromRadiansPerSecond(radiansPerSecond).ToRpm(), 10)).IsEqualTo(Math.Round(rpm, 10)); + } } - [Fact] - public void CatalogueAccessorsConvertFromKnownSiValues() + [Test] + public async Task CatalogueAccessorsConvertFromKnownSiValues() { double[] result = [ @@ -93,11 +96,11 @@ public void CatalogueAccessorsConvertFromKnownSiValues() ]; double[] expected = [1d, 1d, 1d, 1d, 1000d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d, 1d]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void AliasesShareNamedConversionsWithoutDuplicateHelpers() + [Test] + public async Task AliasesShareNamedConversionsWithoutDuplicateHelpers() { Pressure pressure = Pressure.FromPascals(1); Stress stress = Stress.FromPascals(1); @@ -115,41 +118,47 @@ public void AliasesShareNamedConversionsWithoutDuplicateHelpers() MagneticFieldStrength.FromAmpsPerMetre(1).AsAmpsPerMetre(), CoerciveFieldStrength.FromAmpsPerMetre(1).AsAmpsPerMetre() ]; - Assert.Equal(Enumerable.Repeat(1d, result.Length), result); + await Assert.That(result).IsEquivalentTo(Enumerable.Repeat(1d, result.Length), TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void NamedConversionsApplyMetricScale() + [Test] + public async Task NamedConversionsApplyMetricScale() { - Assert.Multiple( - () => Assert.Equal(0.0025, Voltage.FromSiBaseUnit(2.5).AsKiloVolts()), - () => Assert.Equal(1000, Density.FromGramsPerCubicCentiMetre(1).AsSiBaseUnit())); + using (Assert.Multiple()) + { + await Assert.That(Voltage.FromSiBaseUnit(2.5).AsKiloVolts()).IsEqualTo(0.0025); + await Assert.That(Density.FromGramsPerCubicCentiMetre(1).AsSiBaseUnit()).IsEqualTo(1000); + } } - [Fact] - public void GenericPrefixConversionsApplyMetricScale() + [Test] + public async Task GenericPrefixConversionsApplyMetricScale() { - Assert.Multiple( - () => Assert.Equal(0.002, Voltage.FromPrefixedUnits(2, -3).AsSiBaseUnit()), - () => Assert.Equal(1000000, CurrentDensity.FromPrefixedUnits(1, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit()), - () => Assert.Equal(1000, SpecificPower.FromPrefixedUnits(1, wattPrefixExponent: 3, gramPrefixExponent: 3).AsSiBaseUnit()), - () => Assert.Equal(1000, TemperatureCoefficient.FromPrefixedUnits(1, kelvinPrefixExponent: -3).AsSiBaseUnit()), - () => Assert.Equal(2, Torque.FromPrefixedUnits(2).AsSiBaseUnit()), - () => Assert.Equal(2, Voltage.FromSiBaseUnit(0.002).AsPrefixedUnits(-3)), - () => Assert.Equal(1, CurrentDensity.FromSiBaseUnit(1000000).AsPrefixedUnits(ampPrefixExponent: 0, metrePrefixExponent: -3)), - () => Assert.Equal(2, Torque.FromSiBaseUnit(2).AsPrefixedUnits())); + using (Assert.Multiple()) + { + await Assert.That(Voltage.FromPrefixedUnits(2, -3).AsSiBaseUnit()).IsEqualTo(0.002); + await Assert.That(CurrentDensity.FromPrefixedUnits(1, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit()).IsEqualTo(1000000); + await Assert.That(SpecificPower.FromPrefixedUnits(1, wattPrefixExponent: 3, gramPrefixExponent: 3).AsSiBaseUnit()).IsEqualTo(1000); + await Assert.That(TemperatureCoefficient.FromPrefixedUnits(1, kelvinPrefixExponent: -3).AsSiBaseUnit()).IsEqualTo(1000); + await Assert.That(Torque.FromPrefixedUnits(2).AsSiBaseUnit()).IsEqualTo(2); + await Assert.That(Voltage.FromSiBaseUnit(0.002).AsPrefixedUnits(-3)).IsEqualTo(2); + await Assert.That(CurrentDensity.FromSiBaseUnit(1000000).AsPrefixedUnits(ampPrefixExponent: 0, metrePrefixExponent: -3)).IsEqualTo(1); + await Assert.That(Torque.FromSiBaseUnit(2).AsPrefixedUnits()).IsEqualTo(2); + } } - [Fact] - public void PrefixesOnlyApplyToSupportedFactorPlacements() + [Test] + public async Task PrefixesOnlyApplyToSupportedFactorPlacements() { string[] names = Assembly.Load("DimensionalQuantities.Extensions.Metric").GetExportedTypes() .Where(type => type.Namespace == "DimensionalQuantities.Extensions.Metric") .SelectMany(type => type.GetMethods()).Select(method => method.Name).ToArray(); - Assert.Multiple( - () => Assert.DoesNotContain("FromInverseMilliKelvin", names), - () => Assert.DoesNotContain("AsInverseMilliKelvin", names), - () => Assert.DoesNotContain("FromMilliAmpsPerSquareMilliMetre", names), - () => Assert.DoesNotContain("FromKiloGramsPerCubicCentiMetre", names)); + using (Assert.Multiple()) + { + await Assert.That(names.Contains("FromInverseMilliKelvin")).IsFalse(); + await Assert.That(names.Contains("AsInverseMilliKelvin")).IsFalse(); + await Assert.That(names.Contains("FromMilliAmpsPerSquareMilliMetre")).IsFalse(); + await Assert.That(names.Contains("FromKiloGramsPerCubicCentiMetre")).IsFalse(); + } } } diff --git a/src/DimensionalQuantities.Extensions.Nautical.Tests/DimensionalQuantities.Extensions.Nautical.Tests.csproj b/src/DimensionalQuantities.Extensions.Nautical.Tests/DimensionalQuantities.Extensions.Nautical.Tests.csproj index de78b89..829dec9 100644 --- a/src/DimensionalQuantities.Extensions.Nautical.Tests/DimensionalQuantities.Extensions.Nautical.Tests.csproj +++ b/src/DimensionalQuantities.Extensions.Nautical.Tests/DimensionalQuantities.Extensions.Nautical.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Extensions.Nautical.Tests/NauticalConversionsTests.cs b/src/DimensionalQuantities.Extensions.Nautical.Tests/NauticalConversionsTests.cs index 4067292..d1fd134 100644 --- a/src/DimensionalQuantities.Extensions.Nautical.Tests/NauticalConversionsTests.cs +++ b/src/DimensionalQuantities.Extensions.Nautical.Tests/NauticalConversionsTests.cs @@ -1,13 +1,12 @@ -using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Extensions.Nautical; -using Xunit; namespace DimensionalQuantities.Extensions.Nautical.Tests; public sealed class NauticalConversionsTests { - [Fact] - public void NauticalUnitsConvertToExpectedSiValues() + [Test] + public async Task NauticalUnitsConvertToExpectedSiValues() { double[] result = [ @@ -18,11 +17,11 @@ public void NauticalUnitsConvertToExpectedSiValues() ]; double[] expected = [1852d, 1.8288d, 3_429_904d, 1852d / 3600d]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void NauticalUnitsConvertBackFromSiValues() + [Test] + public async Task NauticalUnitsConvertBackFromSiValues() { double[] result = [ @@ -32,20 +31,22 @@ public void NauticalUnitsConvertBackFromSiValues() Speed.FromSiBaseUnit(1852d / 3600d).AsKnots(), ]; - Assert.Equal([1d, 1d, 1d, 1d], result); + await Assert.That(result).IsEquivalentTo(new double[] { 1d, 1d, 1d, 1d }, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void NauticalUnitsDoNotGenerateSiPrefixedConversions() + [Test] + public async Task NauticalUnitsDoNotGenerateSiPrefixedConversions() { string[] names = Assembly.Load("DimensionalQuantities.Extensions.Nautical").GetExportedTypes() .Where(type => type.Namespace == "DimensionalQuantities.Extensions.Nautical") .SelectMany(type => type.GetMethods()).Select(method => method.Name).ToArray(); - Assert.Multiple( - () => Assert.DoesNotContain("FromKiloNauticalMiles", names), - () => Assert.DoesNotContain("FromMilliKnots", names), - () => Assert.DoesNotContain("FromPrefixedUnits", names), - () => Assert.DoesNotContain("AsPrefixedUnits", names)); + using (Assert.Multiple()) + { + await Assert.That(names.Contains("FromKiloNauticalMiles")).IsFalse(); + await Assert.That(names.Contains("FromMilliKnots")).IsFalse(); + await Assert.That(names.Contains("FromPrefixedUnits")).IsFalse(); + await Assert.That(names.Contains("AsPrefixedUnits")).IsFalse(); + } } } diff --git a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj index c73a812..68f6567 100644 --- a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj +++ b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + 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/PackageDeliveryFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs index 1a04198..a129f63 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageDeliveryFixture.cs @@ -1,23 +1,22 @@ using Microsoft.Build.Locator; +using TUnit.Core.Interfaces; namespace DimensionalQuantities.IntegrationTests.Packaging; -public sealed class PackageDeliveryFixture : IDisposable +public sealed class PackageDeliveryFixture : IAsyncInitializer, IDisposable { - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-delivery-").FullName; + private string _scratch = null!; private readonly Dictionary _packages = new(); - static PackageDeliveryFixture() + public Task InitializeAsync() { // MSBuild must be located before any Microsoft.Build type is loaded. if (!MSBuildLocator.IsRegistered) { MSBuildLocator.RegisterDefaults(); } - } - public PackageDeliveryFixture() - { + _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-delivery-").FullName; string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); foreach (string projectName in new[] { @@ -30,6 +29,8 @@ public PackageDeliveryFixture() { _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); } + + return Task.CompletedTask; } internal FileInfo GetPackage(string projectName) => _packages[projectName]; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs index 631152d..a766c65 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityFixture.cs @@ -1,23 +1,22 @@ using Microsoft.Build.Locator; +using TUnit.Core.Interfaces; namespace DimensionalQuantities.IntegrationTests.Packaging; -public sealed class PackageInteroperabilityFixture : IDisposable +public sealed class PackageInteroperabilityFixture : IAsyncInitializer, IDisposable { - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-interoperability-").FullName; + private string _scratch = null!; private readonly Dictionary _packages = new(); - static PackageInteroperabilityFixture() + public Task InitializeAsync() { // MSBuild must be located before any Microsoft.Build type is loaded. if (!MSBuildLocator.IsRegistered) { MSBuildLocator.RegisterDefaults(); } - } - public PackageInteroperabilityFixture() - { + _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-interoperability-").FullName; string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); foreach (string projectName in new[] { @@ -30,6 +29,8 @@ public PackageInteroperabilityFixture() { _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); } + + return Task.CompletedTask; } internal FileInfo GetPackage(string projectName) => _packages[projectName]; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs index d500c8b..dbffa9d 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageInteroperabilityTests.cs @@ -1,11 +1,11 @@ using System.Reflection; using Microsoft.Build.Utilities.ProjectCreation; -using Xunit; namespace DimensionalQuantities.IntegrationTests.Packaging; -[Collection("MSBuild")] -public sealed class PackageInteroperabilityTests : IClassFixture, IDisposable +[NotInParallel] +[ClassDataSource(Shared = SharedType.PerClass)] +public sealed class PackageInteroperabilityTests : IDisposable { private readonly PackageInteroperabilityFixture _fixture; private readonly PackageConsumerWorkspace _workspace; @@ -16,8 +16,8 @@ public PackageInteroperabilityTests(PackageInteroperabilityFixture fixture) _workspace = fixture.CreateWorkspace(); } - [Fact] - public void AffineTemperatureConversionsAndDeltasWorkAcrossPackages() + [Test] + public async Task AffineTemperatureConversionsAndDeltasWorkAcrossPackages() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -68,16 +68,18 @@ public static double[] AbsoluteRoundTrips() => 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)); + using (Assert.Multiple()) + { + await Assert.That(difference).IsEquivalentTo((double[])[10d, 18d, 10d, 18d], TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That(Math.Round(absolute[0], 12)).IsEqualTo(Math.Round(20d, 12)); + await Assert.That(Math.Round(absolute[1], 12)).IsEqualTo(Math.Round(68d, 12)); + await Assert.That(Math.Round(absolute[2], 12)).IsEqualTo(Math.Round(20d, 12)); + await Assert.That(Math.Round(absolute[3], 12)).IsEqualTo(Math.Round(68d, 12)); + } } - [Fact] - public void IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() + [Test] + public async Task IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); Package core = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -152,22 +154,24 @@ public static class Application 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"))); + using (Assert.Multiple()) + { + await Assert.That(independentlyProducedType).IsEqualTo(producedType); + await Assert.That(acceptedType).IsEqualTo(producedType); + await Assert.That(intermediateFromB).IsEqualTo(intermediateFromA); + await Assert.That(intermediateAccepted).IsEqualTo(intermediateFromA); + await Assert.That(InvokeDouble(application, "Direct")).IsEqualTo(6); + await Assert.That(InvokeDouble(application, "Collection")).IsEqualTo(12); + await Assert.That(InvokeDouble(application, "Contained")).IsEqualTo(6); + await Assert.That(Math.Round(InvokeDouble(application, "Prefixed"), 12)).IsEqualTo(Math.Round(0.006, 12)); + await Assert.That(InvokeDouble(application, "Product")).IsEqualTo(24); + await Assert.That(InvokeDouble(application, "Intermediate")).IsEqualTo(6); + await Assert.That(InvokeDouble(application, "IntermediateProduct")).IsEqualTo(24); + } } - [Fact] - public void AllUnitPackagesWorkInALibraryAndItsPackagedConsumer() + [Test] + public async Task AllUnitPackagesWorkInALibraryAndItsPackagedConsumer() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -233,14 +237,16 @@ public static class Application 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])); + using (Assert.Multiple()) + { + await Assert.That(local).IsEquivalentTo((double[])[0.00000001d, 6d, 1d, 10_000d], TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That(converted.Length).IsEqualTo(5); + await Assert.That(converted[0]).IsEqualTo(1d); + await Assert.That(Math.Round(converted[1], 12)).IsEqualTo(Math.Round(1d, 12)); + await Assert.That(converted[2]).IsEqualTo(6d); + await Assert.That(converted[3]).IsEqualTo(1d); + await Assert.That(converted[4]).IsEqualTo(1d); + } } private static double InvokeDouble(Type type, string method, params object[] arguments) diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs index 3609be8..2d47745 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs @@ -1,11 +1,11 @@ using System.Reflection; using Microsoft.Build.Utilities.ProjectCreation; -using Xunit; namespace DimensionalQuantities.IntegrationTests.Packaging; -[Collection("MSBuild")] -public sealed class PackagedGeneratorTests : IClassFixture, IDisposable +[NotInParallel] +[ClassDataSource(Shared = SharedType.PerClass)] +public sealed class PackagedGeneratorTests : IDisposable { private readonly PackageDeliveryFixture _fixture; private readonly PackageConsumerWorkspace _workspace; @@ -16,8 +16,8 @@ public PackagedGeneratorTests(PackageDeliveryFixture fixture) _workspace = fixture.CreateWorkspace(); } - [Fact] - public void CorePackageProvidesBaseUnitsCatalogueAliasesAndArithmetic() + [Test] + public async Task CorePackageProvidesBaseUnitsCatalogueAliasesAndArithmetic() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); Package core = PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -35,15 +35,17 @@ public static class Consumer using PackageAssemblyContext context = new(_workspace.OutputDirectory("CoreConsumer")); Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("CoreConsumer"), "CoreConsumer.dll")) .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(2.5, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(3, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(6, InvokeDouble(type, "CalculateArea")), - () => Assert.Equal(6, InvokeDouble(type, "NamedArea"))); + using (Assert.Multiple()) + { + await Assert.That(InvokeDouble(type, "ConvertLength")).IsEqualTo(2.5); + await Assert.That(InvokeDouble(type, "ConvertCurrent")).IsEqualTo(3); + await Assert.That(InvokeDouble(type, "CalculateArea")).IsEqualTo(6); + await Assert.That(InvokeDouble(type, "NamedArea")).IsEqualTo(6); + } } - [Fact] - public void MetricPackageProvidesNamedConversionsAndArithmeticThroughCoreDependency() + [Test] + public async Task MetricPackageProvidesNamedConversionsAndArithmeticThroughCoreDependency() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -66,13 +68,15 @@ public static double MultiplyVoltageCurrent(double volts, double amps) using PackageAssemblyContext context = new(_workspace.OutputDirectory("MetricConsumer")); Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("MetricConsumer"), "MetricConsumer.dll")) .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(12.5, InvokeDouble(type, "ConvertVoltage", 12.5)), - () => Assert.Equal(25, InvokeDouble(type, "MultiplyVoltageCurrent", 12.5, 2.0))); + using (Assert.Multiple()) + { + await Assert.That(InvokeDouble(type, "ConvertVoltage", 12.5)).IsEqualTo(12.5); + await Assert.That(InvokeDouble(type, "MultiplyVoltageCurrent", 12.5, 2.0)).IsEqualTo(25); + } } - [Fact] - public void ImperialPackageProvidesConversionsThroughCoreDependency() + [Test] + public async Task ImperialPackageProvidesConversionsThroughCoreDependency() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -91,13 +95,15 @@ public static class Consumer using PackageAssemblyContext context = new(_workspace.OutputDirectory("ImperialConsumer")); Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("ImperialConsumer"), "ImperialConsumer.dll")) .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1.8288, InvokeDouble(type, "ConvertLength"), 12), - () => Assert.Equal(273.15, InvokeDouble(type, "ConvertTemperature"), 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(InvokeDouble(type, "ConvertLength"), 12)).IsEqualTo(Math.Round(1.8288, 12)); + await Assert.That(Math.Round(InvokeDouble(type, "ConvertTemperature"), 12)).IsEqualTo(Math.Round(273.15, 12)); + } } - [Fact] - public void NauticalPackageProvidesConversionsThroughCoreDependency() + [Test] + public async Task NauticalPackageProvidesConversionsThroughCoreDependency() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -116,13 +122,15 @@ public static class Consumer using PackageAssemblyContext context = new(_workspace.OutputDirectory("NauticalConsumer")); Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("NauticalConsumer"), "NauticalConsumer.dll")) .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1852, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(1852d / 3600d, InvokeDouble(type, "ConvertSpeed"))); + using (Assert.Multiple()) + { + await Assert.That(InvokeDouble(type, "ConvertLength")).IsEqualTo(1852); + await Assert.That(InvokeDouble(type, "ConvertSpeed")).IsEqualTo(1852d / 3600d); + } } - [Fact] - public void CgsEmagPackageProvidesConversionsThroughCoreDependency() + [Test] + public async Task CgsEmagPackageProvidesConversionsThroughCoreDependency() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -142,14 +150,16 @@ public static class Consumer using PackageAssemblyContext context = new(_workspace.OutputDirectory("CgsEmagConsumer")); Type type = context.LoadFromAssemblyPath(Path.Combine(_workspace.OutputDirectory("CgsEmagConsumer"), "CgsEmagConsumer.dll")) .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1, InvokeDouble(type, "ConvertFluxDensity")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCharge"))); + using (Assert.Multiple()) + { + await Assert.That(InvokeDouble(type, "ConvertFluxDensity")).IsEqualTo(1); + await Assert.That(InvokeDouble(type, "ConvertCurrent")).IsEqualTo(10); + await Assert.That(InvokeDouble(type, "ConvertCharge")).IsEqualTo(10); + } } - [Fact] - public void MetricNamedConversionsRequireNamespaceImport() + [Test] + public async Task MetricNamedConversionsRequireNamespaceImport() { using PackageRepository repository = PackageRepository.Create(_workspace.Directory, new Uri("https://api.nuget.org/v3/index.json")); PackageTestSupport.AddPackedPackage(repository, _fixture.GetPackage("DimensionalQuantities")); @@ -164,11 +174,13 @@ public static class Consumer 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")); + using (Assert.Multiple()) + { + await Assert.That(built).IsFalse().Because(log); + await Assert.That(output.ErrorEvents.Any(error => error.Code == "CS0117" && error.Message!.Contains("FromVolts", StringComparison.Ordinal))).IsTrue(); + await Assert.That(output.ErrorEvents.Any(error => error.Code is "CS8032" or "CS8785" or "AD0001")).IsFalse(); + await Assert.That(output.WarningEvents.Any(warning => warning.Code is "CS8032" or "CS8785" or "AD0001")).IsFalse(); + } } } diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs index 2f38f6a..08513a5 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageFixture.cs @@ -1,23 +1,22 @@ using Microsoft.Build.Locator; +using TUnit.Core.Interfaces; namespace DimensionalQuantities.IntegrationTests.Packaging; -public sealed class SymbolPackageFixture : IDisposable +public sealed class SymbolPackageFixture : IAsyncInitializer, IDisposable { - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-symbols-").FullName; + private string _scratch = null!; private readonly Dictionary _packages = new(); - static SymbolPackageFixture() + public Task InitializeAsync() { // MSBuild must be located before any Microsoft.Build type is loaded. if (!MSBuildLocator.IsRegistered) { MSBuildLocator.RegisterDefaults(); } - } - public SymbolPackageFixture() - { + _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-symbols-").FullName; string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); foreach (string projectName in new[] { @@ -30,6 +29,8 @@ public SymbolPackageFixture() { _packages.Add(projectName, PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch)); } + + return Task.CompletedTask; } internal FileInfo GetPackage(string projectName) => _packages[projectName]; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs index de28c70..450e56e 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs @@ -6,12 +6,12 @@ using System.Reflection.PortableExecutable; using System.Text; using System.Text.Json; -using Xunit; namespace DimensionalQuantities.IntegrationTests.Packaging; -[Collection("MSBuild")] -public sealed class SymbolPackageTests : IClassFixture +[NotInParallel] +[ClassDataSource(Shared = SharedType.PerClass)] +public sealed class SymbolPackageTests { private static readonly Guid _sourceLinkKind = new("CC110556-A091-4D38-9FEC-25AB9A351A6A"); private static readonly Guid _embeddedSourceKind = new("0E8A571B-6926-466E-B4AD-8AB04611F5FE"); @@ -22,8 +22,8 @@ public SymbolPackageTests(SymbolPackageFixture fixture) _fixture = fixture; } - [Fact] - public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() + [Test] + public async Task CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() { (FileInfo package, FileInfo symbols) = GetArchives("DimensionalQuantities"); using ZipArchive binaries = ZipFile.OpenRead(package.FullName); @@ -38,19 +38,21 @@ public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() }) { 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)); + using (Assert.Multiple()) + { + await Assert.That(details.PdbGuid).IsEqualTo(details.AssemblyGuid); + await Assert.That(details.PdbStamp).IsEqualTo(details.AssemblyStamp); + await Assert.That(details.SourceUrls).Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*"); + } } } - [Theory] - [InlineData("Metric")] - [InlineData("Imperial")] - [InlineData("Nautical")] - [InlineData("CgsEmag")] - public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string extension) + [Test] + [Arguments("Metric")] + [Arguments("Imperial")] + [Arguments("Nautical")] + [Arguments("CgsEmag")] + public async Task ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string extension) { string projectName = "DimensionalQuantities.Extensions." + extension; (FileInfo package, FileInfo symbols) = GetArchives(projectName); @@ -63,11 +65,13 @@ public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string 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)); + using (Assert.Multiple()) + { + await Assert.That(details.PdbGuid).IsEqualTo(details.AssemblyGuid); + await Assert.That(details.PdbStamp).IsEqualTo(details.AssemblyStamp); + await Assert.That(details.SourceUrls).Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*"); + await Assert.That(details.EmbeddedGeneratedSource).IsEquivalentTo(generatedSource, TUnit.Assertions.Enums.CollectionOrdering.Matching); + } } private (FileInfo Package, FileInfo Symbols) GetArchives(string projectName) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs index ff648fe..4d6568d 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs @@ -3,21 +3,21 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Testing; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; +[NotInParallel(nameof(DimensionMismatchAnalyzerTests))] public sealed class DimensionMismatchAnalyzerTests { - [Theory] - [InlineData("+")] - [InlineData("-")] - [InlineData("<")] - [InlineData(">")] - [InlineData("<=")] - [InlineData(">=")] - [InlineData("==")] - [InlineData("!=")] + [Test] + [Arguments("+")] + [Arguments("-")] + [Arguments("<")] + [Arguments(">")] + [Arguments("<=")] + [Arguments(">=")] + [Arguments("==")] + [Arguments("!=")] public async Task IncompatibleOperandsExplainTheirDimensions(string operation) { QuantityAnalyzerTest test = new() @@ -33,32 +33,32 @@ public class Consumer DiagnosticResult.CompilerError("CS0019").WithLocation(0), new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Current") ]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public void Calculate(Length length) { Current current = {|#0:length|}; } """, "CS0029")] - [InlineData(""" + [Arguments(""" public void Calculate(Length length, Current current) { current = {|#0:length|}; } """, "CS0029")] - [InlineData(""" + [Arguments(""" public Current Calculate(Length length) => {|#0:length|}; """, "CS0029")] - [InlineData(""" + [Arguments(""" public Current Calculate(Length length) { return {|#0:length|}; } """, "CS0029")] - [InlineData(""" + [Arguments(""" public void Calculate(Length length) { Accept({|#0:length|}); @@ -67,7 +67,7 @@ private void Accept(Current current) { } """, "CS1503")] - [InlineData(""" + [Arguments(""" public void Calculate(Length length) { Accept(current: {|#0:length|}); @@ -76,22 +76,22 @@ private void Accept(Current current) { } """, "CS1503")] - [InlineData(""" + [Arguments(""" public object Calculate(Length length, Current current) => Current.Min(current, {|#0:length|}); """, "CS1503")] - [InlineData(""" + [Arguments(""" public object Calculate(Length length, Current current) => Current.Clamp(current, current, {|#0:length|}); """, "CS1503")] - [InlineData(""" + [Arguments(""" public Current Value { get; } = {|#0:Length.FromMetres(1)|}; """, "CS0029")] - [InlineData(""" + [Arguments(""" public Current Value => {|#0:Length.FromMetres(1)|}; """, "CS0029")] - [InlineData(""" + [Arguments(""" public Current this[int index] => {|#0:Length.FromMetres(1)|}; """, "CS0029")] - [InlineData(""" + [Arguments(""" public Consumer(Current current) { } @@ -110,35 +110,35 @@ public class Consumer DiagnosticResult.CompilerError(compilerError).WithLocation(0), new DiagnosticResult("DQ0002", DiagnosticSeverity.Error).WithLocation(0).WithArguments("Current", "Length") ]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public object Calculate(Length length, Length other) => length + other; """)] - [InlineData(""" + [Arguments(""" public object Calculate(Length length, Current current) => length * current; """)] - [InlineData(""" + [Arguments(""" public object Calculate(Length length, Current current) => length / current; """)] - [InlineData(""" + [Arguments(""" public object Calculate(Energy energy, Torque torque) => energy + torque; """)] - [InlineData(""" + [Arguments(""" public Current? Calculate() => null; """)] - [InlineData(""" + [Arguments(""" public Current Calculate() => default; """)] - [InlineData(""" + [Arguments(""" public object Calculate(Length length) => length; """)] - [InlineData(""" + [Arguments(""" public object Calculate(Length length) => length + {|CS0103:missing|}; """)] - [InlineData(""" + [Arguments(""" public void Calculate(Length length) { Accept(length); @@ -161,12 +161,12 @@ public class Consumer } """ }; - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData("+=")] - [InlineData("-=")] + [Test] + [Arguments("+=")] + [Arguments("-=")] public async Task CompoundAssignmentsExplainIncompatibleDimensions(string operation) { QuantityAnalyzerTest test = new() @@ -185,10 +185,10 @@ public void Calculate(Length length, Current current) DiagnosticResult.CompilerError("CS0019").WithLocation(0), new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Current") ]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task NullableOperandsStillExplainDimensions() { QuantityAnalyzerTest test = new() @@ -204,10 +204,10 @@ public class Consumer DiagnosticResult.CompilerError("CS0019").WithLocation(0), new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments("+", "Length", "Current") ]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ExistingUserOperatorIsRespected() { QuantityAnalyzerTest test = new() @@ -226,10 +226,10 @@ public class Consumer } """ }; - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task UnrelatedCompilationWithoutLibraryDoesNotCrash() { CSharpAnalyzerTest test = new() @@ -237,6 +237,6 @@ public async Task UnrelatedCompilationWithoutLibraryDoesNotCrash() ReferenceAssemblies = ReferenceAssemblies.Net.Net100 }; test.TestState.Sources.Add(("Consumer.cs", "")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs index ac73a92..a7106f4 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs @@ -2,15 +2,15 @@ using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; +[NotInParallel(nameof(QuantityEncodingAnalyzerTests))] public sealed class QuantityEncodingAnalyzerTests { private const string LengthType = "Quantity>"; - [Fact] + [Test] public async Task RawQuantitySuggestsReadableAlias() { QuantityAnalyzerTest test = new() @@ -24,12 +24,12 @@ public class Consumer """ }; test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0003", DiagnosticSeverity.Info).WithLocation(0).WithArguments("Length")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] + [Test] + [Arguments("global::DimensionalQuantities.TypeSystem.Fraction")] + [Arguments("global::DimensionalQuantities.TypeSystem.Fraction")] public async Task NonCanonicalEncodingExplainsDistinctTypeIdentity(string exponent) { string type = $"Quantity", false)] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] + [Test] + [Arguments("Quantity", false)] + [Arguments("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] + [Arguments("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>", true)] public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string type, bool invalidConstraint) { QuantityAnalyzerTest test = new(generate: false) @@ -70,12 +70,12 @@ public class Consumer test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0315").WithLocation(1)); } - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData("Quantity<{|CS0246:Missing|}>")] - [InlineData("Power<{|CS0246:Missing|}>")] + [Test] + [Arguments("Quantity<{|CS0246:Missing|}>")] + [Arguments("Power<{|CS0246:Missing|}>")] public async Task UnresolvedArgumentsDoNotProduceEncodingDiagnostics(string type) { QuantityAnalyzerTest test = new(generate: false) @@ -88,31 +88,31 @@ public class Consumer } """ }; - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData(""" + [Test] + [Arguments(""" using MyLength = DimensionalQuantities.TypeSystem.Quantity>; public class Consumer { public MyLength Value { get; } } """)] - [InlineData(""" + [Arguments(""" public class Consumer { public Length Value { get; } } """)] - [InlineData(""" + [Arguments(""" using DimensionalQuantities.TypeSystem; public class Consumer { public Quantity Value { get; } } """)] - [InlineData(""" + [Arguments(""" public class Quantity { } @@ -124,6 +124,6 @@ public class Consumer public async Task DeliberateAliasesOpenGenericsAndUnrelatedTypesAreAllowed(string source) { QuantityAnalyzerTest test = new() { TestCode = source }; - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs index eef20fc..5b0ab65 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs @@ -1,10 +1,10 @@ using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; +[NotInParallel(nameof(QuantityAliasCodeFixProviderTests))] public sealed class QuantityAliasCodeFixProviderTests { private const string LengthType = "Quantity>"; - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public class Consumer { public TYPE Value { get; } @@ -27,7 +27,7 @@ public class Consumer public Length Value { get; } } """)] - [InlineData(""" + [Arguments(""" public class Consumer { public TYPE? Value { get; } @@ -38,7 +38,7 @@ public class Consumer public Length? Value { get; } } """)] - [InlineData(""" + [Arguments(""" public class Consumer { public /* measurement */ TYPE Value { get; } @@ -49,7 +49,7 @@ public class Consumer public /* measurement */ Length Value { get; } } """)] - [InlineData(""" + [Arguments(""" public class Consumer { public TYPE Value { get; } @@ -72,10 +72,10 @@ public async Task FixUsesAliasAndPreservesSurroundingSource(string template, str CodeActionEquivalenceKey = rawType is null ? "UseAlias:Length" : "UseAlias:LengthCurrent" }; test.ExpectedDiagnostics.Add(Suggestion(0, rawType is null ? "Length" : "LengthCurrent")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task NameOfDoesNotOfferFixThatChangesTheReturnedName() { QuantityCodeFixTest test = new() @@ -90,10 +90,10 @@ public class Consumer NumberOfFixAllIterations = 0 }; test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ShadowedAliasDoesNotOfferUnsafeFix() { QuantityCodeFixTest test = new() @@ -114,10 +114,10 @@ public class Consumer NumberOfFixAllIterations = 0 }; test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task FixAllReplacesMultipleRawQuantities() { QuantityCodeFixTest test = new() @@ -142,7 +142,7 @@ public class Consumer NumberOfFixAllInDocumentIterations = 1 }; test.ExpectedDiagnostics.AddRange([Suggestion(0, "Length"), Suggestion(1, "Length")]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } private static DiagnosticResult Suggestion(int location, string alias) => new DiagnosticResult("DQ0003", DiagnosticSeverity.Info).WithLocation(location).WithArguments(alias); diff --git a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj index f4692dd..37c1f87 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj +++ b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs index 4d2d94a..be28e60 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs @@ -5,30 +5,30 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(ArithmeticDiscoveryTests))] public sealed class ArithmeticDiscoveryTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Theory] - [InlineData("length * time", true)] - [InlineData("length / time", false)] - public void ReadsBoundQuantityOperands(string expression, bool multiply) + [Test] + [Arguments("length * time", true)] + [Arguments("length / time", false)] + public async Task ReadsBoundQuantityOperands(string expression, bool multiply) { - ArithmeticOperation operation = Assert.Single(Discover(expression)); + ArithmeticOperation operation = (await Assert.That(Discover(expression)).HasSingleItem()); Dimension left = new(Length: 1); Dimension right = new(Time: 1); - Assert.Equal(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, - left, right, multiply ? left * right : left / right), operation); + await Assert.That(operation).IsEqualTo(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, + left, right, multiply ? left * right : left / right)); } - [Theory] - [InlineData("length * time", true)] - [InlineData("length / time", false)] - public void ReadsNullableQuantityOperands(string expression, bool multiply) + [Test] + [Arguments("length * time", true)] + [Arguments("length / time", false)] + public async Task ReadsNullableQuantityOperands(string expression, bool multiply) { string source = $$""" public static class Consumer @@ -36,15 +36,15 @@ public static class Consumer public static object Value(Length? length, Time? time) => {{expression}}; } """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); + ArithmeticOperation operation = (await Assert.That(DiscoverFromSource(source)).HasSingleItem()); Dimension left = new(Length: 1); Dimension right = new(Time: 1); - Assert.Equal(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, - left, right, multiply ? left * right : left / right), operation); + await Assert.That(operation).IsEqualTo(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, + left, right, multiply ? left * right : left / right)); } - [Fact] - public void NullableQuantityDivisorRequestsTheInverseDimension() + [Test] + public async Task NullableQuantityDivisorRequestsTheInverseDimension() { const string source = """ public static class Consumer @@ -52,18 +52,18 @@ public static class Consumer public static object Value(Length? length) => 2d / length; } """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1)), operation); + ArithmeticOperation operation = (await Assert.That(DiscoverFromSource(source)).HasSingleItem()); + await Assert.That(operation).IsEqualTo(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1))); } - [Theory] - [InlineData("double?", "Time")] - [InlineData("double?", "Time?")] - [InlineData("float?", "Time")] - [InlineData("float?", "Time?")] - [InlineData("int?", "Time")] - [InlineData("int?", "Time?")] - public void NullableNumericScalarDivisionRequestsTheInverseDimension(string scalarType, string quantityType) + [Test] + [Arguments("double?", "Time")] + [Arguments("double?", "Time?")] + [Arguments("float?", "Time")] + [Arguments("float?", "Time?")] + [Arguments("int?", "Time")] + [Arguments("int?", "Time?")] + public async Task NullableNumericScalarDivisionRequestsTheInverseDimension(string scalarType, string quantityType) { string source = $$""" public static class Consumer @@ -71,23 +71,23 @@ public static class Consumer public static object Value({{scalarType}} scalar, {{quantityType}} time) => scalar / time; } """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Time: 1), new(Time: -1)), operation); + ArithmeticOperation operation = (await Assert.That(DiscoverFromSource(source)).HasSingleItem()); + await Assert.That(operation).IsEqualTo(new(ArithmeticOperationKind.ScalarDivide, default, new(Time: 1), new(Time: -1))); } - [Theory] - [InlineData("length * missing")] - [InlineData("length * 1m")] - [InlineData("length * \"text\"")] - [InlineData("length + time")] - [InlineData("length * scalar")] - public void RejectsUnsupportedOperands(string expression) + [Test] + [Arguments("length * missing")] + [Arguments("length * 1m")] + [Arguments("length * \"text\"")] + [Arguments("length + time")] + [Arguments("length * scalar")] + public async Task RejectsUnsupportedOperands(string expression) { - Assert.Empty(Discover(expression)); + await Assert.That(Discover(expression)).IsEmpty(); } - [Fact] - public void ExistingBoundOperatorControlsTheResult() + [Test] + public async Task ExistingBoundOperatorControlsTheResult() { const string source = """ public static class Custom @@ -102,11 +102,11 @@ public static class Consumer public static object Value(Length length, Time time) => length * time; } """; - Assert.Empty(DiscoverFromSource(source)); + await Assert.That(DiscoverFromSource(source)).IsEmpty(); } - [Fact] - public void ScalarDivisionRequestsTheInverseDimension() + [Test] + public async Task ScalarDivisionRequestsTheInverseDimension() { const string source = """ public static class Consumer @@ -114,12 +114,12 @@ public static class Consumer public static object Value(Length length) => 2d / length; } """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1)), operation); + ArithmeticOperation operation = (await Assert.That(DiscoverFromSource(source)).HasSingleItem()); + await Assert.That(operation).IsEqualTo(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1))); } - [Fact] - public void DecimalDoesNotBecomeAnImplicitDoubleScalar() + [Test] + public async Task DecimalDoesNotBecomeAnImplicitDoubleScalar() { const string source = """ public static class Consumer @@ -127,11 +127,11 @@ public static class Consumer public static object Value(Length length) => 2m / length; } """; - Assert.Empty(DiscoverFromSource(source)); + await Assert.That(DiscoverFromSource(source)).IsEmpty(); } - [Fact] - public void NullableDecimalDoesNotBecomeAnImplicitDoubleScalar() + [Test] + public async Task NullableDecimalDoesNotBecomeAnImplicitDoubleScalar() { const string source = """ public static class Consumer @@ -139,7 +139,7 @@ public static class Consumer public static object Value(decimal? scalar, Time? time) => scalar / time; } """; - Assert.Empty(DiscoverFromSource(source)); + await Assert.That(DiscoverFromSource(source)).IsEmpty(); } private static ImmutableArray Discover(string expression) @@ -172,7 +172,7 @@ private static ImmutableArray DiscoverFromSource(string sou ImmutableArray.Builder operations = ImmutableArray.CreateBuilder(); foreach (BinaryExpressionSyntax binary in tree.GetRoot().DescendantNodes().OfType()) { - if (ArithmeticDiscovery.TryRead(binary, model, reader, out ArithmeticOperation operation, TestContext.Current.CancellationToken)) + if (ArithmeticDiscovery.TryRead(binary, model, reader, out ArithmeticOperation operation, TestContext.Current!.Execution.CancellationToken)) { operations.Add(operation); } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs index 2c50818..31110a4 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs @@ -4,14 +4,14 @@ using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(DiscoverySeedCollectorTests))] public sealed class DiscoverySeedCollectorTests { - [Fact] - public void RawQuantityDeclarationRequestsItsDimension() + [Test] + public async Task RawQuantityDeclarationRequestsItsDimension() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -20,14 +20,14 @@ public class Consumer public Quantity> Value { get; } } """; - SyntaxTree tree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree tree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current!.Execution.CancellationToken); string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); CSharpCompilation compilation = CSharpCompilation.Create("Consumer", [tree], references, new(OutputKind.DynamicallyLinkedLibrary)); - ImmutableArray result = DiscoverySeedCollector.FindRequestedDimensions(compilation, [tree], TestContext.Current.CancellationToken); + ImmutableArray result = DiscoverySeedCollector.FindRequestedDimensions(compilation, [tree], TestContext.Current!.Execution.CancellationToken); Dimension expected = new(Length: 1, ElectricCurrent: 1); - Assert.Equal(expected, Assert.Single(result)); + await Assert.That((await Assert.That(result).HasSingleItem())).IsEqualTo(expected); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs index 4c6ef49..6930233 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs @@ -4,19 +4,19 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(EnglishExponentDiscoveryTests))] public sealed class EnglishExponentDiscoveryTests { - [Theory] - [InlineData("NumberTwo", 2, 1)] - [InlineData("NumberHalf", 1, 2)] - [InlineData("NumberTwoQuarters", 1, 2)] - [InlineData("NumberMinusThreeOverTwo", -3, 2)] - [InlineData("NumberMillionth", 1, 1000000)] - public void DiscoversOnlyTheRequestedEnglishName(string name, int numerator, int denominator) + [Test] + [Arguments("NumberTwo", 2, 1)] + [Arguments("NumberHalf", 1, 2)] + [Arguments("NumberTwoQuarters", 1, 2)] + [Arguments("NumberMinusThreeOverTwo", -3, 2)] + [Arguments("NumberMillionth", 1, 1000000)] + public async Task DiscoversOnlyTheRequestedEnglishName(string name, int numerator, int denominator) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -24,33 +24,35 @@ class Consumer { object Value(object quantity) => Power<{{name}}>.Of(quantity); """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool success = discovery.TryRead(invocation, out EnglishExponentAlias result, TestContext.Current.CancellationToken); + bool success = discovery.TryRead(invocation, out EnglishExponentAlias result, TestContext.Current!.Execution.CancellationToken); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(name, result.Name), - () => Assert.Equal(expected, result.Value)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result.Name).IsEqualTo(name); + await Assert.That(result.Value).IsEqualTo(expected); + } } - [Theory] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power>.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "struct NumberTwo { }")] - [InlineData("Power.Of(quantity)", "using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3;")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Other.Power.Of(quantity)", "namespace Other { struct Power { } }")] - [InlineData("Power.Other(quantity)", "")] - [InlineData("Power.Of(quantity, quantity)", "")] - public void IgnoresNamesThatShouldNotBecomeGeneratedAliases(string expression, string declarations) + [Test] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Power>.Of(quantity)", "")] + [Arguments("Power.Of(quantity)", "struct NumberTwo { }")] + [Arguments("Power.Of(quantity)", "using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3;")] + [Arguments("Power.Of(quantity)", "")] + [Arguments("Other.Power.Of(quantity)", "namespace Other { struct Power { } }")] + [Arguments("Power.Other(quantity)", "")] + [Arguments("Power.Of(quantity, quantity)", "")] + public async Task IgnoresNamesThatShouldNotBecomeGeneratedAliases(string expression, string declarations) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -59,16 +61,16 @@ class Consumer { object Value(object quantity) => {{expression}}; } """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, TestContext.Current.CancellationToken); + bool result = discovery.TryRead(invocation, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } - [Fact] - public void DoesNotReplaceAnAmbiguousExistingType() + [Test] + public async Task DoesNotReplaceAnAmbiguousExistingType() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -80,12 +82,12 @@ class Consumer { object Value(object quantity) => Power.Of(quantity); """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, TestContext.Current.CancellationToken); + bool result = discovery.TryRead(invocation, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } private static CSharpCompilation Compile(string source) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs index b49900f..1995de4 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs @@ -6,46 +6,46 @@ using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(MetadataQuantityDiscoveryTests))] public sealed class MetadataQuantityDiscoveryTests { - [Theory] - [InlineData("Library.Create()")] - [InlineData("Library.Field")] - [InlineData("Library.Property")] - [InlineData("Library.Values()")] - [InlineData("Library.Values()[0]")] - [InlineData("Library.Pair()")] - public void DiscoversQuantityTypesInReferencedResultsAndCollections(string expression) + [Test] + [Arguments("Library.Create()")] + [Arguments("Library.Field")] + [Arguments("Library.Property")] + [Arguments("Library.Values()")] + [Arguments("Library.Values()[0]")] + [Arguments("Library.Pair()")] + public async Task DiscoversQuantityTypesInReferencedResultsAndCollections(string expression) { CSharpCompilation compilation = CompileConsumer(expression); SyntaxTree tree = compilation.SyntaxTrees.Single(); - ExpressionSyntax value = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single().Expression; + ExpressionSyntax value = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single().Expression; MetadataQuantityDiscovery discovery = new(compilation.GetSemanticModel(tree)); - ImmutableArray result = discovery.Discover(value, TestContext.Current.CancellationToken); + ImmutableArray result = discovery.Discover(value, TestContext.Current!.Execution.CancellationToken); Dimension expected = new(Length: 1, ElectricCurrent: 1); - Assert.Equal(expected, Assert.Single(result)); + await Assert.That((await Assert.That(result).HasSingleItem())).IsEqualTo(expected); } - [Theory] - [InlineData("Library.Other()")] - [InlineData("Library.Missing()")] - [InlineData("Library.Zero()")] - public void IgnoresUnrelatedUnresolvedAndDimensionlessTypes(string expression) + [Test] + [Arguments("Library.Other()")] + [Arguments("Library.Missing()")] + [Arguments("Library.Zero()")] + public async Task IgnoresUnrelatedUnresolvedAndDimensionlessTypes(string expression) { CSharpCompilation compilation = CompileConsumer(expression); SyntaxTree tree = compilation.SyntaxTrees.Single(); - ExpressionSyntax value = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single().Expression; + ExpressionSyntax value = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single().Expression; MetadataQuantityDiscovery discovery = new(compilation.GetSemanticModel(tree)); - ImmutableArray result = discovery.Discover(value, TestContext.Current.CancellationToken); + ImmutableArray result = discovery.Discover(value, TestContext.Current!.Execution.CancellationToken); - Assert.Empty(result); + await Assert.That(result).IsEmpty(); } private static CSharpCompilation CompileConsumer(string expression) @@ -75,7 +75,7 @@ public static class Library CSharpCompilation library = CSharpCompilation.Create("MetadataLibrary", [CSharpSyntaxTree.ParseText(librarySource, options)], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using MemoryStream stream = new(); - EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!emitted.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs index 83fa21c..b5198e8 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs @@ -4,29 +4,29 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(PowerDiscoveryTests))] public sealed class PowerDiscoveryTests { - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() + [Test] + public async Task MissingRuntimeReferenceThrowsWithTheRequiredTypeName() { - SyntaxTree tree = CSharpSyntaxTree.ParseText("class Consumer { }", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree tree = CSharpSyntaxTree.ParseText("class Consumer { }", cancellationToken: TestContext.Current!.Execution.CancellationToken); CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer", [tree]); SemanticModel model = compilation.GetSemanticModel(tree); - InvalidOperationException result = Assert.Throws(() => new PowerDiscovery(model)); + InvalidOperationException result = (await Assert.That(() => new PowerDiscovery(model)).ThrowsExactly())!; - Assert.Contains(typeof(Power<>).FullName!, result.Message); + await Assert.That(result.Message).Contains(typeof(Power<>).FullName!); } - [Theory] - [InlineData("Power>", "", "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("Power", "using Half = DimensionalQuantities.TypeSystem.Fraction;", "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("Root", "using Root = DimensionalQuantities.TypeSystem.Power>;", "global::DimensionalQuantities.TypeSystem.Fraction")] - public void ReadsTheExponentWithoutChangingItsDeclaredType(string powerTypeName, string alias, string expectedExponentTypeName) + [Test] + [Arguments("Power>", "", "global::DimensionalQuantities.TypeSystem.Fraction")] + [Arguments("Power", "using Half = DimensionalQuantities.TypeSystem.Fraction;", "global::DimensionalQuantities.TypeSystem.Fraction")] + [Arguments("Root", "using Root = DimensionalQuantities.TypeSystem.Power>;", "global::DimensionalQuantities.TypeSystem.Fraction")] + public async Task ReadsTheExponentWithoutChangingItsDeclaredType(string powerTypeName, string alias, string expectedExponentTypeName) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -35,23 +35,25 @@ public class Consumer { public object Value(object quantity) => {{powerTypeName} """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool read = discovery.TryRead(invocation, out Rational result, out string exponentTypeName, TestContext.Current.CancellationToken); + bool read = discovery.TryRead(invocation, out Rational result, out string exponentTypeName, TestContext.Current!.Execution.CancellationToken); Rational expected = new(1, 2); - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result), - () => Assert.Equal(expectedExponentTypeName, exponentTypeName)); + using (Assert.Multiple()) + { + await Assert.That(read).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + await Assert.That(exponentTypeName).IsEqualTo(expectedExponentTypeName); + } } - [Theory] - [InlineData("NumberTwo", 2, 1, "global::DimensionalQuantities.TypeSystem.TerminalHex2")] - [InlineData("NumberHalf", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("NumberTwoQuarters", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("NumberMinusTwo", -2, 1, "global::DimensionalQuantities.TypeSystem.Negative")] - public void ReadsUnresolvedEnglishExponentNames(string name, int numerator, int denominator, string expectedTypeName) + [Test] + [Arguments("NumberTwo", 2, 1, "global::DimensionalQuantities.TypeSystem.TerminalHex2")] + [Arguments("NumberHalf", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] + [Arguments("NumberTwoQuarters", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] + [Arguments("NumberMinusTwo", -2, 1, "global::DimensionalQuantities.TypeSystem.Negative")] + public async Task ReadsUnresolvedEnglishExponentNames(string name, int numerator, int denominator, string expectedTypeName) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -59,28 +61,30 @@ public class Consumer { public object Value(object quantity) => Power<{{name}}>. """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool read = discovery.TryRead(invocation, out Rational result, out string typeName, TestContext.Current.CancellationToken); + bool read = discovery.TryRead(invocation, out Rational result, out string typeName, TestContext.Current!.Execution.CancellationToken); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result), - () => Assert.Equal(expectedTypeName, typeName)); + using (Assert.Multiple()) + { + await Assert.That(read).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + await Assert.That(typeName).IsEqualTo(expectedTypeName); + } } - [Theory] - [InlineData("Other.Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Other(quantity)")] - [InlineData("Power.Of(quantity, quantity)")] - [InlineData("Power.Of()")] - public void RejectsUnrelatedAndUnsupportedCalls(string expression) + [Test] + [Arguments("Other.Power.Of(quantity)")] + [Arguments("Power.Of(quantity)")] + [Arguments("Power.Of(quantity)")] + [Arguments("Power.Of(quantity)")] + [Arguments("Power.Of(quantity)")] + [Arguments("Power.Other(quantity)")] + [Arguments("Power.Of(quantity, quantity)")] + [Arguments("Power.Of()")] + public async Task RejectsUnrelatedAndUnsupportedCalls(string expression) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -90,11 +94,11 @@ public class Consumer { public object Value(object quantity) => {{expression}}; """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); + bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } private static CSharpCompilation Compile(string source) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs index f379f2d..084b0b3 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs @@ -4,99 +4,103 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(PowerMethodDiscoveryTests))] public sealed class PowerMethodDiscoveryTests { - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("Cubed", 3, 1)] - [InlineData("Pow4", 4, 1)] - [InlineData("Pow5", 5, 1)] - [InlineData("Pow6", 6, 1)] - [InlineData("SquareRoot", 1, 2)] - [InlineData("CubeRoot", 1, 3)] - [InlineData("Root4", 1, 4)] - [InlineData("Root5", 1, 5)] - [InlineData("Root6", 1, 6)] - public void ReadsTheExponentForEachConvenienceMethod(string name, int numerator, int denominator) + [Test] + [Arguments("Squared", 2, 1)] + [Arguments("Cubed", 3, 1)] + [Arguments("Pow4", 4, 1)] + [Arguments("Pow5", 5, 1)] + [Arguments("Pow6", 6, 1)] + [Arguments("SquareRoot", 1, 2)] + [Arguments("CubeRoot", 1, 3)] + [Arguments("Root4", 1, 4)] + [Arguments("Root5", 1, 5)] + [Arguments("Root6", 1, 6)] + public async Task ReadsTheExponentForEachConvenienceMethod(string name, int numerator, int denominator) { string source = $$""" class Consumer { object Value(object quantity) => quantity.{{name}}(); } """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current.CancellationToken); + bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current!.Execution.CancellationToken); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result), - () => Assert.Equal(name, methodName)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + await Assert.That(methodName).IsEqualTo(name); + } } - [Theory] - [InlineData("quantity.Pow7()")] - [InlineData("quantity.Root7()")] - [InlineData("quantity.Squared(2)")] - [InlineData("quantity.Squared()")] - [InlineData("quantity.squared()")] - public void RejectsUnsupportedMethodCalls(string expression) + [Test] + [Arguments("quantity.Pow7()")] + [Arguments("quantity.Root7()")] + [Arguments("quantity.Squared(2)")] + [Arguments("quantity.Squared()")] + [Arguments("quantity.squared()")] + public async Task RejectsUnsupportedMethodCalls(string expression) { string source = $$"""class Consumer { object Value(object quantity) => {{expression}}; }"""; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); + bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } - [Theory] - [InlineData("class Other { public int Squared() => 7; }", "quantity.Squared()")] - [InlineData("class Other { public int Squared() => 7; }", "quantity?.Squared()")] - [InlineData("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity.Squared()")] - [InlineData("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity?.Squared()")] - public void PreservesAlreadyBoundMethods(string declaration, string expression) + [Test] + [Arguments("class Other { public int Squared() => 7; }", "quantity.Squared()")] + [Arguments("class Other { public int Squared() => 7; }", "quantity?.Squared()")] + [Arguments("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity.Squared()")] + [Arguments("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity?.Squared()")] + public async Task PreservesAlreadyBoundMethods(string declaration, string expression) { string source = $$"""{{declaration}} class Consumer { object Value(Other quantity) => {{expression}}; }"""; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); + bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } - [Fact] - public void ReadsConditionalMemberBindingWithinAChain() + [Test] + public async Task ReadsConditionalMemberBindingWithinAChain() { const string source = "class Consumer { object Value(object quantity) => quantity?.Squared().ToString(); }"; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes() + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes() .OfType().Single(call => call.Expression is MemberBindingExpressionSyntax); PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool success = discovery.TryRead(invocation, out Rational exponent, out string methodName, TestContext.Current.CancellationToken); + bool success = discovery.TryRead(invocation, out Rational exponent, out string methodName, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(new Rational(2), exponent), - () => Assert.Equal("Squared", methodName)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(exponent).IsEqualTo(new Rational(2)); + await Assert.That(methodName).IsEqualTo("Squared"); + } } - [Fact] - public void AllowsAConvenienceMethodAlongsideAnOverloadWithRequiredArguments() + [Test] + public async Task AllowsAConvenienceMethodAlongsideAnOverloadWithRequiredArguments() { const string source = """ class Other { } @@ -105,16 +109,18 @@ class Consumer { object Value(Other quantity) => quantity.Squared(); } """; CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); + InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType().Single(); PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current.CancellationToken); + bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current!.Execution.CancellationToken); Rational expected = new(2); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result), - () => Assert.Equal("Squared", methodName)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + await Assert.That(methodName).IsEqualTo("Squared"); + } } private static CSharpCompilation Compile(string source) @@ -123,7 +129,7 @@ private static CSharpCompilation Compile(string source) IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); return CSharpCompilation.Create("PowerMethodConsumer", - [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken)], + [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current!.Execution.CancellationToken)], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs index db61ae3..dfb201e 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs @@ -1,28 +1,29 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Roslyn.Discovery; using DimensionalQuantities.Roslyn.Generators; using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(QuantityDiscoveryCoordinatorTests))] public sealed class QuantityDiscoveryCoordinatorTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Theory] - [InlineData("var make = () => length * current; return make() * time;")] - [InlineData("var pair = (length * current, time); return pair.Item1 * pair.Item2;")] - [InlineData("var (value, duration) = (length * current, time); return value * duration;")] - [InlineData("return Identity(length * current) * time;")] - [InlineData("LengthCurrent? value = null; var fallback = length * current; return (value ?? fallback) * time;")] - [InlineData("object value = length * current; return ((LengthCurrent)value) * time;")] - [InlineData("var values = new[] { length }.Select(item => item * current); return values.First() * time;")] - [InlineData("var values = new[] { length * current }; LengthTimeCurrent result = default; foreach (var value in values) { result += value * time; } return result;")] - public void IntermediateResultsComposeThroughOrdinaryCSharp(string body) + [Test] + [Arguments("var make = () => length * current; return make() * time;")] + [Arguments("var pair = (length * current, time); return pair.Item1 * pair.Item2;")] + [Arguments("var (value, duration) = (length * current, time); return value * duration;")] + [Arguments("return Identity(length * current) * time;")] + [Arguments("LengthCurrent? value = null; var fallback = length * current; return (value ?? fallback) * time;")] + [Arguments("object value = length * current; return ((LengthCurrent)value) * time;")] + [Arguments("var values = new[] { length }.Select(item => item * current); return values.First() * time;")] + [Arguments("var values = new[] { length * current }; LengthTimeCurrent result = default; foreach (var value in values) { result += value * time; } return result;")] + public async Task IntermediateResultsComposeThroughOrdinaryCSharp(string body) { string source = $$""" using System.Linq; @@ -43,11 +44,11 @@ public static LengthTimeCurrent Calculate() double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ForeachArithmeticOverTypedInputRetainsItsResultDimension() + [Test] + public async Task ForeachArithmeticOverTypedInputRetainsItsResultDimension() { const string source = """ using System.Collections.Generic; @@ -68,11 +69,11 @@ public static LengthTimeCurrent Calculate(IEnumerable values) QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(20, result); + await Assert.That(result).IsEqualTo(20); } - [Fact] - public void ConstrainedProviderResultsComposeWithArithmetic() + [Test] + public async Task ConstrainedProviderResultsComposeWithArithmetic() { const string source = """ public interface IProvider { T Get(); } @@ -94,11 +95,11 @@ private static LengthTimeCurrent Calculate(TProvider provider) where double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void OutVariablesComposeWithArithmetic() + [Test] + public async Task OutVariablesComposeWithArithmetic() { const string source = """ public static class Consumer @@ -120,14 +121,14 @@ private static LengthTimeCurrent Calculate() double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("ref", "return Get() * Time.FromSeconds(4);")] - [InlineData("ref", "ref var value = ref Get(); return value * Time.FromSeconds(4);")] - [InlineData("ref readonly", "ref readonly var value = ref Get(); return value * Time.FromSeconds(4);")] - public void RefReturnsComposeWithArithmetic(string returnModifier, string body) + [Test] + [Arguments("ref", "return Get() * Time.FromSeconds(4);")] + [Arguments("ref", "ref var value = ref Get(); return value * Time.FromSeconds(4);")] + [Arguments("ref readonly", "ref readonly var value = ref Get(); return value * Time.FromSeconds(4);")] + public async Task RefReturnsComposeWithArithmetic(string returnModifier, string body) { string source = $$""" public static class Consumer @@ -145,13 +146,13 @@ private static LengthTimeCurrent Calculate() double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("Span")] - [InlineData("ReadOnlySpan")] - public void SpanElementsComposeWithArithmetic(string spanType) + [Test] + [Arguments("Span")] + [Arguments("ReadOnlySpan")] + public async Task SpanElementsComposeWithArithmetic(string spanType) { string source = $$""" using System; @@ -165,11 +166,11 @@ public static class Consumer double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void PropertyPatternVariablesComposeWithArithmetic() + [Test] + public async Task PropertyPatternVariablesComposeWithArithmetic() { const string source = """ public sealed class Measurement @@ -190,11 +191,11 @@ private static LengthTimeCurrent Calculate(Measurement input) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ListPatternVariablesComposeWithArithmetic() + [Test] + public async Task ListPatternVariablesComposeWithArithmetic() { const string source = """ public static class Consumer @@ -211,11 +212,11 @@ private static LengthTimeCurrent Calculate(LengthCurrent[] input) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void CustomDeconstructionResultsComposeWithArithmetic() + [Test] + public async Task CustomDeconstructionResultsComposeWithArithmetic() { const string source = """ public sealed class Measurement @@ -240,13 +241,13 @@ private static LengthTimeCurrent Calculate(Measurement input) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("public LengthCurrent Get() => Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("LengthCurrent IProvider.Get() => Length.FromMetres(2) * Current.FromAmps(3);")] - public void GenericInterfaceResultsComposeWithArithmetic(string implementation) + [Test] + [Arguments("public LengthCurrent Get() => Length.FromMetres(2) * Current.FromAmps(3);")] + [Arguments("LengthCurrent IProvider.Get() => Length.FromMetres(2) * Current.FromAmps(3);")] + public async Task GenericInterfaceResultsComposeWithArithmetic(string implementation) { string source = $$""" public interface IProvider { T Get(); } @@ -268,14 +269,14 @@ private static LengthTimeCurrent Calculate(IProvider provider) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] - [InlineData("switch (input) { case LengthCurrent value: return value * Time.FromSeconds(4); default: throw new System.Exception(); }")] - [InlineData("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] - public void PatternVariablesComposeWithArithmetic(string body) + [Test] + [Arguments("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] + [Arguments("switch (input) { case LengthCurrent value: return value * Time.FromSeconds(4); default: throw new System.Exception(); }")] + [Arguments("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] + public async Task PatternVariablesComposeWithArithmetic(string body) { string source = $$""" public static class Consumer @@ -291,11 +292,11 @@ private static LengthTimeCurrent Calculate(object input) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void IteratorResultsComposeWithArithmetic() + [Test] + public async Task IteratorResultsComposeWithArithmetic() { const string source = """ using System.Collections.Generic; @@ -322,13 +323,13 @@ private static LengthTimeCurrent Calculate() double result = Evaluate(discovery.Compilation); double expected = 60; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] - [InlineData("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] - public void UnionCaseVariablesComposeWithArithmetic(string body) + [Test] + [Arguments("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] + [Arguments("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] + public async Task UnionCaseVariablesComposeWithArithmetic(string body) { string source = $$""" public union Measurement(LengthCurrent, Time); @@ -345,11 +346,11 @@ private static LengthTimeCurrent Calculate(Measurement input) double result = Evaluate(discovery.Compilation); double expected = 24; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void IncompatibleUnionCasesDoNotSupplyDimensionsToArithmetic() + [Test] + public async Task IncompatibleUnionCasesDoNotSupplyDimensionsToArithmetic() { const string source = """ public union Measurement(LengthCurrent, Time); @@ -368,16 +369,18 @@ public static object Calculate(Measurement input, Current current) } """; QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS8506"), - () => Assert.DoesNotContain(result.Sources, source => source.HintName == "Arithmetic.g.cs")); + using (Assert.Multiple()) + { + await Assert.That(errors.Any(diagnostic => diagnostic.Id == "CS8506")).IsTrue(); + await Assert.That(result.Sources.Any(source => source.HintName == "Arithmetic.g.cs")).IsFalse(); + } } - [Fact] - public void AsyncIteratorResultsComposeWithArithmetic() + [Test] + public async Task AsyncIteratorResultsComposeWithArithmetic() { const string source = """ using System.Collections.Generic; @@ -407,11 +410,11 @@ private static async Task Calculate() double result = Evaluate(discovery.Compilation); double expected = 60; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void AwaitedIntermediateResultsComposeWithArithmetic() + [Test] + public async Task AwaitedIntermediateResultsComposeWithArithmetic() { const string source = """ using System.Threading.Tasks; @@ -429,11 +432,11 @@ private static async Task Make() QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Fact] - public void BlockGetterResultsComposeAcrossSourceFiles() + [Test] + public async Task BlockGetterResultsComposeAcrossSourceFiles() { const string member = """ public static class Measurements @@ -454,14 +457,14 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(consumer, member); double result = Evaluate(discovery.Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData("new LengthCurrent()")] - [InlineData("default(LengthCurrent)")] - [InlineData("Make()")] - public void ExplicitIntermediateTypesSupplyDimensionsWithoutInitialisers(string expression) + [Test] + [Arguments("new LengthCurrent()")] + [Arguments("default(LengthCurrent)")] + [Arguments("Make()")] + public async Task ExplicitIntermediateTypesSupplyDimensionsWithoutInitialisers(string expression) { string source = $$""" public static class Consumer @@ -474,13 +477,13 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(0, result); + await Assert.That(result).IsEqualTo(0); } - [Theory] - [InlineData("FromSiBaseUnit(6000)")] - [InlineData("FromPrefixedUnits(6, 3, 0)")] - public void StandaloneCanonicalFactoryRequestsAQuantityAndItsConversions(string factory) + [Test] + [Arguments("FromSiBaseUnit(6000)")] + [Arguments("FromPrefixedUnits(6, 3, 0)")] + public async Task StandaloneCanonicalFactoryRequestsAQuantityAndItsConversions(string factory) { string source = $$""" public static class Consumer @@ -491,14 +494,14 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(6, result); + await Assert.That(result).IsEqualTo(6); } - [Theory] - [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).Squared()", "LengthSquaredTimeCurrentSquared", 144)] - [InlineData("Power.Of(Length.FromMetres(2) * Current.FromAmps(3))", "LengthSquaredTimeCurrentSquared", 144)] - [InlineData("Power.Of(Length.FromMetres(3) * Current.FromAmps(3))", "SquareRootLengthTimeSquareRootCurrent", 12)] - public void PowerResultsComposeThroughInferredDelegates(string expression, string resultType, double expected) + [Test] + [Arguments("(Length.FromMetres(2) * Current.FromAmps(3)).Squared()", "LengthSquaredTimeCurrentSquared", 144)] + [Arguments("Power.Of(Length.FromMetres(2) * Current.FromAmps(3))", "LengthSquaredTimeCurrentSquared", 144)] + [Arguments("Power.Of(Length.FromMetres(3) * Current.FromAmps(3))", "SquareRootLengthTimeSquareRootCurrent", 12)] + public async Task PowerResultsComposeThroughInferredDelegates(string expression, string resultType, double expected) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -515,11 +518,11 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ExistingMultiplicationOperatorKeepsItsBehaviour() + [Test] + public async Task ExistingMultiplicationOperatorKeepsItsBehaviour() { const string source = """ public static class CustomOperators @@ -538,11 +541,11 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(168, result); + await Assert.That(result).IsEqualTo(168); } - [Fact] - public void ExistingConvenienceMethodKeepsItsBehaviourAfterItsReceiverResolves() + [Test] + public async Task ExistingConvenienceMethodKeepsItsBehaviourAfterItsReceiverResolves() { const string source = """ public static class CustomMethods @@ -558,14 +561,14 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(21, result); + await Assert.That(result).IsEqualTo(21); } - [Theory] - [InlineData("wrapper + wrapper")] - [InlineData("wrapper - wrapper")] - [InlineData("-wrapper")] - public void BoundOperatorResultsComposeWithDimensionalArithmetic(string expression) + [Test] + [Arguments("wrapper + wrapper")] + [Arguments("wrapper - wrapper")] + [Arguments("-wrapper")] + public async Task BoundOperatorResultsComposeWithDimensionalArithmetic(string expression) { string source = $$""" public sealed class Wrapper @@ -587,13 +590,13 @@ public static TimeCurrent Calculate() QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(12, result); + await Assert.That(result).IsEqualTo(12); } - [Theory] - [InlineData("choose ? length * current : length * time", "CS0173")] - [InlineData("choose switch { true => length * current, false => length * time }", "CS8506")] - public void ConflictingBranchesDoNotSupplyDimensionsToFurtherArithmetic(string expression, string expectedDiagnostic) + [Test] + [Arguments("choose ? length * current : length * time", "CS0173")] + [Arguments("choose switch { true => length * current, false => length * time }", "CS8506")] + public async Task ConflictingBranchesDoNotSupplyDimensionsToFurtherArithmetic(string expression, string expectedDiagnostic) { string source = $$""" public static class Consumer @@ -606,17 +609,19 @@ public static object Value(bool choose, Length length, Current current, Time tim } """; QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == expectedDiagnostic), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(errors.Any(diagnostic => diagnostic.Id == expectedDiagnostic)).IsTrue(); + await Assert.That(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")).IsNull(); + await Assert.That(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + } } - [Fact] - public void AmbiguousMethodCallsRemainCompilerErrors() + [Test] + public async Task AmbiguousMethodCallsRemainCompilerErrors() { const string source = """ public static class Consumer @@ -627,20 +632,22 @@ public static class Consumer } """; QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0121"), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(errors.Any(diagnostic => diagnostic.Id == "CS0121")).IsTrue(); + await Assert.That(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")).IsNull(); + await Assert.That(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + } } - [Theory] - [InlineData("var value = value * current; return value;", "CS0841")] - [InlineData("return (length + current) * time;", "CS0019")] - [InlineData("return LengthCurrent.FromBananas(6);", "CS0103")] - public void InvalidConsumerCodeRemainsACompilerError(string body, string expectedDiagnostic) + [Test] + [Arguments("var value = value * current; return value;", "CS0841")] + [Arguments("return (length + current) * time;", "CS0019")] + [Arguments("return LengthCurrent.FromBananas(6);", "CS0103")] + public async Task InvalidConsumerCodeRemainsACompilerError(string body, string expectedDiagnostic) { string source = $$""" public static class Consumer @@ -649,14 +656,14 @@ public static object Value(Length length, Current current, Time time) { {{body}} } """; QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Contains(errors, diagnostic => diagnostic.Id == expectedDiagnostic); + await Assert.That(errors.Any(diagnostic => diagnostic.Id == expectedDiagnostic)).IsTrue(); } - [Fact] - public void LongDependentExpressionsCompleteWithoutAnArbitrarySmallPassLimit() + [Test] + public async Task LongDependentExpressionsCompleteWithoutAnArbitrarySmallPassLimit() { string expression = string.Join(" * ", Enumerable.Repeat("Current.FromAmps(1)", 20)); string source = $$""" @@ -669,15 +676,15 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(2, result); + await Assert.That(result).IsEqualTo(2); } - [Theory] - [InlineData("var squared = current * current; var heating = squared * resistance;", "Power", "heating", 36)] - [InlineData("var squared = current * current; var copy = squared; var heating = copy * resistance; var energy = heating * time;", "Energy", "energy", 72)] - [InlineData("var squared = (2 * current) * current / 2; var heating = squared * resistance;", "Power", "heating", 36)] - [InlineData("var squared = current * current; var fourth = squared * squared;", "Current4", "fourth", 81)] - public void ArithmeticThroughLocalInitialisersCompilesAndExecutes(string declarations, string resultType, string resultName, double expected) + [Test] + [Arguments("var squared = current * current; var heating = squared * resistance;", "Power", "heating", 36)] + [Arguments("var squared = current * current; var copy = squared; var heating = copy * resistance; var energy = heating * time;", "Energy", "energy", 72)] + [Arguments("var squared = (2 * current) * current / 2; var heating = squared * resistance;", "Power", "heating", 36)] + [Arguments("var squared = current * current; var fourth = squared * squared;", "Current4", "fourth", 81)] + public async Task ArithmeticThroughLocalInitialisersCompilesAndExecutes(string declarations, string resultType, string resultName, double expected) { string source = $$""" public static class Consumer @@ -695,11 +702,11 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void IdenticallyNamedLocalsInSeparateScopesRetainTheirOwnDimensions() + [Test] + public async Task IdenticallyNamedLocalsInSeparateScopesRetainTheirOwnDimensions() { const string source = """ public static class Consumer @@ -730,11 +737,11 @@ public static double Value() double result = Evaluate(Discover(source).Compilation); double expected = 48; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void CyclicLocalInitialisersDoNotCrashDiscovery() + [Test] + public async Task CyclicLocalInitialisersDoNotCrashDiscovery() { const string source = """ public static class Consumer @@ -749,16 +756,18 @@ public static object Value(Current current) """; QuantityDiscoveryResult result = Discover(source); - Assert.Multiple( - () => Assert.Null(result.Compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.DoesNotContain(result.Sources, generated => generated.HintName == "ArithmeticExtensions.g.cs")); + using (Assert.Multiple()) + { + await Assert.That(result.Compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); + await Assert.That(result.Sources.Any(generated => generated.HintName == "ArithmeticExtensions.g.cs")).IsFalse(); + } } - [Theory] - [InlineData("LengthCurrent value = length * current;")] - [InlineData("LengthCurrent first = length * current; LengthCurrent value = first;")] - [InlineData("LengthCurrent first = length * current; var value = first;")] - public void ExplicitIntermediateLocalsComposeWithFurtherArithmetic(string declarations) + [Test] + [Arguments("LengthCurrent value = length * current;")] + [Arguments("LengthCurrent first = length * current; LengthCurrent value = first;")] + [Arguments("LengthCurrent first = length * current; var value = first;")] + public async Task ExplicitIntermediateLocalsComposeWithFurtherArithmetic(string declarations) { string source = $$""" public static class Consumer @@ -776,11 +785,11 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Fact] - public void IncorrectExplicitIntermediateTypeRemainsACompilerError() + [Test] + public async Task IncorrectExplicitIntermediateTypeRemainsACompilerError() { const string source = """ class Consumer @@ -793,19 +802,19 @@ object Value(Length length, Current current, Time time) } """; QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Contains(errors, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + await Assert.That(errors.Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsTrue(); } - [Theory] - [InlineData("choose ? length * current : length * current")] - [InlineData("choose ? length * current : throw new System.Exception()")] - [InlineData("choose switch { true => length * current, false => length * current }")] - [InlineData("choose switch { true => length * current, _ => throw new System.Exception() }")] - [InlineData("choose ? (choose switch { true => length * current, _ => length * current }) : length * current")] - public void ConditionalIntermediateResultsComposeWithArithmetic(string expression) + [Test] + [Arguments("choose ? length * current : length * current")] + [Arguments("choose ? length * current : throw new System.Exception()")] + [Arguments("choose switch { true => length * current, false => length * current }")] + [Arguments("choose switch { true => length * current, _ => throw new System.Exception() }")] + [Arguments("choose ? (choose switch { true => length * current, _ => length * current }) : length * current")] + public async Task ConditionalIntermediateResultsComposeWithArithmetic(string expression) { string source = $$""" public static class Consumer @@ -824,16 +833,16 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData("public LengthCurrent Stored = Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("public LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("public LengthCurrent Stored { get => Length.FromMetres(2) * Current.FromAmps(3); }")] - [InlineData("public LengthCurrent Stored { get; } = Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("private LengthCurrent Seed = Length.FromMetres(2) * Current.FromAmps(3); public LengthCurrent Stored => Seed;")] - public void IntermediateFieldsAndPropertiesComposeWithArithmetic(string declaration) + [Test] + [Arguments("public LengthCurrent Stored = Length.FromMetres(2) * Current.FromAmps(3);")] + [Arguments("public LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3);")] + [Arguments("public LengthCurrent Stored { get => Length.FromMetres(2) * Current.FromAmps(3); }")] + [Arguments("public LengthCurrent Stored { get; } = Length.FromMetres(2) * Current.FromAmps(3);")] + [Arguments("private LengthCurrent Seed = Length.FromMetres(2) * Current.FromAmps(3); public LengthCurrent Stored => Seed;")] + public async Task IntermediateFieldsAndPropertiesComposeWithArithmetic(string declaration) { string source = $$""" public class Inputs { {{declaration}} } @@ -845,17 +854,17 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData("public LengthCurrent Make(Length length, Current current) => length * current;")] - [InlineData("public LengthCurrent Make(Length length, Current current) { LengthCurrent product = length * current; return product; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() > 0) return length * current; return length * current * 2; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() < 0) throw new System.Exception(); return length * current; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { LengthCurrent Local(Length l, Current c) => l * c; return Local(length, current); }")] - [InlineData("public LengthTime Make(Length length, Time time) => length * time; public LengthCurrent Make(Length length, Current current) => length * current;")] - public void IntermediateMethodResultsComposeWithArithmetic(string declaration) + [Test] + [Arguments("public LengthCurrent Make(Length length, Current current) => length * current;")] + [Arguments("public LengthCurrent Make(Length length, Current current) { LengthCurrent product = length * current; return product; }")] + [Arguments("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() > 0) return length * current; return length * current * 2; }")] + [Arguments("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() < 0) throw new System.Exception(); return length * current; }")] + [Arguments("public LengthCurrent Make(Length length, Current current) { LengthCurrent Local(Length l, Current c) => l * c; return Local(length, current); }")] + [Arguments("public LengthTime Make(Length length, Time time) => length * time; public LengthCurrent Make(Length length, Current current) => length * current;")] + public async Task IntermediateMethodResultsComposeWithArithmetic(string declaration) { string source = $$""" public class Inputs { {{declaration}} } @@ -867,11 +876,11 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Fact] - public void ExtensionMethodIntermediateReturnComposesWithArithmetic() + [Test] + public async Task ExtensionMethodIntermediateReturnComposesWithArithmetic() { const string source = """ public static class Helpers @@ -886,17 +895,17 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData("public static LengthCurrent Field;", "Field")] - [InlineData("public static LengthCurrent Field = default;", "Field")] - [InlineData("public static LengthCurrent Property { get; } = new();", "Property")] - [InlineData("public static LengthCurrent Property { get; set; }", "Property")] - [InlineData("public static LengthCurrent[] Values = new LengthCurrent[1];", "Values[0]")] - [InlineData("public static System.Collections.Generic.List Values = new() { default };", "Values[0]")] - public void TypeOnlyMemberAndCollectionValuesParticipateInArithmetic(string declaration, string operand) + [Test] + [Arguments("public static LengthCurrent Field;", "Field")] + [Arguments("public static LengthCurrent Field = default;", "Field")] + [Arguments("public static LengthCurrent Property { get; } = new();", "Property")] + [Arguments("public static LengthCurrent Property { get; set; }", "Property")] + [Arguments("public static LengthCurrent[] Values = new LengthCurrent[1];", "Values[0]")] + [Arguments("public static System.Collections.Generic.List Values = new() { default };", "Values[0]")] + public async Task TypeOnlyMemberAndCollectionValuesParticipateInArithmetic(string declaration, string operand) { string source = $$""" public static class Consumer @@ -908,13 +917,13 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(0, result); + await Assert.That(result).IsEqualTo(0); } - [Theory] - [InlineData("new LengthCurrent[1]")] - [InlineData("new System.Collections.Generic.List { default }")] - public void InferredCollectionsRetainTheirExplicitElementDimensions(string initializer) + [Test] + [Arguments("new LengthCurrent[1]")] + [Arguments("new System.Collections.Generic.List { default }")] + public async Task InferredCollectionsRetainTheirExplicitElementDimensions(string initializer) { string source = $$""" public static class Consumer @@ -929,11 +938,11 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(0, result); + await Assert.That(result).IsEqualTo(0); } - [Fact] - public void SourceIndexerCanDeclareAnIntermediateQuantityResult() + [Test] + public async Task SourceIndexerCanDeclareAnIntermediateQuantityResult() { const string source = """ public sealed class Measurements @@ -952,11 +961,11 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Fact] - public void ExplicitLocalCanBeAssignedAfterItsDeclaration() + [Test] + public async Task ExplicitLocalCanBeAssignedAfterItsDeclaration() { const string source = """ public static class Consumer @@ -972,13 +981,13 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData("default")] - [InlineData("new()")] - public void ExplicitDefaultQuantityLocalParticipatesInArithmetic(string initializer) + [Test] + [Arguments("default")] + [Arguments("new()")] + public async Task ExplicitDefaultQuantityLocalParticipatesInArithmetic(string initializer) { string source = $$""" public static class Consumer @@ -993,36 +1002,36 @@ public static LengthTimeCurrent Calculate() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(0, result); + await Assert.That(result).IsEqualTo(0); } - [Fact] - public void EmptyInputNeedsNoDynamicSource() + [Test] + public async Task EmptyInputNeedsNoDynamicSource() { QuantityDiscoveryResult result = Discover(); - Assert.Empty(result.Sources); + await Assert.That(result.Sources).IsEmpty(); } - [Fact] - public void CancellationStopsDiscovery() + [Test] + public async Task CancellationStopsDiscovery() { using CancellationTokenSource cancellation = new(); cancellation.Cancel(); QuantityGenerationPlan defaults = DefaultQuantityDiscovery.Discover(); CSharpCompilation compilation = CreateCompilation([]); - Assert.Throws(() => QuantityDiscoveryCoordinator.Discover(compilation, [], defaults, cancellation.Token)); + await Assert.That(() => QuantityDiscoveryCoordinator.Discover(compilation, [], defaults, cancellation.Token)).ThrowsExactly(); } - [Theory] - [InlineData("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length?", "Current", "null", "Current.FromAmps(3)", -1)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "null", -1)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] - public void NullableMultiplicationDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) + [Test] + [Arguments("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] + [Arguments("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] + [Arguments("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] + [Arguments("Length?", "Current", "null", "Current.FromAmps(3)", -1)] + [Arguments("Length", "Current?", "Length.FromMetres(6)", "null", -1)] + [Arguments("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] + public async Task NullableMultiplicationDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) { string source = $$""" public static class Consumer @@ -1039,17 +1048,17 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length?", "Current", "null", "Current.FromAmps(3)", -1)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "null", -1)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] - public void NullableDivisionDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) + [Test] + [Arguments("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] + [Arguments("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] + [Arguments("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] + [Arguments("Length?", "Current", "null", "Current.FromAmps(3)", -1)] + [Arguments("Length", "Current?", "Length.FromMetres(6)", "null", -1)] + [Arguments("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] + public async Task NullableDivisionDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) { string source = $$""" public static class Consumer @@ -1066,13 +1075,13 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("Length.FromMetres(6)", 18)] - [InlineData("null", -1)] - public void NullableArithmeticUsesOperatorDiscoveredFromNonNullableOperands(string leftValue, double expectedValue) + [Test] + [Arguments("Length.FromMetres(6)", 18)] + [Arguments("null", -1)] + public async Task NullableArithmeticUsesOperatorDiscoveredFromNonNullableOperands(string leftValue, double expectedValue) { string source = $$""" public static class Consumer @@ -1089,13 +1098,13 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("Current.FromAmps(3)", 2)] - [InlineData("null", -1)] - public void NullableScalarReciprocalDiscoveryPreservesNullableResults(string value, double expectedValue) + [Test] + [Arguments("Current.FromAmps(3)", 2)] + [Arguments("null", -1)] + public async Task NullableScalarReciprocalDiscoveryPreservesNullableResults(string value, double expectedValue) { string source = $$""" public static class Consumer @@ -1110,17 +1119,17 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("Time?", "6d", "Time.FromSeconds(3)", 2)] - [InlineData("Time?", "null", "Time.FromSeconds(3)", -1)] - [InlineData("Time?", "6d", "null", -1)] - [InlineData("Time?", "null", "null", -1)] - [InlineData("Time", "6d", "Time.FromSeconds(3)", 2)] - [InlineData("Time", "null", "Time.FromSeconds(3)", -1)] - public void NullableScalarNumeratorDiscoveryPreservesNullableResults(string timeType, string scalarValue, string timeValue, double expectedValue) + [Test] + [Arguments("Time?", "6d", "Time.FromSeconds(3)", 2)] + [Arguments("Time?", "null", "Time.FromSeconds(3)", -1)] + [Arguments("Time?", "6d", "null", -1)] + [Arguments("Time?", "null", "null", -1)] + [Arguments("Time", "6d", "Time.FromSeconds(3)", 2)] + [Arguments("Time", "null", "Time.FromSeconds(3)", -1)] + public async Task NullableScalarNumeratorDiscoveryPreservesNullableResults(string timeType, string scalarValue, string timeValue, double expectedValue) { string source = $$""" public static class Consumer @@ -1137,13 +1146,13 @@ public static class Consumer QuantityDiscoveryResult discovery = Discover(source); double result = Evaluate(discovery.Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("LengthCurrent.FromSiBaseUnit(12)", 144)] - [InlineData("null", -1)] - public void NullablePowerDiscoveryAddsNullConditionalSquaredMethod(string value, double expectedValue) + [Test] + [Arguments("LengthCurrent.FromSiBaseUnit(12)", 144)] + [Arguments("null", -1)] + public async Task NullablePowerDiscoveryAddsNullConditionalSquaredMethod(string value, double expectedValue) { string source = $$""" public static class Consumer @@ -1158,13 +1167,13 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("LengthCurrent.FromSiBaseUnit(144)", 12)] - [InlineData("null", -1)] - public void NullablePowerDiscoveryAddsNullConditionalSquareRootMethod(string value, double expectedValue) + [Test] + [Arguments("LengthCurrent.FromSiBaseUnit(144)", 12)] + [Arguments("null", -1)] + public async Task NullablePowerDiscoveryAddsNullConditionalSquareRootMethod(string value, double expectedValue) { string source = $$""" public static class Consumer @@ -1179,13 +1188,13 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("Length.FromMetres(3)", 9)] - [InlineData("null", -1)] - public void BaseNullablePowerKeepsPregeneratedSquaredMethod(string value, double expectedValue) + [Test] + [Arguments("Length.FromMetres(3)", 9)] + [Arguments("null", -1)] + public async Task BaseNullablePowerKeepsPregeneratedSquaredMethod(string value, double expectedValue) { string source = $$""" public static class Consumer @@ -1200,14 +1209,14 @@ public static class Consumer """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Theory] - [InlineData("value?.Squared().AsSiBaseUnit()", 36)] - [InlineData("value?.Squared().Squared().AsSiBaseUnit()", 1296)] - [InlineData("(value?.Squared())?.SquareRoot().AsSiBaseUnit()", 6)] - public void NullablePowerDiscoveryHandlesConditionalAccessChains(string expression, double expectedValue) + [Test] + [Arguments("value?.Squared().AsSiBaseUnit()", 36)] + [Arguments("value?.Squared().Squared().AsSiBaseUnit()", 1296)] + [Arguments("(value?.Squared())?.SquareRoot().AsSiBaseUnit()", 6)] + public async Task NullablePowerDiscoveryHandlesConditionalAccessChains(string expression, double expectedValue) { string source = $$""" public static class Consumer @@ -1221,11 +1230,11 @@ public static double Value() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - [Fact] - public void NullablePowerDiscoveryUsesTheNearestConditionalReceiver() + [Test] + public async Task NullablePowerDiscoveryUsesTheNearestConditionalReceiver() { const string source = """ public sealed class Holder @@ -1244,7 +1253,7 @@ public static double Value() """; double result = Evaluate(Discover(source).Compilation); - Assert.Equal(36, result); + await Assert.That(result).IsEqualTo(36); } private static QuantityDiscoveryResult Discover(params string[] sources) @@ -1257,7 +1266,7 @@ private static QuantityDiscoveryResult Discover(params string[] sources) CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(defaults, "DefaultPowerExtensions"), _parseOptions, path: "DefaultPowers.g.cs"), CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(defaults, "DefaultPowerMethodExtensions"), _parseOptions, path: "DefaultPowerMethods.g.cs") ]; - return QuantityDiscoveryCoordinator.Discover(original.AddSyntaxTrees(defaultTrees), [.. original.SyntaxTrees], defaults, TestContext.Current.CancellationToken); + return QuantityDiscoveryCoordinator.Discover(original.AddSyntaxTrees(defaultTrees), [.. original.SyntaxTrees], defaults, TestContext.Current!.Execution.CancellationToken); } private static CSharpCompilation CreateCompilation(string[] sources) @@ -1272,7 +1281,7 @@ private static CSharpCompilation CreateCompilation(string[] sources) private static double Evaluate(CSharpCompilation compilation) { using MemoryStream bytes = new(); - EmitResult emitted = compilation.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emitted = compilation.Emit(bytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!emitted.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs index 7a55c38..1824ceb 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs @@ -3,50 +3,52 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(QuantityNameDiscoveryTests))] public sealed class QuantityNameDiscoveryTests { - [Theory] - [InlineData("class Consumer { void Read(LengthCurrent value) { } }")] - [InlineData("class Consumer { LengthCurrent Value; }")] - [InlineData("class Consumer { LengthCurrent Value { get; set; } }")] - [InlineData("class Consumer { LengthCurrent Value() => default; }")] - [InlineData("class Consumer { System.Collections.Generic.List Values; }")] - [InlineData("class Consumer { LengthCurrent[] Values; }")] - [InlineData("class Consumer { System.Type Value() => typeof(LengthCurrent); }")] - public void ReadsUnresolvedNamesInTypePositions(string source) + [Test] + [Arguments("class Consumer { void Read(LengthCurrent value) { } }")] + [Arguments("class Consumer { LengthCurrent Value; }")] + [Arguments("class Consumer { LengthCurrent Value { get; set; } }")] + [Arguments("class Consumer { LengthCurrent Value() => default; }")] + [Arguments("class Consumer { System.Collections.Generic.List Values; }")] + [Arguments("class Consumer { LengthCurrent[] Values; }")] + [Arguments("class Consumer { System.Type Value() => typeof(LengthCurrent); }")] + public async Task ReadsUnresolvedNamesInTypePositions(string source) { CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - IdentifierNameSyntax name = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType() + IdentifierNameSyntax name = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType() .Single(identifier => identifier.Identifier.ValueText == "LengthCurrent"); - bool success = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out Dimension result, TestContext.Current.CancellationToken); + bool success = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out Dimension result, TestContext.Current!.Execution.CancellationToken); Dimension expected = new(Length: 1, ElectricCurrent: 1); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("class LengthCurrent { } class Consumer { LengthCurrent Value; }")] - [InlineData("using LengthCurrent = System.Int32; class Consumer { LengthCurrent Value; }")] - [InlineData("class Consumer { object Value() => LengthCurrent; }")] - [InlineData("class Consumer { Missing.LengthCurrent Value; }")] - public void IgnoresBoundSymbolsAndNamesOutsideSimpleTypePositions(string source) + [Test] + [Arguments("class LengthCurrent { } class Consumer { LengthCurrent Value; }")] + [Arguments("using LengthCurrent = System.Int32; class Consumer { LengthCurrent Value; }")] + [Arguments("class Consumer { object Value() => LengthCurrent; }")] + [Arguments("class Consumer { Missing.LengthCurrent Value; }")] + public async Task IgnoresBoundSymbolsAndNamesOutsideSimpleTypePositions(string source) { CSharpCompilation compilation = Compile(source); SyntaxTree tree = compilation.SyntaxTrees.Single(); - IdentifierNameSyntax name = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType() + IdentifierNameSyntax name = tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType() .Last(identifier => identifier.Identifier.ValueText == "LengthCurrent"); - bool result = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out _, TestContext.Current.CancellationToken); + bool result = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } private static CSharpCompilation Compile(string source) @@ -54,7 +56,7 @@ private static CSharpCompilation Compile(string source) string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)); return CSharpCompilation.Create("TypeNameConsumer", - [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken)], + [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current!.Execution.CancellationToken)], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs index dba7079..be9453c 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs @@ -4,26 +4,26 @@ using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(QuantityTypeReaderTests))] public sealed class QuantityTypeReaderTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() + [Test] + public async Task MissingRuntimeReferenceThrowsWithTheRequiredTypeName() { CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer"); - InvalidOperationException result = Assert.Throws(() => new QuantityTypeReader(compilation)); + InvalidOperationException result = (await Assert.That(() => new QuantityTypeReader(compilation)).ThrowsExactly())!; - Assert.Contains(typeof(Quantity<>).FullName!, result.Message); + await Assert.That(result.Message).Contains(typeof(Quantity<>).FullName!); } - [Fact] - public void ReaderDecodesEveryAxisAndRationalMarker() + [Test] + public async Task ReaderDecodesEveryAxisAndRationalMarker() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -34,18 +34,20 @@ public static class Consumer } """; CSharpCompilation compilation = Compile(source); - IFieldSymbol field = GetField(compilation, "Value"); + IFieldSymbol field = await GetField(compilation, "Value"); QuantityTypeReader reader = new(compilation); - bool read = reader.TryRead(field.Type, out Dimension result, TestContext.Current.CancellationToken); + bool read = reader.TryRead(field.Type, out Dimension result, TestContext.Current!.Execution.CancellationToken); Dimension expected = new(19, -2, new Rational(1, 2), 4, 5, 6, 7); - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(read).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void ReaderRejectsUnrelatedAndUnresolvedTypes() + [Test] + public async Task ReaderRejectsUnrelatedAndUnresolvedTypes() { const string source = """ namespace Other { public class Quantity { } } @@ -58,18 +60,20 @@ public static class Consumer """; CSharpCompilation compilation = Compile(source); QuantityTypeReader reader = new(compilation); - bool unrelated = reader.TryRead(GetField(compilation, "Unrelated").Type, out _, TestContext.Current.CancellationToken); - bool plain = reader.TryRead(GetField(compilation, "Plain").Type, out _, TestContext.Current.CancellationToken); - bool unresolved = reader.TryRead(GetField(compilation, "Unresolved").Type, out _, TestContext.Current.CancellationToken); + bool unrelated = reader.TryRead((await GetField(compilation, "Unrelated")).Type, out _, TestContext.Current!.Execution.CancellationToken); + bool plain = reader.TryRead((await GetField(compilation, "Plain")).Type, out _, TestContext.Current!.Execution.CancellationToken); + bool unresolved = reader.TryRead((await GetField(compilation, "Unresolved")).Type, out _, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.False(unrelated), - () => Assert.False(plain), - () => Assert.False(unresolved)); + using (Assert.Multiple()) + { + await Assert.That(unrelated).IsFalse(); + await Assert.That(plain).IsFalse(); + await Assert.That(unresolved).IsFalse(); + } } - private static IFieldSymbol GetField(CSharpCompilation compilation, string name) => - Assert.IsAssignableFrom(Assert.Single(compilation.GetTypeByMetadataName("Consumer")!.GetMembers(name))); + private static async Task GetField(CSharpCompilation compilation, string name) => + (await Assert.That(await Assert.That(compilation.GetTypeByMetadataName("Consumer")!.GetMembers(name)).HasSingleItem()).IsAssignableTo())!; private static CSharpCompilation Compile(string source) { diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs index f1d12f3..5c41044 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs @@ -3,55 +3,57 @@ using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Discovery; +[NotInParallel(nameof(TypeSystemNumberReaderTests))] public sealed class TypeSystemNumberReaderTests { - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() + [Test] + public async Task MissingRuntimeReferenceThrowsWithTheRequiredTypeName() { CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer"); - InvalidOperationException result = Assert.Throws(() => new TypeSystemNumberReader(compilation)); + InvalidOperationException result = (await Assert.That(() => new TypeSystemNumberReader(compilation)).ThrowsExactly())!; - Assert.Contains(typeof(Hex<,>).FullName!, result.Message); + await Assert.That(result.Message).Contains(typeof(Hex<,>).FullName!); } - [Theory] - [InlineData("TerminalHex0", 0, 1)] - [InlineData("TerminalHexF", 15, 1)] - [InlineData("Hex", 16, 1)] - [InlineData("Negative", -3, 1)] - [InlineData("Fraction", 1, 2)] - [InlineData("Fraction, TerminalHex2>", -3, 2)] - public void ReadsNumbersFromTheirTypes(string encoding, int numerator, int denominator) + [Test] + [Arguments("TerminalHex0", 0, 1)] + [Arguments("TerminalHexF", 15, 1)] + [Arguments("Hex", 16, 1)] + [Arguments("Negative", -3, 1)] + [Arguments("Fraction", 1, 2)] + [Arguments("Fraction, TerminalHex2>", -3, 2)] + public async Task ReadsNumbersFromTheirTypes(string encoding, int numerator, int denominator) { CSharpCompilation compilation = Compile($"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {encoding} Value; }}"); IFieldSymbol field = (IFieldSymbol)compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); TypeSystemNumberReader reader = new(compilation); - bool read = reader.TryRead(field.Type, out Rational result, TestContext.Current.CancellationToken); + bool read = reader.TryRead(field.Type, out Rational result, TestContext.Current!.Execution.CancellationToken); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(read).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("int")] - [InlineData("Missing")] - [InlineData("Fraction")] - [InlineData("Custom")] - public void RejectsUnrecognisedNumbersAndZeroDenominators(string encoding) + [Test] + [Arguments("int")] + [Arguments("Missing")] + [Arguments("Fraction")] + [Arguments("Custom")] + public async Task RejectsUnrecognisedNumbersAndZeroDenominators(string encoding) { CSharpCompilation compilation = Compile($"using DimensionalQuantities.TypeSystem; public struct Custom : ITypeSystemNumber {{ }} public class Consumer {{ public {encoding} Value; }}"); IFieldSymbol field = (IFieldSymbol)compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); TypeSystemNumberReader reader = new(compilation); - bool result = reader.TryRead(field.Type, out _, TestContext.Current.CancellationToken); + bool result = reader.TryRead(field.Type, out _, TestContext.Current!.Execution.CancellationToken); - Assert.False(result); + await Assert.That(result).IsFalse(); } private static CSharpCompilation Compile(string source) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs index c712bda..f51290a 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs @@ -4,7 +4,6 @@ using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CSharp.Testing; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Framework; @@ -20,7 +19,7 @@ public QuantityCodeFixTest() protected override ImmutableArray FilterCodeActions(ImmutableArray actions) { // Framework selection accepts the first matching action, so reject additional alternatives. - Assert.InRange(actions.Length, 0, 1); + new DefaultVerifier().True(actions.Length <= 1, "Expected at most one code action."); return base.FilterCodeActions(actions); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs index 6b7c2ff..5014c6a 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs @@ -1,4 +1,5 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Discovery; using DimensionalQuantities.Roslyn.Generators; @@ -6,16 +7,16 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(ArithmeticSourceEmitterTests))] public sealed class ArithmeticSourceEmitterTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Fact] - public void ExplicitPlanEmitsUsableArithmetic() + [Test] + public async Task ExplicitPlanEmitsUsableArithmetic() { Dimension current = new(ElectricCurrent: 1); Dimension currentSquared = new(ElectricCurrent: 2); @@ -40,22 +41,24 @@ public static class Consumer public static double Divided() => (Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)).AsSiBaseUnit(); } """; - Assembly assembly = CompileAndEmit(source, plan); + Assembly assembly = await CompileAndEmit(source, plan); Type consumer = assembly.GetType("Consumer")!; double left = (double)consumer.GetMethod("Left")!.Invoke(null, null)!; double right = (double)consumer.GetMethod("Right")!.Invoke(null, null)!; double divided = (double)consumer.GetMethod("Divided")!.Invoke(null, null)!; - Assert.Multiple( - () => Assert.Equal(24, left), - () => Assert.Equal(24, right), - () => Assert.Equal(4, divided)); + using (Assert.Multiple()) + { + await Assert.That(left).IsEqualTo(24); + await Assert.That(right).IsEqualTo(24); + await Assert.That(divided).IsEqualTo(4); + } } - [Theory] - [InlineData("Current.FromAmps(3) * InverseCurrent.FromSiBaseUnit(2)", false)] - [InlineData("InverseCurrent.FromSiBaseUnit(2) * Current.FromAmps(3)", true)] - public void CancellingProductEmitsAnOperatorReturningDouble(string expression, bool inverseFirst) + [Test] + [Arguments("Current.FromAmps(3) * InverseCurrent.FromSiBaseUnit(2)", false)] + [Arguments("InverseCurrent.FromSiBaseUnit(2) * Current.FromAmps(3)", true)] + public async Task CancellingProductEmitsAnOperatorReturningDouble(string expression, bool inverseFirst) { Dimension current = new(ElectricCurrent: 1); Dimension inverse = new(ElectricCurrent: -1); @@ -69,14 +72,14 @@ public static class Consumer public static double Value() => {{expression}}; } """; - Assembly assembly = CompileAndEmit(source, plan); + Assembly assembly = await CompileAndEmit(source, plan); double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; double expected = 6; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - private static Assembly CompileAndEmit(string source, QuantityGenerationPlan plan) + private static async Task CompileAndEmit(string source, QuantityGenerationPlan plan) { string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) @@ -90,13 +93,13 @@ private static Assembly CompileAndEmit(string source, QuantityGenerationPlan pla SyntaxTree additionalQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), _parseOptions, path: "AdditionalQuantities.g.cs"); SyntaxTree arithmetic = CSharpSyntaxTree.ParseText(ArithmeticSourceEmitter.Emit(plan), _parseOptions, path: "Arithmetic.g.cs"); CSharpCompilation compilation = input.AddSyntaxTrees(knownQuantities, additionalQuantities, arithmetic); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Empty(errors); + await Assert.That(errors).IsEmpty(); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); + await Assert.That(emit.Success).IsTrue().Because(string.Join(Environment.NewLine, emit.Diagnostics)); return Assembly.Load(assemblyBytes.ToArray()); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs index da41768..c89106e 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs @@ -1,16 +1,16 @@ using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(CoreConversionBoundaryTests))] public sealed class CoreConversionBoundaryTests { - [Theory] - [InlineData("Voltage.{|#0:FromVolts|}(12)", "CS0117")] - [InlineData("{|#0:Voltage|}.FromPrefixedUnits(12, 0)", "CS1929")] - [InlineData("Voltage.FromSiBaseUnit(12).{|#0:AsVolts|}()", "CS1061")] - [InlineData("{|#0:Voltage.FromSiBaseUnit(12)|}.AsPrefixedUnits(0)", "CS1929")] + [Test] + [Arguments("Voltage.{|#0:FromVolts|}(12)", "CS0117")] + [Arguments("{|#0:Voltage|}.FromPrefixedUnits(12, 0)", "CS1929")] + [Arguments("Voltage.FromSiBaseUnit(12).{|#0:AsVolts|}()", "CS1061")] + [Arguments("{|#0:Voltage.FromSiBaseUnit(12)|}.AsPrefixedUnits(0)", "CS1929")] public async Task CatalogueConversionsRequireAnExtensionPackage(string expression, string error) { QuantityGeneratorTest test = new() @@ -25,16 +25,16 @@ public class Consumer }; test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError(error).WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData("Length.FromMilliMetres(12).AsMetres()")] - [InlineData("Mass.FromKiloGrams(12).AsGrams()")] - [InlineData("Voltage.FromSiBaseUnit(12).AsSiBaseUnit()")] - [InlineData("Voltage.FromArbitrarySiComponents(12).AsArbitrarySiComponents()")] - [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).AsPrefixedUnits(3, 0)")] - [InlineData("Voltage.FromSiBaseUnit(12).Squared().AsSiBaseUnit()")] + [Test] + [Arguments("Length.FromMilliMetres(12).AsMetres()")] + [Arguments("Mass.FromKiloGrams(12).AsGrams()")] + [Arguments("Voltage.FromSiBaseUnit(12).AsSiBaseUnit()")] + [Arguments("Voltage.FromArbitrarySiComponents(12).AsArbitrarySiComponents()")] + [Arguments("(Length.FromMetres(2) * Current.FromAmps(3)).AsPrefixedUnits(3, 0)")] + [Arguments("Voltage.FromSiBaseUnit(12).Squared().AsSiBaseUnit()")] public async Task BaseGenericAndIntermediateConversionsRemainAvailable(string expression) { QuantityGeneratorTest test = new() @@ -48,6 +48,6 @@ public class Consumer TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck }; - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs index 74cc02f..4abc5ce 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs @@ -2,24 +2,24 @@ using DimensionalQuantities.Numerics; using DimensionalQuantities.Roslyn.Discovery; using DimensionalQuantities.Roslyn.Generators; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(DefaultQuantityDiscoveryTests))] public sealed class DefaultQuantityDiscoveryTests { - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("Cubed", 3, 1)] - [InlineData("Pow4", 4, 1)] - [InlineData("Pow5", 5, 1)] - [InlineData("Pow6", 6, 1)] - [InlineData("SquareRoot", 1, 2)] - [InlineData("CubeRoot", 1, 3)] - [InlineData("Root4", 1, 4)] - [InlineData("Root5", 1, 5)] - [InlineData("Root6", 1, 6)] - public void PlansEachConvenienceMethodForEveryBaseAndCatalogueDimension(string method, int numerator, int denominator) + [Test] + [Arguments("Squared", 2, 1)] + [Arguments("Cubed", 3, 1)] + [Arguments("Pow4", 4, 1)] + [Arguments("Pow5", 5, 1)] + [Arguments("Pow6", 6, 1)] + [Arguments("SquareRoot", 1, 2)] + [Arguments("CubeRoot", 1, 3)] + [Arguments("Root4", 1, 4)] + [Arguments("Root5", 1, 5)] + [Arguments("Root6", 1, 6)] + public async Task PlansEachConvenienceMethodForEveryBaseAndCatalogueDimension(string method, int numerator, int denominator) { Rational exponent = new(numerator, denominator); Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); @@ -28,21 +28,29 @@ public void PlansEachConvenienceMethodForEveryBaseAndCatalogueDimension(string m QuantityGenerationPlan plan = DefaultQuantityDiscovery.Discover(); PowerMethodOperation[] result = plan.PowerMethodOperations.Where(operation => operation.MethodName == method).ToArray(); - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void PlansReturnTypesWithoutRecursivelyAddingTheirConvenienceMethods() + [Test] + public async Task PlansReturnTypesWithoutRecursivelyAddingTheirConvenienceMethods() { QuantityGenerationPlan result = DefaultQuantityDiscovery.Discover(); Dimension[] originalDimensions = result.KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); Dimension[] allDimensions = result.KnownQuantities.Concat(result.AdditionalQuantities).Select(quantity => quantity.Dimension).ToArray(); - Assert.Multiple( - () => Assert.Equal(originalDimensions.Length * 10, result.PowerMethodOperations.Length), - () => Assert.All(result.PowerMethodOperations, operation => Assert.Contains(operation.Operand, originalDimensions)), - () => Assert.All(result.PowerMethodOperations, operation => Assert.Contains(operation.Result, allDimensions)), - () => Assert.Equal(allDimensions.Length, allDimensions.Distinct().Count()), - () => Assert.NotEmpty(result.AdditionalQuantities)); + using (Assert.Multiple()) + { + await Assert.That(result.PowerMethodOperations.Length).IsEqualTo(originalDimensions.Length * 10); + foreach (PowerMethodOperation operation in result.PowerMethodOperations) + { + await Assert.That(originalDimensions).Contains(operation.Operand); + } + foreach (PowerMethodOperation operation in result.PowerMethodOperations) + { + await Assert.That(allDimensions).Contains(operation.Result); + } + await Assert.That(allDimensions.Distinct().Count()).IsEqualTo(allDimensions.Length); + await Assert.That(result.AdditionalQuantities).IsNotEmpty(); + } } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs index 5bcf85c..0a21284 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs @@ -4,14 +4,14 @@ using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(EnglishExponentAliasEmitterTests))] public sealed class EnglishExponentAliasEmitterTests { - [Fact] - public void EmitsOnlyRequestedAliasesWithoutDuplicates() + [Test] + public async Task EmitsOnlyRequestedAliasesWithoutDuplicates() { EnglishExponentAlias[] aliases = [ @@ -21,15 +21,15 @@ public void EmitsOnlyRequestedAliasesWithoutDuplicates() ]; string result = EnglishExponentAliasEmitter.Emit(aliases); - SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); - string[] names = tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings.Select(directive => directive.Alias!.Name.Identifier.ValueText).OrderBy(name => name).ToArray(); + SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current!.Execution.CancellationToken); + string[] names = tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings.Select(directive => directive.Alias!.Name.Identifier.ValueText).OrderBy(name => name).ToArray(); string[] expected = ["NumberHalf", "NumberTwo"]; - Assert.Equal(expected, names); + await Assert.That(names).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void AliasesResolveToTheirEncodedTypesInAnotherFile() + [Test] + public async Task AliasesResolveToTheirEncodedTypesInAnotherFile() { EnglishExponentAlias[] aliases = [ @@ -42,30 +42,32 @@ public void AliasesResolveToTheirEncodedTypesInAnotherFile() IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); CSharpCompilation compilation = CSharpCompilation.Create("AliasConsumer", - [CSharpSyntaxTree.ParseText(EnglishExponentAliasEmitter.Emit(aliases), options, cancellationToken: TestContext.Current.CancellationToken), CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken)], + [CSharpSyntaxTree.ParseText(EnglishExponentAliasEmitter.Emit(aliases), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current!.Execution.CancellationToken)], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); INamedTypeSymbol consumer = compilation.GetTypeByMetadataName("Consumer")!; - IFieldSymbol integer = Assert.IsAssignableFrom(Assert.Single(consumer.GetMembers("Integer"))); - IFieldSymbol fraction = Assert.IsAssignableFrom(Assert.Single(consumer.GetMembers("Fraction"))); + IFieldSymbol integer = (await Assert.That(await Assert.That(consumer.GetMembers("Integer")).HasSingleItem()).IsAssignableTo())!; + IFieldSymbol fraction = (await Assert.That(await Assert.That(consumer.GetMembers("Fraction")).HasSingleItem()).IsAssignableTo())!; TypeSystemNumberReader reader = new(compilation); - bool integerRead = reader.TryRead(integer.Type, out Rational integerResult, TestContext.Current.CancellationToken); - bool fractionRead = reader.TryRead(fraction.Type, out Rational fractionResult, TestContext.Current.CancellationToken); + bool integerRead = reader.TryRead(integer.Type, out Rational integerResult, TestContext.Current!.Execution.CancellationToken); + bool fractionRead = reader.TryRead(fraction.Type, out Rational fractionResult, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.True(integerRead), - () => Assert.True(fractionRead), - () => Assert.Equal(new Rational(2), integerResult), - () => Assert.Equal(new Rational(1, 2), fractionResult)); + using (Assert.Multiple()) + { + await Assert.That(compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(integerRead).IsTrue(); + await Assert.That(fractionRead).IsTrue(); + await Assert.That(integerResult).IsEqualTo(new Rational(2)); + await Assert.That(fractionResult).IsEqualTo(new Rational(1, 2)); + } } - [Fact] - public void NoRequestedNamesProducesNoAliases() + [Test] + public async Task NoRequestedNamesProducesNoAliases() { string result = EnglishExponentAliasEmitter.Emit([]); - SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current!.Execution.CancellationToken); - Assert.Empty(tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings); + await Assert.That(tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings).IsEmpty(); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs index eda5454..bb60ede 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/FractionalPrefixEmitterTests.cs @@ -1,23 +1,23 @@ using DimensionalQuantities.Numerics; using DimensionalQuantities.Roslyn.Generators; using DimensionalQuantities.Units; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(FractionalPrefixEmitterTests))] public sealed class FractionalPrefixEmitterTests { - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public static Length FromPrefixedUnits(double value, int widgetPrefixExponent = 0) => Length.FromSiBaseUnit(value * 2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); """)] - [InlineData(""" + [Arguments(""" public double AsPrefixedUnits(int widgetPrefixExponent = 0) => length.AsSiBaseUnit() / (2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); """)] - [InlineData(""" + [Arguments(""" public double AsPrefixedUnits(int widgetPrefixExponent = 0) => delta.AsSiBaseUnit() / (2d * global::System.Math.Pow(10, ((double)widgetPrefixExponent) * (1d / 2d))); """)] - public void FractionalPrefixConversionsUseFloatingPointDivision(string expectedDeclaration) + public async Task FractionalPrefixConversionsUseFloatingPointDivision(string expectedDeclaration) { AtomicUnit widget = new("Widget", "Widgets", "w", Scale: 4); UnitConversionSpec[] units = @@ -28,6 +28,6 @@ public void FractionalPrefixConversionsUseFloatingPointDivision(string expectedD string source = UnitConversionSourceEmitter.Emit(units, "Custom", "public"); - Assert.Contains(expectedDeclaration, source); + await Assert.That(source).Contains(expectedDeclaration); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs index 2e824b0..dade61f 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs @@ -5,13 +5,13 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(GenerationDiagnosticTests))] public sealed class GenerationDiagnosticTests { - [Fact] + [Test] public async Task GeneratedAliasWarnsWhenItShadowsAnImportedType() { QuantityGeneratorTest test = new() @@ -32,10 +32,10 @@ public class Consumer test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ImportedMetadataTypeShadowingIsDiagnosed() { QuantityGeneratorTest test = new() @@ -53,10 +53,10 @@ public class Consumer test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task CollisionWarningPreservesTheGeneratedAliasBinding() { QuantityGeneratorTest test = new() @@ -77,15 +77,15 @@ public class Consumer test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); IPropertySymbol property = (IPropertySymbol)test.Compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); INamedTypeSymbol result = ((INamedTypeSymbol)property.Type).OriginalDefinition; INamedTypeSymbol expected = test.Compilation.GetTypeByMetadataName(typeof(Quantity<>).FullName!)!; - Assert.True(SymbolEqualityComparer.Default.Equals(expected, result)); + await Assert.That(SymbolEqualityComparer.Default.Equals(expected, result)).IsTrue(); } - [Fact] + [Test] public async Task ConflictingGlobalTypeDeclarationWarns() { QuantityGeneratorTest test = new() @@ -102,10 +102,10 @@ public class Consumer { } test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ConflictingDelegateDeclarationWarns() { QuantityGeneratorTest test = new() @@ -121,10 +121,10 @@ public async Task ConflictingDelegateDeclarationWarns() test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning) .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ConflictingExplicitAliasWarns() { QuantityGeneratorTest test = new() @@ -146,10 +146,10 @@ public class Consumer .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1537").WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task StaticMemberUseOfImportedTypeWarnsWhenShadowed() { QuantityGeneratorTest test = new() @@ -174,10 +174,10 @@ public class Consumer .WithLocation(0).WithMessage("Generated alias 'Current' conflicts with a name in this source")); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0117").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() { QuantityGeneratorTest test = new() @@ -195,10 +195,10 @@ public class Consumer } """)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task QualifiedReferenceToSameNamedTypeDoesNotWarn() { QuantityGeneratorTest test = new() @@ -216,12 +216,12 @@ public class Consumer } """)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Theory] - [InlineData("NumberTwoOverZero")] - [InlineData("NumberBanana")] + [Test] + [Arguments("NumberTwoOverZero")] + [Arguments("NumberBanana")] public async Task InvalidEnglishExponentExplainsUnresolvedRequest(string name) { QuantityGeneratorTest test = new() @@ -240,10 +240,10 @@ public class Consumer test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() { QuantityGeneratorTest test = new() @@ -266,10 +266,10 @@ public class OtherConsumer { } test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ValidEnglishExponentDoesNotProduceGenerationDiagnostics() { QuantityGeneratorTest test = new() @@ -284,10 +284,10 @@ public class Consumer } """)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task UnrelatedMissingNameDoesNotProduceGenerationDiagnostics() { QuantityGeneratorTest test = new() @@ -304,10 +304,10 @@ public class Consumer test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task UnrelatedPowerTypeDoesNotProduceGenerationDiagnostics() { QuantityGeneratorTest test = new() @@ -326,10 +326,10 @@ public class Consumer """)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ExplicitlyBoundExponentDoesNotProduceGenerationDiagnostics() { QuantityGeneratorTest test = new() @@ -345,10 +345,10 @@ public class Consumer } """)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task BoundInvalidEnglishNameDoesNotProduceGenerationDiagnostics() { QuantityGeneratorTest test = new() @@ -366,10 +366,10 @@ public class Consumer test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0453").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task InvalidNumericEncodingDoesNotCrashGenerator() { QuantityGeneratorTest test = new() @@ -389,11 +389,11 @@ public class Consumer DiagnosticResult.CompilerError("CS0315").WithLocation(1) ]); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] - public void CorrectingAnEnglishExponentRemovesItsDiagnostic() + [Test] + public async Task CorrectingAnEnglishExponentRemovesItsDiagnostic() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -404,15 +404,17 @@ public class Consumer """; CSharpCompilation original = CreateLifecycleCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(original, TestContext.Current.CancellationToken); + driver = driver.RunGenerators(original, TestContext.Current!.Execution.CancellationToken); ImmutableArray initial = driver.GetRunResult().Diagnostics; CSharpCompilation edited = CreateLifecycleCompilation(source.Replace("NumberBanana", "NumberTwo")); - driver = driver.RunGenerators(edited, TestContext.Current.CancellationToken); + driver = driver.RunGenerators(edited, TestContext.Current!.Execution.CancellationToken); ImmutableArray result = driver.GetRunResult().Diagnostics; - Assert.Multiple( - () => Assert.Contains(initial, diagnostic => diagnostic.Id == "DQ0007"), - () => Assert.Empty(result)); + using (Assert.Multiple()) + { + await Assert.That(initial.Any(diagnostic => diagnostic.Id == "DQ0007")).IsTrue(); + await Assert.That(result).IsEmpty(); + } } private static async Task CreateImportedLibraryReference() @@ -424,12 +426,12 @@ public class Current { } } """; ImmutableArray references = await ReferenceAssemblies.Net.Net100.ResolveAsync( - LanguageNames.CSharp, TestContext.Current.CancellationToken); + LanguageNames.CSharp, TestContext.Current!.Execution.CancellationToken); CSharpCompilation library = CSharpCompilation.Create("OtherLibrary", [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using MemoryStream bytes = new(); - Microsoft.CodeAnalysis.Emit.EmitResult result = library.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); + Microsoft.CodeAnalysis.Emit.EmitResult result = library.Emit(bytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!result.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, result.Diagnostics)); @@ -444,7 +446,7 @@ private static CSharpCompilation CreateLifecycleCompilation(string source) IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); return CSharpCompilation.Create("Consumer", [CSharpSyntaxTree.ParseText(source, - new CSharpParseOptions(LanguageVersion.Preview), "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken)], + new CSharpParseOptions(LanguageVersion.Preview), "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken)], references, new(OutputKind.DynamicallyLinkedLibrary)); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs index f465fd7..e539734 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs @@ -1,4 +1,5 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Numerics; using DimensionalQuantities.Roslyn.Discovery; @@ -7,16 +8,16 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(PowerMethodSourceEmitterTests))] public sealed class PowerMethodSourceEmitterTests { - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("SquareRoot", 1, 2)] - public void ConvenienceMethodDelegatesToTheEncodedPowerOverload(string method, int numerator, int denominator) + [Test] + [Arguments("Squared", 2, 1)] + [Arguments("SquareRoot", 1, 2)] + public async Task ConvenienceMethodDelegatesToTheEncodedPowerOverload(string method, int numerator, int denominator) { Dimension operand = new(Length: 1); Rational exponent = new(numerator, denominator); @@ -44,29 +45,29 @@ public static class Consumer .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); SyntaxTree[] trees = [ - CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken) + CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current!.Execution.CancellationToken) ]; CSharpCompilation compilation = CSharpCompilation.Create("DelegatingPowerConsumer", trees, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); + await Assert.That(emit.Success).IsTrue().Because(string.Join(Environment.NewLine, emit.Diagnostics)); Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); double result = (double)assembly.GetType("DimensionalQuantities.Generated.Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - Assert.Equal(109, result); + await Assert.That(result).IsEqualTo(109); } - [Theory] - [InlineData("Squared", 2, 1, -3, 9)] - [InlineData("CubeRoot", 1, 3, -8, -2)] - [InlineData("Root5", 1, 5, -32, -2)] - [InlineData("SquareRoot", 1, 2, -9, double.NaN)] - [InlineData("Root4", 1, 4, -16, double.NaN)] - public void EmittedMethodsUseTheRealOddRootAndPreserveEvenRootBehaviour(string method, int numerator, int denominator, double value, double expected) + [Test] + [Arguments("Squared", 2, 1, -3, 9)] + [Arguments("CubeRoot", 1, 3, -8, -2)] + [Arguments("Root5", 1, 5, -32, -2)] + [Arguments("SquareRoot", 1, 2, -9, double.NaN)] + [Arguments("Root4", 1, 4, -16, double.NaN)] + public async Task EmittedMethodsUseTheRealOddRootAndPreserveEvenRootBehaviour(string method, int numerator, int denominator, double value, double expected) { Dimension operand = new(Length: 1); Rational exponent = new(numerator, denominator); @@ -85,20 +86,20 @@ public static class Consumer .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); SyntaxTree[] trees = [ - CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken) + CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current!.Execution.CancellationToken), + CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current!.Execution.CancellationToken) ]; CSharpCompilation compilation = CSharpCompilation.Create("PowerMethodConsumer", trees, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); + await Assert.That(emit.Success).IsTrue().Because(string.Join(Environment.NewLine, emit.Diagnostics)); Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs index 8e1c06d..bacb684 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs @@ -1,4 +1,5 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Numerics; using DimensionalQuantities.Roslyn.Discovery; @@ -7,16 +8,16 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(PowerSourceEmitterTests))] public sealed class PowerSourceEmitterTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Fact] - public void DifferentPowersReturnTheExpectedQuantityTypes() + [Test] + public async Task DifferentPowersReturnTheExpectedQuantityTypes() { Dimension length = new(Length: 1); PowerOperation[] operations = @@ -42,14 +43,14 @@ public static double Value() } } """; - Assembly assembly = CompileAndEmit(source, plan); + Assembly assembly = await CompileAndEmit(source, plan); double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; double expected = 40; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - private static Assembly CompileAndEmit(string source, QuantityGenerationPlan plan) + private static async Task CompileAndEmit(string source, QuantityGenerationPlan plan) { string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) @@ -63,13 +64,13 @@ private static Assembly CompileAndEmit(string source, QuantityGenerationPlan pla SyntaxTree additionalQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), _parseOptions, path: "AdditionalQuantities.g.cs"); SyntaxTree powers = CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(plan), _parseOptions, path: "Powers.g.cs"); CSharpCompilation compilation = input.AddSyntaxTrees(knownQuantities, additionalQuantities, powers); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Empty(errors); + await Assert.That(errors).IsEmpty(); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); + await Assert.That(emit.Success).IsTrue().Because(string.Join(Environment.NewLine, emit.Diagnostics)); return Assembly.Load(assemblyBytes.ToArray()); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs index ab22999..4d87d2d 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs @@ -4,14 +4,14 @@ using DimensionalQuantities.Roslyn.Generators; using DimensionalQuantities.Units; using DimensionalQuantities.TypeSystem; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(QuantityDiscoveryTests))] public sealed class QuantityDiscoveryTests { - [Fact] - public void TypeRequestsAddOnlyMissingQuantitiesWithoutInventingOperations() + [Test] + public async Task TypeRequestsAddOnlyMissingQuantitiesWithoutInventingOperations() { QuantityGenerationPlan predefined = DefaultQuantityDiscovery.Discover(); Dimension requested = new(Length: 1, ElectricCurrent: 1); @@ -19,16 +19,18 @@ public void TypeRequestsAddOnlyMissingQuantitiesWithoutInventingOperations() QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefined, [], [], [], [requested, requested, new(ElectricCurrent: 1), new(ElectricCurrent: 2), default]); - Assert.Multiple( - () => Assert.Equal(requested, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Equal("LengthCurrent", result.GetQuantityName(requested)), - () => Assert.Empty(result.Operations), - () => Assert.Empty(result.PowerOperations), - () => Assert.Empty(result.PowerMethodOperations)); + using (Assert.Multiple()) + { + await Assert.That((await Assert.That(result.AdditionalQuantities).HasSingleItem()).Dimension).IsEqualTo(requested); + await Assert.That(result.GetQuantityName(requested)).IsEqualTo("LengthCurrent"); + await Assert.That(result.Operations).IsEmpty(); + await Assert.That(result.PowerOperations).IsEmpty(); + await Assert.That(result.PowerMethodOperations).IsEmpty(); + } } - [Fact] - public void ReusesPredefinedQuantitiesAndOnlyAddsNewResults() + [Test] + public async Task ReusesPredefinedQuantitiesAndOnlyAddsNewResults() { Dimension currentSquared = new(ElectricCurrent: 2); Dimension length = new(Length: 1); @@ -40,15 +42,17 @@ public void ReusesPredefinedQuantitiesAndOnlyAddsNewResults() QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefinedPlan, [operation], [], []); - Assert.Multiple( - () => Assert.Equal(predefined, Assert.Single(result.KnownQuantities.Where(quantity => quantity.Dimension == currentSquared))), - () => Assert.Equal(product, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Equal("CurrentSquared", result.GetQuantityName(currentSquared)), - () => Assert.Equal(operation, Assert.Single(result.Operations))); + using (Assert.Multiple()) + { + await Assert.That((await Assert.That(result.KnownQuantities.Where(quantity => quantity.Dimension == currentSquared)).HasSingleItem())).IsEqualTo(predefined); + await Assert.That((await Assert.That(result.AdditionalQuantities).HasSingleItem()).Dimension).IsEqualTo(product); + await Assert.That(result.GetQuantityName(currentSquared)).IsEqualTo("CurrentSquared"); + await Assert.That((await Assert.That(result.Operations).HasSingleItem())).IsEqualTo(operation); + } } - [Fact] - public void ReusesPredefinedMethodsWhilePlanningNewConvenienceMethods() + [Test] + public async Task ReusesPredefinedMethodsWhilePlanningNewConvenienceMethods() { Dimension current = new(ElectricCurrent: 1); Dimension squared = new(ElectricCurrent: 2); @@ -61,15 +65,17 @@ public void ReusesPredefinedMethodsWhilePlanningNewConvenienceMethods() QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefinedPlan, [], [], [square, cube]); - Assert.Multiple( - () => Assert.Equal(cube, Assert.Single(result.PowerMethodOperations)), - () => Assert.Equal(cubed, Assert.Single(result.AdditionalQuantities).Dimension)); + using (Assert.Multiple()) + { + await Assert.That((await Assert.That(result.PowerMethodOperations).HasSingleItem())).IsEqualTo(cube); + await Assert.That((await Assert.That(result.AdditionalQuantities).HasSingleItem()).Dimension).IsEqualTo(cubed); + } } - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("SquareRoot", 1, 2)] - public void ConvenienceMethodsReuseExplicitCanonicalPowerOperations(string method, int numerator, int denominator) + [Test] + [Arguments("Squared", 2, 1)] + [Arguments("SquareRoot", 1, 2)] + public async Task ConvenienceMethodsReuseExplicitCanonicalPowerOperations(string method, int numerator, int denominator) { Dimension current = new(ElectricCurrent: 1); Rational exponent = new(numerator, denominator); @@ -80,13 +86,15 @@ public void ConvenienceMethodsReuseExplicitCanonicalPowerOperations(string metho QuantityGenerationPlan result = QuantityDiscovery.Discover([], [expected], [convenience]); - Assert.Multiple( - () => Assert.Equal(expected, Assert.Single(result.PowerOperations)), - () => Assert.Equal(convenience, Assert.Single(result.PowerMethodOperations))); + using (Assert.Multiple()) + { + await Assert.That((await Assert.That(result.PowerOperations).HasSingleItem())).IsEqualTo(expected); + await Assert.That((await Assert.That(result.PowerMethodOperations).HasSingleItem())).IsEqualTo(convenience); + } } - [Fact] - public void ConvenienceMethodAddsCanonicalPowerAlongsideAnExplicitAlternativeEncoding() + [Test] + public async Task ConvenienceMethodAddsCanonicalPowerAlongsideAnExplicitAlternativeEncoding() { Dimension current = new(ElectricCurrent: 1); Dimension squared = new(ElectricCurrent: 2); @@ -98,14 +106,16 @@ public void ConvenienceMethodAddsCanonicalPowerAlongsideAnExplicitAlternativeEnc QuantityGenerationPlan result = QuantityDiscovery.Discover([], [alternative], [convenience]); - Assert.Multiple( - () => Assert.Equal(2, result.PowerOperations.Length), - () => Assert.Contains(alternative, result.PowerOperations), - () => Assert.Contains(canonical, result.PowerOperations)); + using (Assert.Multiple()) + { + await Assert.That(result.PowerOperations.Length).IsEqualTo(2); + await Assert.That(result.PowerOperations).Contains(alternative); + await Assert.That(result.PowerOperations).Contains(canonical); + } } - [Fact] - public void ConvenienceMethodsDeduplicateByOperandAndNameAndPlanTheirDimensions() + [Test] + public async Task ConvenienceMethodsDeduplicateByOperandAndNameAndPlanTheirDimensions() { Dimension current = new(ElectricCurrent: 1); Dimension squared = new(ElectricCurrent: 2); @@ -117,15 +127,17 @@ public void ConvenienceMethodsDeduplicateByOperandAndNameAndPlanTheirDimensions( QuantityGenerationPlan result = QuantityDiscovery.Discover([], [], [square, square, cube, squareAgain]); - Assert.Multiple( - () => Assert.Equal(expected, result.PowerMethodOperations), - () => Assert.Equal("CurrentSquared", result.GetQuantityName(squared)), - () => Assert.Equal("CurrentCubed", result.GetQuantityName(cubed)), - () => Assert.Equal(3, result.AdditionalQuantities.Length)); + using (Assert.Multiple()) + { + await Assert.That(result.PowerMethodOperations).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That(result.GetQuantityName(squared)).IsEqualTo("CurrentSquared"); + await Assert.That(result.GetQuantityName(cubed)).IsEqualTo("CurrentCubed"); + await Assert.That(result.AdditionalQuantities.Length).IsEqualTo(3); + } } - [Fact] - public void PlanKeepsCatalogueNameAndDeduplicatesOrderedOperations() + [Test] + public async Task PlanKeepsCatalogueNameAndDeduplicatesOrderedOperations() { Dimension current = new(ElectricCurrent: 1); Dimension currentSquared = new(ElectricCurrent: 2); @@ -138,30 +150,34 @@ public void PlanKeepsCatalogueNameAndDeduplicatesOrderedOperations() QuantityGenerationPlan plan = QuantityDiscovery.Discover(operations); ArithmeticOperation[] expected = [square, heat]; - Assert.Multiple( - () => Assert.Equal(expected, plan.Operations), - () => Assert.Equal("Power", plan.GetQuantityName(power)), - () => Assert.Equal("Energy", plan.GetQuantityName(energy)), - () => Assert.Equal("CurrentSquared", plan.GetQuantityName(currentSquared)), - () => Assert.Single(plan.AdditionalQuantities)); + using (Assert.Multiple()) + { + await Assert.That(plan.Operations).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That(plan.GetQuantityName(power)).IsEqualTo("Power"); + await Assert.That(plan.GetQuantityName(energy)).IsEqualTo("Energy"); + await Assert.That(plan.GetQuantityName(currentSquared)).IsEqualTo("CurrentSquared"); + await Assert.That(plan.AdditionalQuantities).HasSingleItem(); + } } - [Fact] - public void CancellingProductPlansOperandsWithoutADimensionlessQuantity() + [Test] + public async Task CancellingProductPlansOperandsWithoutADimensionlessQuantity() { Dimension current = new(ElectricCurrent: 1); Dimension inverse = new(ElectricCurrent: -1); ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, current, inverse, default); QuantityGenerationPlan result = QuantityDiscovery.Discover([operation, operation]); - Assert.Multiple( - () => Assert.Equal(operation, Assert.Single(result.Operations)), - () => Assert.Equal(inverse, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.DoesNotContain(result.KnownQuantities, quantity => quantity.Dimension == default)); + using (Assert.Multiple()) + { + await Assert.That((await Assert.That(result.Operations).HasSingleItem())).IsEqualTo(operation); + await Assert.That((await Assert.That(result.AdditionalQuantities).HasSingleItem()).Dimension).IsEqualTo(inverse); + await Assert.That(result.KnownQuantities.Any(quantity => quantity.Dimension == default)).IsFalse(); + } } - [Fact] - public void EquivalentExponentsKeepTheirOverloadsAndShareOneResultType() + [Test] + public async Task EquivalentExponentsKeepTheirOverloadsAndShareOneResultType() { Dimension current = new(ElectricCurrent: 1); Dimension rootCurrent = new(ElectricCurrent: new Rational(1, 2)); @@ -175,28 +191,32 @@ public void EquivalentExponentsKeepTheirOverloadsAndShareOneResultType() QuantityGenerationPlan result = QuantityDiscovery.Discover([], [half, half, twoQuarters, zero]); PowerOperation[] expected = [half, twoQuarters, zero]; - Assert.Multiple( - () => Assert.Equal(expected, result.PowerOperations), - () => Assert.Equal(rootCurrent, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Empty(result.Operations)); + using (Assert.Multiple()) + { + await Assert.That(result.PowerOperations).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That((await Assert.That(result.AdditionalQuantities).HasSingleItem()).Dimension).IsEqualTo(rootCurrent); + await Assert.That(result.Operations).IsEmpty(); + } } - [Fact] - public void UnknownQuantityUsesSiComponentPowersAndBasePrefixes() + [Test] + public async Task UnknownQuantityUsesSiComponentPowersAndBasePrefixes() { Dimension mass = new(Mass: 1); Dimension massSquared = new(Mass: 2); ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, mass, mass, massSquared); QuantityGenerationPlan plan = QuantityDiscovery.Discover([operation]); - PlannedQuantity quantity = Assert.Single(plan.AdditionalQuantities); - UnitDefinition unit = Assert.Single(quantity.Units); - UnitTerm term = Assert.Single(unit.Expression.Terms); - - Assert.Multiple( - () => Assert.Equal(massSquared, quantity.Dimension), - () => Assert.False(quantity.IncludeNamedConversions), - () => Assert.Equal("MassSquared", unit.Name), - () => Assert.Equal(2, term.Power), - () => Assert.Equal(SiBasePrefixExponents.Mass, term.PrefixExponent)); + PlannedQuantity quantity = await Assert.That(plan.AdditionalQuantities).HasSingleItem(); + UnitDefinition unit = (await Assert.That(quantity.Units).HasSingleItem()); + UnitTerm term = (await Assert.That(unit.Expression.Terms).HasSingleItem()); + + using (Assert.Multiple()) + { + await Assert.That(quantity.Dimension).IsEqualTo(massSquared); + await Assert.That(quantity.IncludeNamedConversions).IsFalse(); + await Assert.That(unit.Name).IsEqualTo("MassSquared"); + await Assert.That(term.Power).IsEqualTo(2); + await Assert.That(term.PrefixExponent).IsEqualTo(SiBasePrefixExponents.Mass); + } } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs index 2ae5477..687ae5f 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs @@ -1,5 +1,6 @@ using System.Collections.Immutable; using System.Reflection; +using Assembly = System.Reflection.Assembly; using System.Text; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Discovery; @@ -12,15 +13,15 @@ using Microsoft.CodeAnalysis.Emit; using Microsoft.CodeAnalysis.Text; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(QuantityGeneratorTests))] public sealed class QuantityGeneratorTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Fact] + [Test] public async Task BaseAliasesHaveUnprefixedFactoriesAndAccessors() { const string source = """ @@ -44,7 +45,7 @@ public static double UseBaseQuantities() await Compile(source); } - [Fact] + [Test] public async Task SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() { const string source = """ @@ -58,18 +59,20 @@ public static class Consumer TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck }; test.TestState.Sources.Add(("Consumer.cs", source)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); Compilation result = test.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; - IFieldSymbol aliasResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("AliasResolved"))); - IFieldSymbol factoryResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); + IFieldSymbol aliasResolved = (await Assert.That(await Assert.That(probe.GetMembers("AliasResolved")).HasSingleItem()).IsAssignableTo())!; + IFieldSymbol factoryResolved = (await Assert.That(await Assert.That(probe.GetMembers("FactoryResolved")).HasSingleItem()).IsAssignableTo())!; - Assert.Multiple( - () => Assert.Equal(true, aliasResolved.ConstantValue), - () => Assert.Equal(true, factoryResolved.ConstantValue)); + using (Assert.Multiple()) + { + await Assert.That(aliasResolved.ConstantValue is true).IsTrue(); + await Assert.That(factoryResolved.ConstantValue is true).IsTrue(); + } } - [Fact] + [Test] public async Task CatalogueAliasesAreAvailableToConsumers() { const string source = """ @@ -92,35 +95,35 @@ public static class Consumer await Compile(source); } - [Theory] - [InlineData("Length.FromMetres(2) * Length.FromMetres(3)", "Area", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)", "Power", 24)] - [InlineData("Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))", "Power", 24)] - [InlineData("Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)", "Resistance", 4)] - [InlineData("Current.FromAmps(3) * Time.FromSeconds(2)", "TimeCurrent", 6)] - [InlineData("(Current.FromAmps(2) * Time.FromSeconds(3)) / Time.FromSeconds(3)", "Current", 2)] - [InlineData("(Voltage.FromSiBaseUnit(4) * Current.FromAmps(3)) / Current.FromAmps(2)", "Voltage", 6)] - [InlineData("Current.FromAmps(3) * 2d", "Current", 6)] - [InlineData("2 * Current.FromAmps(3)", "Current", 6)] - [InlineData("Current.FromAmps(6) / 2f", "Current", 3)] - [InlineData("2d / Time.FromSeconds(4)", "Frequency", 0.5)] - [InlineData("2f / Current.FromAmps(4)", "InverseCurrent", 0.5)] - [InlineData("(2 / Current.FromAmps(4)) * Time.FromSeconds(3)", "TimePerCurrent", 1.5)] - [InlineData("(Current.FromAmps(2) * 2) * Current.FromAmps(3)", "CurrentSquared", 12)] - [InlineData("2 * (Current.FromAmps(2) * Current.FromAmps(3))", "CurrentSquared", 12)] - [InlineData("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] - [InlineData("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] - [InlineData("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] + [Test] + [Arguments("Length.FromMetres(2) * Length.FromMetres(3)", "Area", 6)] + [Arguments("Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 6)] + [Arguments("Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)", "Power", 24)] + [Arguments("Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))", "Power", 24)] + [Arguments("Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)", "Resistance", 4)] + [Arguments("Current.FromAmps(3) * Time.FromSeconds(2)", "TimeCurrent", 6)] + [Arguments("(Current.FromAmps(2) * Time.FromSeconds(3)) / Time.FromSeconds(3)", "Current", 2)] + [Arguments("(Voltage.FromSiBaseUnit(4) * Current.FromAmps(3)) / Current.FromAmps(2)", "Voltage", 6)] + [Arguments("Current.FromAmps(3) * 2d", "Current", 6)] + [Arguments("2 * Current.FromAmps(3)", "Current", 6)] + [Arguments("Current.FromAmps(6) / 2f", "Current", 3)] + [Arguments("2d / Time.FromSeconds(4)", "Frequency", 0.5)] + [Arguments("2f / Current.FromAmps(4)", "InverseCurrent", 0.5)] + [Arguments("(2 / Current.FromAmps(4)) * Time.FromSeconds(3)", "TimePerCurrent", 1.5)] + [Arguments("(Current.FromAmps(2) * 2) * Current.FromAmps(3)", "CurrentSquared", 12)] + [Arguments("2 * (Current.FromAmps(2) * Current.FromAmps(3))", "CurrentSquared", 12)] + [Arguments("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] + [Arguments("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] + [Arguments("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] public async Task QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) { string expression = $"(({resultType})({arithmetic})).AsSiBaseUnit()"; double result = await Evaluate(expression); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] + [Test] public async Task QuantityArithmeticAcceptsTypedMethodParametersAndReturns() { const string source = """ @@ -135,7 +138,7 @@ public static class Consumer await Compile(source); } - [Fact] + [Test] public async Task RepeatedConsumerOperationIsEmittedOnce() { const string source = """ @@ -147,11 +150,11 @@ public static class Consumer """; CSharpCompilation compilation = await Compile(source); INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")!; - Assert.Single(extensions.GetMembers().OfType(), method => method.MetadataName == "op_Multiply"); + await Assert.That(extensions.GetMembers().OfType()).HasSingleItem(method => method.MetadataName == "op_Multiply"); } - [Fact] + [Test] public async Task ArithmeticReadsFieldAndMethodReturnTypes() { const string source = """ @@ -165,7 +168,7 @@ public static class Consumer await Compile(source); } - [Fact] + [Test] public async Task DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() { const string source = """ @@ -176,11 +179,11 @@ public static class Consumer """; CSharpCompilation compilation = await Compile(source); - Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); + await Assert.That(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); } - [Fact] - public void GeneratorRefreshesArithmeticAfterAddingEditingAndRemovingConsumerTrees() + [Test] + public async Task GeneratorRefreshesArithmeticAfterAddingEditingAndRemovingConsumerTrees() { const string firstSource = """ public static class Consumer @@ -201,30 +204,34 @@ public static class Consumer } """; CSharpCompilation initialInput = CreateInputCompilation(firstSource); - SyntaxTree initialTree = Assert.Single(initialInput.SyntaxTrees); - SyntaxTree addedTree = CSharpSyntaxTree.ParseText(addedSource, _parseOptions, path: "Added.cs", cancellationToken: TestContext.Current.CancellationToken); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree initialTree = (await Assert.That(initialInput.SyntaxTrees).HasSingleItem()); + SyntaxTree addedTree = CSharpSyntaxTree.ParseText(addedSource, _parseOptions, path: "Added.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); + SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); driver = driver.RunGeneratorsAndUpdateCompilation(initialInput, out Compilation firstOutput, out ImmutableArray firstDiagnostics, - TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(firstDiagnostics), - () => Assert.Empty(firstOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.NotNull(firstOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(firstDiagnostics).IsEmpty(); + await Assert.That(firstOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(firstOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); + } CSharpCompilation addedInput = initialInput.AddSyntaxTrees(addedTree); driver = driver.RunGeneratorsAndUpdateCompilation(addedInput, out Compilation addedOutput, out ImmutableArray addedDiagnostics, - TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(addedDiagnostics), - () => Assert.Empty(addedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); + TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(addedDiagnostics).IsEmpty(); + await Assert.That(addedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); + await Assert.That(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")).IsNotNull(); + } CSharpCompilation editedInput = addedInput.ReplaceSyntaxTree(initialTree, editedTree); driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, - TestContext.Current.CancellationToken); + TestContext.Current!.Execution.CancellationToken); Dimension length = new(Length: 1); Dimension time = new(Time: 1); Dimension lengthTime = new(Length: 1, Time: 1); @@ -234,38 +241,44 @@ public static class Consumer ArithmeticOperation addedOperation = new(ArithmeticOperationKind.Multiply, length, time, lengthTime); ArithmeticOperation editedOperation = new(ArithmeticOperationKind.Divide, voltage, current, resistance); ArithmeticOperation[] editedOperators = ReadOperators(editedOutput); - Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), - () => Assert.Equal(2, editedOperators.Length), - () => Assert.Contains(addedOperation, editedOperators), - () => Assert.Contains(editedOperation, editedOperators)); + using (Assert.Multiple()) + { + await Assert.That(editedDiagnostics).IsEmpty(); + await Assert.That(editedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")).IsNotNull(); + await Assert.That(editedOperators.Length).IsEqualTo(2); + await Assert.That(editedOperators).Contains(addedOperation); + await Assert.That(editedOperators).Contains(editedOperation); + } CSharpCompilation removedInput = editedInput.RemoveSyntaxTrees(addedTree); driver = driver.RunGeneratorsAndUpdateCompilation(removedInput, out Compilation removedOutput, out ImmutableArray removedDiagnostics, - TestContext.Current.CancellationToken); + TestContext.Current!.Execution.CancellationToken); ArithmeticOperation[] removedOperators = ReadOperators(removedOutput); - Assert.Multiple( - () => Assert.Empty(removedDiagnostics), - () => Assert.Empty(removedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), - () => Assert.Equal(editedOperation, Assert.Single(removedOperators))); + using (Assert.Multiple()) + { + await Assert.That(removedDiagnostics).IsEmpty(); + await Assert.That(removedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")).IsNull(); + await Assert.That((await Assert.That(removedOperators).HasSingleItem())).IsEqualTo(editedOperation); + } CSharpCompilation emptyInput = removedInput.RemoveSyntaxTrees(editedTree); driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation emptyOutput, out ImmutableArray emptyDiagnostics, - TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(emptyDiagnostics), - () => Assert.Empty(emptyOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); + TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(emptyDiagnostics).IsEmpty(); + await Assert.That(emptyOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); + await Assert.That(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")).IsNull(); + } } - [Fact] + [Test] public async Task GeneratorIgnoresUnrelatedAndIncompleteArithmetic() { const string source = """ @@ -281,15 +294,15 @@ public static class Consumer }; test.TestState.Sources.Add(("Consumer.cs", source)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0103").WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); Compilation output = test.Compilation; - Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); + await Assert.That(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); } - [Fact] - public void LocalInitialiserEditsRefreshDependentOperatorsAndRemoveObsoleteOutput() + [Test] + public async Task LocalInitialiserEditsRefreshDependentOperatorsAndRemoveObsoleteOutput() { const string source = """ public static class Consumer @@ -310,9 +323,9 @@ public static class Consumer } """; CSharpCompilation input = CreateInputCompilation(source); - SyntaxTree originalTree = Assert.Single(input.SyntaxTrees); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - SyntaxTree removedTree = CSharpSyntaxTree.ParseText(removedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree originalTree = (await Assert.That(input.SyntaxTrees).HasSingleItem()); + SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); + SyntaxTree removedTree = CSharpSyntaxTree.ParseText(removedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); Dimension current = new(ElectricCurrent: 1); Dimension lengthCurrent = new(Length: 1, ElectricCurrent: 1); @@ -330,36 +343,42 @@ public static class Consumer new(ArithmeticOperationKind.Multiply, area, time, new(Length: 2, Time: 1)) ]; - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(originalDiagnostics), - () => Assert.Empty(originalOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Equal(originalExpected, ReadOperators(originalOutput))); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(originalDiagnostics).IsEmpty(); + await Assert.That(originalOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(ReadOperators(originalOutput)).IsEquivalentTo(originalExpected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + } CSharpCompilation editedInput = input.ReplaceSyntaxTree(originalTree, editedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Equal(editedExpected, ReadOperators(editedOutput)), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); + driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(editedDiagnostics).IsEmpty(); + await Assert.That(editedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(ReadOperators(editedOutput)).IsEquivalentTo(editedExpected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + } CSharpCompilation removedInput = editedInput.ReplaceSyntaxTree(editedTree, removedTree); - driver.RunGeneratorsAndUpdateCompilation(removedInput, out Compilation removedOutput, out ImmutableArray removedDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(removedDiagnostics), - () => Assert.Empty(removedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredTimeExtensions"))); + driver.RunGeneratorsAndUpdateCompilation(removedInput, out Compilation removedOutput, out ImmutableArray removedDiagnostics, TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(removedDiagnostics).IsEmpty(); + await Assert.That(removedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); + await Assert.That(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredTimeExtensions")).IsNull(); + } } - [Theory] - [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps", 2.5)] - [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] - [InlineData("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] - [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] + [Test] + [Arguments("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps", 2.5)] + [Arguments("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] + [Arguments("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] + [Arguments("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] public async Task SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) { string source = $$""" @@ -369,17 +388,19 @@ public static class Consumer } """; CSharpCompilation compilation = await Compile(source); - double result = EvaluateCompilation(compilation); + double result = await EvaluateCompilation(compilation); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")).IsNull(); + } } - [Theory] - [InlineData("firstSquared + secondSquared", 52)] - [InlineData("firstSquared - secondSquared", 20)] - [InlineData("-firstSquared", -36)] + [Test] + [Arguments("firstSquared + secondSquared", 52)] + [Arguments("firstSquared - secondSquared", 20)] + [Arguments("-firstSquared", -36)] public async Task SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) { string source = $$""" @@ -400,25 +421,25 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] - [InlineData("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] + [Test] + [Arguments("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] + [Arguments("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] + [Arguments("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] public async Task SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) { double result = await Evaluate(expression); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("current + length")] - [InlineData("current - length")] - [InlineData("current + 2")] - [InlineData("2 - current")] + [Test] + [Arguments("current + length")] + [Arguments("current - length")] + [Arguments("current + 2")] + [Arguments("2 - current")] public async Task InvalidSameDimensionArithmeticRemainsACompilerError(string expression) { string source = $$""" @@ -433,34 +454,34 @@ public static class Consumer }; test.TestState.Sources.Add(("Consumer.cs", source)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0019").WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); - Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); + Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Equal("CS0019", Assert.Single(errors).Id); + await Assert.That((await Assert.That(errors).HasSingleItem()).Id).IsEqualTo("CS0019"); } - [Theory] - [InlineData("Length.FromMetres(3) / Length.FromMilliMetres(500)", 6)] - [InlineData("Energy.FromSiBaseUnit(6) / Torque.FromSiBaseUnit(2)", 3)] - [InlineData("Current.FromAmps(3) * (2 / Current.FromAmps(3))", 2)] - [InlineData("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] - [InlineData("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] - [InlineData("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] + [Test] + [Arguments("Length.FromMetres(3) / Length.FromMilliMetres(500)", 6)] + [Arguments("Energy.FromSiBaseUnit(6) / Torque.FromSiBaseUnit(2)", 3)] + [Arguments("Current.FromAmps(3) * (2 / Current.FromAmps(3))", 2)] + [Arguments("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] + [Arguments("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] + [Arguments("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] public async Task CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) { double result = await Evaluate(expression); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("var ratio = first / second;", "(ratio * time).AsSeconds()", 6)] - [InlineData("var firstSquared = first * first; var secondSquared = second * second; var ratio = firstSquared / secondSquared;", "(ratio * time).AsSeconds()", 9)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var copy = ratio;", "(copy * time).AsSeconds()", 8)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] - [InlineData("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] + [Test] + [Arguments("var ratio = first / second;", "(ratio * time).AsSeconds()", 6)] + [Arguments("var firstSquared = first * first; var secondSquared = second * second; var ratio = firstSquared / secondSquared;", "(ratio * time).AsSeconds()", 9)] + [Arguments("var inverse = 2 / first; var ratio = first * inverse; var copy = ratio;", "(copy * time).AsSeconds()", 8)] + [Arguments("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] + [Arguments("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] + [Arguments("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] public async Task CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) { string source = $$""" @@ -478,20 +499,20 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("TerminalHex2", 3, 9)] - [InlineData("TerminalHex3", 3, 27)] - [InlineData("TerminalHex1", 3, 3)] - [InlineData("Hex", 2, 65536)] - [InlineData("Negative", 2, 0.25)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", -8, -2)] - [InlineData("Fraction", -8, 4)] - [InlineData("Fraction, TerminalHex3>", -8, -0.5)] + [Test] + [Arguments("TerminalHex2", 3, 9)] + [Arguments("TerminalHex3", 3, 27)] + [Arguments("TerminalHex1", 3, 3)] + [Arguments("Hex", 2, 65536)] + [Arguments("Negative", 2, 0.25)] + [Arguments("Fraction", 9, 3)] + [Arguments("Fraction", 9, 3)] + [Arguments("Fraction", -8, -2)] + [Arguments("Fraction", -8, 4)] + [Arguments("Fraction, TerminalHex3>", -8, -0.5)] public async Task EncodedPowersCompileAndExecute(string exponent, double value, double expected) { string source = $$""" @@ -503,18 +524,18 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Theory] - [InlineData("NumberTwo", 3, 9)] - [InlineData("NumberSeventeen", 2, 131072)] - [InlineData("NumberMinusTwo", 2, 0.25)] - [InlineData("NumberHalf", 9, 3)] - [InlineData("NumberTwoQuarters", 9, 3)] - [InlineData("NumberTwoOverThree", -8, 4)] - [InlineData("NumberMinusOneOverThree", -8, -0.5)] - [InlineData("NumberMillionth", 1, 1)] + [Test] + [Arguments("NumberTwo", 3, 9)] + [Arguments("NumberSeventeen", 2, 131072)] + [Arguments("NumberMinusTwo", 2, 0.25)] + [Arguments("NumberHalf", 9, 3)] + [Arguments("NumberTwoQuarters", 9, 3)] + [Arguments("NumberTwoOverThree", -8, 4)] + [Arguments("NumberMinusOneOverThree", -8, -0.5)] + [Arguments("NumberMillionth", 1, 1)] public async Task EnglishPowersCompileAndExecute(string exponent, double value, double expected) { string source = $$""" @@ -526,10 +547,10 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] + [Test] public async Task GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() { CSharpCompilation unused = await Compile(""" @@ -545,23 +566,25 @@ class Consumer } """; CSharpCompilation used = await Compile(source); - string[] unusedNames = unused.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + string[] unusedNames = unused.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - string[] usedNames = used.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + string[] usedNames = used.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); string[] result = usedNames.Except(unusedNames).ToArray(); string[] expected = ["NumberTwo"]; - Assert.Multiple( - () => Assert.DoesNotContain("NumberTwo", unusedNames), - () => Assert.DoesNotContain("NumberHalf", unusedNames), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(unusedNames).DoesNotContain("NumberTwo"); + await Assert.That(unusedNames).DoesNotContain("NumberHalf"); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); + } } - [Theory] - [InlineData("typeof(NumberTwo)")] - [InlineData("Power.Other(value)")] - [InlineData("Other.Power.Of(value)")] + [Test] + [Arguments("typeof(NumberTwo)")] + [Arguments("Power.Other(value)")] + [Arguments("Other.Power.Of(value)")] public async Task EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) { string markedExpression = expression.Replace("NumberTwo", "{|#0:NumberTwo|}", StringComparison.Ordinal) @@ -590,18 +613,20 @@ class Consumer { test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0117").WithLocation(1)); } - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); Compilation output = test.Compilation; - string[] aliases = output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + string[] aliases = output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - Assert.Multiple( - () => Assert.DoesNotContain("NumberTwo", aliases), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))); + using (Assert.Multiple()) + { + await Assert.That(aliases).DoesNotContain("NumberTwo"); + await Assert.That(output.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Any(diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))).IsTrue(); + } } - [Fact] - public void RemovingEnglishPowerCallsRemovesTheirAliases() + [Test] + public async Task RemovingEnglishPowerCallsRemovesTheirAliases() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -612,22 +637,24 @@ class Consumer """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current!.Execution.CancellationToken); CSharpCompilation emptyInput = input.RemoveAllSyntaxTrees(); - driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation removed, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - string[] originalNames = original.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation removed, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); + string[] originalNames = original.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - string[] remainingNames = removed.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + string[] remainingNames = removed.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - Assert.Multiple( - () => Assert.Contains("NumberTwo", originalNames), - () => Assert.DoesNotContain("NumberTwo", remainingNames), - () => Assert.Empty(diagnostics), - () => Assert.Empty(removed.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error))); + using (Assert.Multiple()) + { + await Assert.That(originalNames).Contains("NumberTwo"); + await Assert.That(remainingNames).DoesNotContain("NumberTwo"); + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(removed.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + } } - [Fact] + [Test] public async Task EnglishPowersWorkWithNestedCallsArithmeticAndLocals() { const string source = """ @@ -646,10 +673,10 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(15, result); + await Assert.That(result).IsEqualTo(15); } - [Fact] + [Test] public async Task EnglishLookingUserAliasKeepsItsDeclaredExponent() { const string source = """ @@ -662,10 +689,10 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(27, result); + await Assert.That(result).IsEqualTo(27); } - [Fact] + [Test] public async Task ExplicitAliasInAnotherFileReservesTheName() { const string generatedAliasSource = """ @@ -691,18 +718,19 @@ class Second test.TestState.Sources.Add(("Second.cs", explicitAliasSource)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); Compilation output = test.Compilation; - Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + Diagnostic[] errors = output.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal)), - () => Assert.DoesNotContain(errors, diagnostic => diagnostic.Location.SourceTree?.FilePath == "Second.cs"), - () => Assert.DoesNotContain(output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings), - directive => directive.Alias?.Name.Identifier.ValueText == "NumberTwo" && directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword))); + using (Assert.Multiple()) + { + await Assert.That(errors.Any(diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))).IsTrue(); + await Assert.That(errors.Any(diagnostic => diagnostic.Location.SourceTree?.FilePath == "Second.cs")).IsFalse(); + await Assert.That(output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current!.Execution.CancellationToken).Usings).Any(directive => directive.Alias?.Name.Identifier.ValueText == "NumberTwo" && directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword))).IsFalse(); + } } - [Fact] + [Test] public async Task EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() { const string source = """ @@ -720,10 +748,10 @@ public static bool Value() } """; - Assert.True(await EvaluateSource(source)); + await Assert.That(await EvaluateSource(source)).IsTrue(); } - [Fact] + [Test] public async Task EnglishZerothPowerReturnsDouble() { const string source = """ @@ -734,10 +762,10 @@ public static class Consumer } """; - Assert.Equal(1, await EvaluateSource(source)); + await Assert.That(await EvaluateSource(source)).IsEqualTo(1); } - [Fact] + [Test] public async Task PowersReturnExistingQuantityTypesWhenCalledThroughAliases() { const string source = """ @@ -762,16 +790,16 @@ public static double Value() double result = await EvaluateSource(source); double expected = 51; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData("var squared = Power.Of(current); var result = squared * resistance;", "((Power)result).AsSiBaseUnit()", 36)] - [InlineData("var squared = current * current; var result = Power>.Of(squared);", "((Current)result).AsAmps()", 3)] - [InlineData("var squared = Power.Of(current); var copy = squared; var result = Power>.Of(copy);", "((Current)result).AsAmps()", 3)] - [InlineData("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] - [InlineData("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] - [InlineData("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] + [Test] + [Arguments("var squared = Power.Of(current); var result = squared * resistance;", "((Power)result).AsSiBaseUnit()", 36)] + [Arguments("var squared = current * current; var result = Power>.Of(squared);", "((Current)result).AsAmps()", 3)] + [Arguments("var squared = Power.Of(current); var copy = squared; var result = Power>.Of(copy);", "((Current)result).AsAmps()", 3)] + [Arguments("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] + [Arguments("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] + [Arguments("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] public async Task PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) { string source = $$""" @@ -789,10 +817,10 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] + [Test] public async Task ZerothPowerReturnsDouble() { const string source = """ @@ -804,12 +832,12 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(1, result); + await Assert.That(result).IsEqualTo(1); } - [Theory] - [InlineData("Two")] - [InlineData("NumberNotANumber", "DQ0007")] + [Test] + [Arguments("Two")] + [Arguments("NumberNotANumber", "DQ0007")] public async Task UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) { string source = $$""" @@ -831,16 +859,15 @@ public static class Consumer } test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS1929").WithLocation(1)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); - Assert.Contains(test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken), - diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal)); + await Assert.That(test.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Any(diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal))).IsTrue(); } - [Theory] - [InlineData("TerminalHex2", "TerminalHex3")] - [InlineData("NumberTwo", "NumberThree")] - public void EditingAndRemovingPowerCallsRemovesObsoleteGeneratedTypes(string originalExponent, string editedExponent) + [Test] + [Arguments("TerminalHex2", "TerminalHex3")] + [Arguments("NumberTwo", "NumberThree")] + public async Task EditingAndRemovingPowerCallsRemovesObsoleteGeneratedTypes(string originalExponent, string editedExponent) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -851,42 +878,48 @@ public static class Consumer """; CSharpCompilation input = CreateInputCompilation(source); SyntaxTree originalTree = input.SyntaxTrees.Single(); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(source.Replace(originalExponent, editedExponent, StringComparison.Ordinal), _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree editedTree = CSharpSyntaxTree.ParseText(source.Replace(originalExponent, editedExponent, StringComparison.Ordinal), _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(originalDiagnostics), - () => Assert.Empty(originalOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.NotNull(originalOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(originalDiagnostics).IsEmpty(); + await Assert.That(originalOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(originalOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")).IsNotNull(); + } CSharpCompilation editedInput = input.ReplaceSyntaxTree(originalTree, editedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")), - () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions"))); + driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(editedDiagnostics).IsEmpty(); + await Assert.That(editedOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")).IsNull(); + await Assert.That(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions")).IsNotNull(); + } CSharpCompilation emptyInput = editedInput.RemoveSyntaxTrees(editedTree); - driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation emptyOutput, out ImmutableArray emptyDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(emptyDiagnostics), - () => Assert.Empty(emptyOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions"))); - } - - [Theory] - [InlineData("Squared", 3, 9)] - [InlineData("Cubed", 3, 27)] - [InlineData("Pow4", 2, 16)] - [InlineData("Pow5", 2, 32)] - [InlineData("Pow6", 2, 64)] - [InlineData("SquareRoot", 9, 3)] - [InlineData("CubeRoot", 27, 3)] - [InlineData("Root4", 16, 2)] - [InlineData("Root5", 32, 2)] - [InlineData("Root6", 64, 2)] + driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation emptyOutput, out ImmutableArray emptyDiagnostics, TestContext.Current!.Execution.CancellationToken); + using (Assert.Multiple()) + { + await Assert.That(emptyDiagnostics).IsEmpty(); + await Assert.That(emptyOutput.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions")).IsNull(); + } + } + + [Test] + [Arguments("Squared", 3, 9)] + [Arguments("Cubed", 3, 27)] + [Arguments("Pow4", 2, 16)] + [Arguments("Pow5", 2, 32)] + [Arguments("Pow6", 2, 64)] + [Arguments("SquareRoot", 9, 3)] + [Arguments("CubeRoot", 27, 3)] + [Arguments("Root4", 16, 2)] + [Arguments("Root5", 32, 2)] + [Arguments("Root6", 64, 2)] public async Task ConveniencePowersCompileAndExecute(string method, double value, double expected) { string source = $$""" @@ -897,10 +930,10 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] + [Test] public async Task ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() { const string source = """ @@ -925,14 +958,14 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(57, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(57d, 12)); } - [Theory] - [InlineData("current.Squared().SquareRoot() * resistance", 12)] - [InlineData("Power.Of(current.Squared()) * resistance", 12)] - [InlineData("Power.Of(current).SquareRoot() * resistance", 12)] - [InlineData("(current * resistance).Squared().SquareRoot()", 12)] + [Test] + [Arguments("current.Squared().SquareRoot() * resistance", 12)] + [Arguments("Power.Of(current.Squared()) * resistance", 12)] + [Arguments("Power.Of(current).SquareRoot() * resistance", 12)] + [Arguments("(current * resistance).Squared().SquareRoot()", 12)] public async Task ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) { string source = $$""" @@ -950,10 +983,10 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] + [Test] public async Task GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() { const string source = """ @@ -968,20 +1001,23 @@ class Consumer string[] result = ReadConvenienceMethods(output, new(Length: 1, ElectricCurrent: 1)).Where(convenienceNames.Contains).ToArray(); string[] expected = ["Squared"]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() { CSharpCompilation result = await Compile(string.Empty); string[] expected = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); - Assert.All(dimensions, dimension => Assert.Equal(expected.Order(), ReadConvenienceMethods(result, dimension).Where(expected.Contains).Order())); + foreach (Dimension dimension in dimensions) + { + await Assert.That(ReadConvenienceMethods(result, dimension).Where(expected.Contains).Order()).IsEquivalentTo(expected.Order(), TUnit.Assertions.Enums.CollectionOrdering.Matching); + } } - [Fact] + [Test] public async Task InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() { const string source = """ @@ -997,10 +1033,10 @@ public static double Value() """; double result = await EvaluateSource(source); - Assert.Equal(81, result); + await Assert.That(result).IsEqualTo(81); } - [Fact] + [Test] public async Task CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() { const string source = """ @@ -1014,15 +1050,15 @@ public static class Consumer TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck }; test.TestState.Sources.Add(("Consumer.cs", source)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); Compilation result = test.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; - IFieldSymbol resolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); + IFieldSymbol resolved = (await Assert.That(await Assert.That(probe.GetMembers("FactoryResolved")).HasSingleItem()).IsAssignableTo())!; - Assert.Equal(true, resolved.ConstantValue); + await Assert.That(resolved.ConstantValue is true).IsTrue(); } - [Fact] + [Test] public async Task ExistingQuantityExtensionMethodKeepsItsBehaviour() { const string source = """ @@ -1037,10 +1073,10 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(42, result); + await Assert.That(result).IsEqualTo(42); } - [Fact] + [Test] public async Task ConvenienceMethodCoexistsWithAnExistingOverload() { const string source = """ @@ -1060,12 +1096,12 @@ public static double[] Value() double[] result = await EvaluateSource(source); double[] expected = [9, 12]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Theory] - [InlineData("(3d).Squared()", "CS1929")] - [InlineData("Length.FromMetres(3).Pow7()", "CS1061")] + [Test] + [Arguments("(3d).Squared()", "CS1929")] + [Arguments("Length.FromMetres(3).Pow7()", "CS1061")] public async Task UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) { string markedExpression = expression == "(3d).Squared()" @@ -1083,13 +1119,13 @@ class Consumer }; test.TestState.Sources.Add(("Consumer.cs", source)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError(diagnosticId).WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); - Assert.Contains(test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId); + await Assert.That(test.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Any(diagnostic => diagnostic.Id == diagnosticId)).IsTrue(); } - [Fact] - public void RemovingIntermediateConvenienceCallsRemovesTheirGeneratedMethods() + [Test] + public async Task RemovingIntermediateConvenienceCallsRemovesTheirGeneratedMethods() { const string source = """ class Consumer @@ -1099,20 +1135,22 @@ class Consumer """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation removed, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current!.Execution.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation removed, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); string[] originalMethods = ReadConvenienceMethods(original, new(Length: 1, ElectricCurrent: 1)); string[] remainingMethods = ReadConvenienceMethods(removed, new(Length: 1, ElectricCurrent: 1)); - Assert.Multiple( - () => Assert.Contains("Squared", originalMethods), - () => Assert.DoesNotContain("Squared", remainingMethods), - () => Assert.Empty(diagnostics)); + using (Assert.Multiple()) + { + await Assert.That(originalMethods).Contains("Squared"); + await Assert.That(remainingMethods).DoesNotContain("Squared"); + await Assert.That(diagnostics).IsEmpty(); + } } - [Fact] - public void EditingExplicitLocalUpdatesItsDependentArithmetic() + [Test] + public async Task EditingExplicitLocalUpdatesItsDependentArithmetic() { const string source = """ class Consumer @@ -1127,21 +1165,23 @@ object Value(Length length, Current current, Time time) string edited = source.Replace("LengthCurrent value = length * current", "LengthTime value = length * time", StringComparison.Ordinal); CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - CSharpCompilation changed = input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken)); - driver.RunGeneratorsAndUpdateCompilation(changed, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current!.Execution.CancellationToken); + CSharpCompilation changed = input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken)); + driver.RunGeneratorsAndUpdateCompilation(changed, out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions")).IsNotNull(); + } } - [Fact] - public void EditingConditionalBranchesRemovesObsoleteDependentOperations() + [Test] + public async Task EditingConditionalBranchesRemovesObsoleteDependentOperations() { const string source = """ class Consumer @@ -1156,20 +1196,22 @@ object Value(bool choose, Length length, Current current, Time time) string edited = source.Replace("length * current", "length * time", StringComparison.Ordinal); CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current!.Execution.CancellationToken); + SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions")).IsNotNull(); + } } - [Fact] - public void EditingMemberDefinitionRemovesObsoleteDependentOperations() + [Test] + public async Task EditingMemberDefinitionRemovesObsoleteDependentOperations() { const string source = """ class Inputs @@ -1184,23 +1226,25 @@ class Consumer } """; string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current!.Execution.CancellationToken); + SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions")).IsNotNull(); + } } - [Fact] - public void EditingMethodDefinitionRefreshesUnchangedConsumers() + [Test] + public async Task EditingMethodDefinitionRefreshesUnchangedConsumers() { const string source = """ class Inputs @@ -1215,23 +1259,25 @@ class Consumer } """; string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); + SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current!.Execution.CancellationToken); + SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current!.Execution.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")).IsNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions")).IsNotNull(); + } } - [Theory] - [InlineData(false, 216)] - [InlineData(true, 72)] + [Test] + [Arguments(false, 216)] + [Arguments(true, 72)] public async Task WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) { string source = $$""" @@ -1262,13 +1308,15 @@ public static double[] Value() """; double[] result = await EvaluateSource(source); - Assert.Multiple( - () => Assert.Equal(expectedLoss, result[0], 12), - () => Assert.Equal(0.5, result[1], 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(result[0], 12)).IsEqualTo(Math.Round(expectedLoss, 12)); + await Assert.That(Math.Round(result[1], 12)).IsEqualTo(Math.Round(0.5, 12)); + } } - [Fact] + [Test] public async Task TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() { const string source = """ @@ -1284,10 +1332,10 @@ public class Consumer """; CSharpCompilation result = await Compile(source); - Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); } - [Fact] + [Test] public async Task TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() { const string source = """ @@ -1299,17 +1347,17 @@ public static class Consumer """; double result = await EvaluateSource(source); - Assert.Equal(24, result); + await Assert.That(result).IsEqualTo(24); } - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public class LengthCurrent { } """)] - [InlineData(""" + [Arguments(""" using LengthCurrent = System.Int32; """)] public async Task ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) @@ -1323,10 +1371,10 @@ class Consumer """; CSharpCompilation result = await Compile(source); - Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); } - [Fact] + [Test] public async Task QuantityLookingVariableNamesDoNotRequestTypes() { const string source = """ @@ -1341,10 +1389,10 @@ int Value() """; CSharpCompilation result = await Compile(source); - Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); } - [Fact] + [Test] public async Task TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() { const string source = """ @@ -1367,16 +1415,18 @@ class Second test.TestState.Sources.Add(("Consumer.cs", source)); test.TestState.Sources.Add(("Alias.cs", aliasSource)); test.ExpectedDiagnostics.Add(DiagnosticResult.CompilerError("CS0246").WithLocation(0)); - await test.RunAsync(TestContext.Current.CancellationToken); - Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); + Diagnostic[] errors = test.Compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.Contains(errors, error => error.Id == "CS0246" && error.Location.SourceTree?.FilePath == "Consumer.cs"), - () => Assert.DoesNotContain(errors, error => error.Location.SourceTree?.FilePath == "Alias.cs")); + using (Assert.Multiple()) + { + await Assert.That(errors.Any(error => error.Id == "CS0246" && error.Location.SourceTree?.FilePath == "Consumer.cs")).IsTrue(); + await Assert.That(errors.Any(error => error.Location.SourceTree?.FilePath == "Alias.cs")).IsFalse(); + } } - [Fact] - public void RemovingTypeOnlyDeclarationsRemovesTheirQuantities() + [Test] + public async Task RemovingTypeOnlyDeclarationsRemovesTheirQuantities() { const string source = """ class Consumer @@ -1386,21 +1436,23 @@ class Consumer """; CSharpCompilation input = CreateInputCompilation(source); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current!.Execution.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.NotNull(original.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Empty(diagnostics)); + using (Assert.Multiple()) + { + await Assert.That(original.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); + await Assert.That(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(diagnostics).IsEmpty(); + } } - [Theory] - [InlineData("Library.Create()")] - [InlineData("Library.Field")] - [InlineData("Library.Property")] - [InlineData("Library.Values()[0]")] - [InlineData("Library.Measure().Value")] + [Test] + [Arguments("Library.Create()")] + [Arguments("Library.Field")] + [Arguments("Library.Property")] + [Arguments("Library.Values()[0]")] + [Arguments("Library.Measure().Value")] public async Task ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1424,10 +1476,10 @@ public class Consumer } """, library); - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); } - [Fact] + [Test] public async Task ReferencedCollectionTypesRequestTheirNestedQuantity() { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1443,10 +1495,10 @@ public class Consumer } """, library); - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); } - [Fact] + [Test] public async Task RemovingMetadataUsageRemovesItsLocallyGeneratedConversions() { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1462,17 +1514,19 @@ public class Consumer } """).AddReferences(library); GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); + driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current!.Execution.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current!.Execution.CancellationToken); - Assert.Multiple( - () => Assert.NotNull(original.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Empty(diagnostics)); + using (Assert.Multiple()) + { + await Assert.That(original.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNotNull(); + await Assert.That(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); + await Assert.That(diagnostics).IsEmpty(); + } } - [Fact] + [Test] public async Task ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1491,10 +1545,10 @@ public class Consumer } """, library); - Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + await Assert.That(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")).IsNull(); } - [Fact] + [Test] public async Task MetadataDiscoveryPreservesExplicitConsumerAliases() { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1513,8 +1567,8 @@ public class Consumer """, library); } - [Theory] - [InlineData(""" + [Test] + [Arguments(""" public class LengthCurrent { public int Marker @@ -1524,7 +1578,7 @@ public int Marker } } """, "LengthCurrent", "new() { Marker = 7 }")] - [InlineData(""" + [Arguments(""" namespace LengthCurrent { public class Item @@ -1551,7 +1605,7 @@ public class Consumer await Compile(source, library); } - [Fact] + [Test] public async Task ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() { PortableExecutableReference library = await CreateLibraryReference(""" @@ -1568,14 +1622,14 @@ public static class Consumer """; CSharpCompilation result = await Compile(source, library); - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")); + await Assert.That(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")).IsNotNull(); } private static async Task CreateLibraryReference(string source) { CSharpCompilation library = (await Compile(source)).WithAssemblyName("ReferencedQuantities"); using MemoryStream stream = new(); - EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!emitted.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); @@ -1586,9 +1640,9 @@ private static async Task CreateLibraryReference(st private static string[] ReadConvenienceMethods(Compilation compilation, Dimension dimension) { QuantityTypeReader reader = new(compilation); - return compilation.SyntaxTrees.SelectMany(tree => tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType()) + return compilation.SyntaxTrees.SelectMany(tree => tree.GetRoot(TestContext.Current!.Execution.CancellationToken).DescendantNodes().OfType()) .Where(block => block.ParameterList is { Parameters.Count: 1 } parameters && parameters.Parameters[0].Type is { } type - && reader.TryRead(compilation.GetSemanticModel(block.SyntaxTree).GetTypeInfo(type).Type, out Dimension receiver, TestContext.Current.CancellationToken) + && reader.TryRead(compilation.GetSemanticModel(block.SyntaxTree).GetTypeInfo(type).Type, out Dimension receiver, TestContext.Current!.Execution.CancellationToken) && receiver == dimension) .SelectMany(block => block.Members.OfType()) .Where(method => method.ParameterList.Parameters.Count == 0 && !method.Modifiers.Any(SyntaxKind.StaticKeyword)) @@ -1609,20 +1663,22 @@ public static class Consumer private static async Task EvaluateSource(string source) { CSharpCompilation compilation = await Compile(source); - return EvaluateCompilation(compilation); + return await EvaluateCompilation(compilation); } - private static T EvaluateCompilation(Compilation compilation) + private static async Task EvaluateCompilation(Compilation compilation) { using MemoryStream assemblyBytes = new(); - EmitResult emitResult = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emitResult = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!emitResult.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitResult.Diagnostics)); } Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; - return Assert.IsType(method.Invoke(null, null)); + object? value = method.Invoke(null, null); + await Assert.That(value?.GetType()).IsEqualTo(typeof(T)); + return (T)value!; } private static async Task Compile(string source, params MetadataReference[] references) @@ -1634,7 +1690,7 @@ private static async Task Compile(string source, params Metad }; test.TestState.Sources.Add(("Consumer.cs", source)); test.TestState.AdditionalReferences.AddRange(references); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); return (CSharpCompilation)test.Compilation; } @@ -1703,9 +1759,9 @@ private static ArithmeticOperation[] ReadOperators(Compilation compilation) .Where(method => method.MetadataName is "op_Multiply" or "op_Division") .Select(method => { - if (!reader.TryRead(method.Parameters[0].Type, out Dimension left, TestContext.Current.CancellationToken) - || !reader.TryRead(method.Parameters[1].Type, out Dimension right, TestContext.Current.CancellationToken) - || !reader.TryRead(method.ReturnType, out Dimension result, TestContext.Current.CancellationToken)) + if (!reader.TryRead(method.Parameters[0].Type, out Dimension left, TestContext.Current!.Execution.CancellationToken) + || !reader.TryRead(method.Parameters[1].Type, out Dimension right, TestContext.Current!.Execution.CancellationToken) + || !reader.TryRead(method.ReturnType, out Dimension result, TestContext.Current!.Execution.CancellationToken)) { throw new InvalidOperationException("Generated operator has an unreadable quantity signature."); } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs index d18a506..9a4652c 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs @@ -1,4 +1,5 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Discovery; using DimensionalQuantities.Roslyn.Generators; @@ -6,23 +7,23 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(QuantitySourceEmitterTests))] public sealed class QuantitySourceEmitterTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - [Fact] - public void StandaloneTemperatureUsesTheDimensionAlias() + [Test] + public async Task StandaloneTemperatureUsesTheDimensionAlias() { string source = QuantitySourceEmitter.Emit(QuantityDiscovery.Discover([]).KnownQuantities); - Assert.Contains("global using Temperature =", source); + await Assert.That(source).Contains("global using Temperature ="); } - [Fact] - public void DiscoveredMechanicalQuantityUsesItsGenericPrefixConversion() + [Test] + public async Task DiscoveredMechanicalQuantityUsesItsGenericPrefixConversion() { Dimension mass = new(Mass: 1); Dimension massSquared = new(Mass: 2); @@ -33,11 +34,11 @@ public void DiscoveredMechanicalQuantityUsesItsGenericPrefixConversion() Type consumer = assembly.GetType("Consumer")!; double result = (double)consumer.GetMethod("Value")!.Invoke(null, null)!; - Assert.Equal(0.000002, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(0.000002, 12)); } - [Fact] - public void DiscoveredQuantityOnlyHasGenericPrefixConversions() + [Test] + public async Task DiscoveredQuantityOnlyHasGenericPrefixConversions() { Dimension current = new(ElectricCurrent: 1); Dimension currentSquared = new(ElectricCurrent: 2); @@ -47,31 +48,33 @@ public void DiscoveredQuantityOnlyHasGenericPrefixConversions() INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.CurrentSquaredExtensions")!; string[] methods = extensions.GetMembers().OfType().Select(method => method.Name).ToArray(); - Assert.Multiple( - () => Assert.Contains("FromPrefixedUnits", methods), - () => Assert.Contains("AsPrefixedUnits", methods), - () => Assert.DoesNotContain(methods, method => method.StartsWith("FromSquare", StringComparison.Ordinal)), - () => Assert.DoesNotContain(methods, method => method.StartsWith("AsSquare", StringComparison.Ordinal))); + using (Assert.Multiple()) + { + await Assert.That(methods).Contains("FromPrefixedUnits"); + await Assert.That(methods).Contains("AsPrefixedUnits"); + await Assert.That(methods.Any(method => method.StartsWith("FromSquare", StringComparison.Ordinal))).IsFalse(); + await Assert.That(methods.Any(method => method.StartsWith("AsSquare", StringComparison.Ordinal))).IsFalse(); + } } - [Fact] - public void VoltageAndMechanicalAliasAreTheSameType() + [Test] + public async Task VoltageAndMechanicalAliasAreTheSameType() { const string expression = "typeof(Voltage) == typeof(LengthSquaredMassPerTimeCubedCurrent)"; bool result = Evaluate(expression); - Assert.True(result); + await Assert.That(result).IsTrue(); } - [Theory] - [InlineData("Area", "LengthSquared")] - [InlineData("CurrentDensity", "CurrentPerLengthSquared")] - [InlineData("Pressure", "Stress")] - [InlineData("Pressure", "YoungsModulus")] - [InlineData("Energy", "Torque")] - public void CatalogueAliasesShareTheCanonicalDimensionType(string alias, string equivalent) + [Test] + [Arguments("Area", "LengthSquared")] + [Arguments("CurrentDensity", "CurrentPerLengthSquared")] + [Arguments("Pressure", "Stress")] + [Arguments("Pressure", "YoungsModulus")] + [Arguments("Energy", "Torque")] + public async Task CatalogueAliasesShareTheCanonicalDimensionType(string alias, string equivalent) { bool result = Evaluate($"typeof({alias}) == typeof({equivalent})"); - Assert.True(result); + await Assert.That(result).IsTrue(); } private static T Evaluate(string expression) @@ -94,7 +97,7 @@ private static CSharpCompilation Compile(string source) _parseOptions, path: "KnownQuantities.g.cs"); CSharpCompilation compilation = CreateInputCompilation(source).AddSyntaxTrees(generated); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) + Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); if (errors.Length != 0) { @@ -108,7 +111,7 @@ private static Assembly CompileAndEmit(string source, IReadOnlyList diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); if (errors.Length != 0) { @@ -116,7 +119,7 @@ private static Assembly CompileAndEmit(string source, IReadOnlyList diagnostic.ToString()))); diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs index a1b0d98..d326a9f 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs @@ -1,4 +1,5 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Generators; using DimensionalQuantities.TypeSystem; @@ -6,10 +7,10 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(UnitConversionSourceEmitterTests))] public sealed class UnitConversionSourceEmitterTests { private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); @@ -24,8 +25,8 @@ public sealed class UnitConversionSourceEmitterTests "Deci", "Centi", "Milli", "Micro", "Nano", "Pico", "Femto", "Atto", "Zepto", "Yocto", "Ronto", "Quecto" ]; - [Fact] - public void EverySiPrefixHasUsableFactoryAndAccessor() + [Test] + public async Task EverySiPrefixHasUsableFactoryAndAccessor() { string calls = string.Join("\n", _prefixes.Select(prefix => $"Length value{prefix} = Length.From{prefix}Metres(1); double output{prefix} = value{prefix}.As{prefix}Metres();")); @@ -40,17 +41,17 @@ public static void UsePrefixes() """; CSharpCompilation compilation = Compile(source); - Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)); + await Assert.That(compilation.GetDiagnostics(TestContext.Current!.Execution.CancellationToken) + .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)).IsEmpty(); } - [Theory] - [InlineData("Length.FromMilliMetres(2500).AsSiBaseUnit()", 2.5)] - [InlineData("Mass.FromKiloGrams(2.5).AsSiBaseUnit()", 2.5)] - [InlineData("Mass.FromPrefixedUnits(2).AsSiBaseUnit()", 2)] - [InlineData("Mass.FromSiBaseUnit(1).AsPrefixedUnits(gramPrefixExponent: 0)", 1000)] - [InlineData("Length.FromMilliMetres(2500).AsDelta().AsMilliMetres()", 2500)] - public void BaseUnitPrefixesKeepTheirSiScales(string expression, double expected) + [Test] + [Arguments("Length.FromMilliMetres(2500).AsSiBaseUnit()", 2.5)] + [Arguments("Mass.FromKiloGrams(2.5).AsSiBaseUnit()", 2.5)] + [Arguments("Mass.FromPrefixedUnits(2).AsSiBaseUnit()", 2)] + [Arguments("Mass.FromSiBaseUnit(1).AsPrefixedUnits(gramPrefixExponent: 0)", 1000)] + [Arguments("Length.FromMilliMetres(2500).AsDelta().AsMilliMetres()", 2500)] + public async Task BaseUnitPrefixesKeepTheirSiScales(string expression, double expected) { string source = $$""" public static class Consumer @@ -60,7 +61,7 @@ public static class Consumer """; CSharpCompilation compilation = Compile(source); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!emit.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emit.Diagnostics.Select(diagnostic => diagnostic.ToString()))); @@ -69,11 +70,11 @@ public static class Consumer Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; double result = (double)method.Invoke(null, null)!; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void AffineReadingsAndScaleOnlyDeltasUseTheirOwnConversionRules() + [Test] + public async Task AffineReadingsAndScaleOnlyDeltasUseTheirOwnConversionRules() { AtomicUnit celsius = new("Celsius", "Celsius", "°C"); AtomicUnit rankine = new("Rankine", "Rankine", "°R", Scale: 5d / 9d); @@ -100,18 +101,20 @@ public static class Consumer } """, units); using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); + EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current!.Execution.CancellationToken); + await Assert.That(emit.Success).IsTrue().Because(string.Join(Environment.NewLine, emit.Diagnostics)); Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); Type consumer = assembly.GetType("Consumer")!; - Assert.Multiple( - () => Assert.Equal(20, Invoke(consumer, "AbsoluteCelsius"), 10), - () => Assert.Equal(20, Invoke(consumer, "AbsoluteFahrenheit"), 10), - () => Assert.Equal(10, Invoke(consumer, "DifferenceCelsius"), 10), - () => Assert.Equal(18, Invoke(consumer, "DifferenceFahrenheit"), 10), - () => Assert.Equal(18, Invoke(consumer, "DifferenceRankine"), 10), - () => Assert.Equal(0, Invoke(consumer, "ZeroDifference"), 10), - () => Assert.Equal(-18, Invoke(consumer, "NegativeDifference"), 10)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(Invoke(consumer, "AbsoluteCelsius"), 10)).IsEqualTo(Math.Round(20d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "AbsoluteFahrenheit"), 10)).IsEqualTo(Math.Round(20d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "DifferenceCelsius"), 10)).IsEqualTo(Math.Round(10d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "DifferenceFahrenheit"), 10)).IsEqualTo(Math.Round(18d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "DifferenceRankine"), 10)).IsEqualTo(Math.Round(18d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "ZeroDifference"), 10)).IsEqualTo(Math.Round(0d, 10)); + await Assert.That(Math.Round(Invoke(consumer, "NegativeDifference"), 10)).IsEqualTo(Math.Round(-18d, 10)); + } } private static double Invoke(Type consumer, string method) => (double)consumer.GetMethod(method)!.Invoke(null, null)!; diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs index c0d58be..0139836 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs @@ -1,12 +1,13 @@ using System.Reflection; +using Assembly = System.Reflection.Assembly; using DimensionalQuantities.Roslyn.Tests.Framework; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Emit; using Microsoft.CodeAnalysis.Testing; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(UnitProviderGenerationTests))] public sealed class UnitProviderGenerationTests { private const string FootProvider = """ @@ -25,7 +26,7 @@ private sealed class Foot; } """; - [Fact] + [Test] public async Task IndependentProviderGeneratesScaledFactoriesAndAccessors() { const string consumer = """ @@ -42,14 +43,16 @@ public static class Consumer test.TestState.Sources.Add(FootProvider); test.TestState.Sources.Add(consumer); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(3.048, result[0], 12), - () => Assert.Equal(2, result[1], 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(result[0], 12)).IsEqualTo(Math.Round(3.048, 12)); + await Assert.That(Math.Round(result[1], 12)).IsEqualTo(Math.Round(2d, 12)); + } } - [Fact] + [Test] public async Task AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() { const string source = """ @@ -80,11 +83,11 @@ public static double[] Values() }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); - Assert.Equal([16d, 3d, 1d], Evaluate(test.Compilation, "Consumer")); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); + await Assert.That(Evaluate(test.Compilation, "Consumer")).IsEquivalentTo([16d, 3d, 1d], TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task ProviderConversionsArePublicAndNotRegeneratedByConsumers() { QuantityGeneratorTest provider = new() @@ -93,7 +96,7 @@ public async Task ProviderConversionsArePublicAndNotRegeneratedByConsumers() TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck }; provider.SolutionTransforms.Add((solution, project) => solution.WithProjectAssemblyName(project, "Independent.Provider")); - await provider.RunAsync(TestContext.Current.CancellationToken); + await provider.RunAsync(TestContext.Current!.Execution.CancellationToken); MetadataReference reference = MetadataReference.CreateFromImage(Emit(provider.Compilation)); const string consumer = """ using Independent.Units; @@ -109,14 +112,14 @@ public static class Consumer }; test.TestState.AdditionalReferences.Add(reference); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); INamespaceSymbol? localNamespace = test.Compilation.Assembly.GlobalNamespace.GetNamespaceMembers() .SingleOrDefault(symbol => symbol.Name == "Independent"); - Assert.Null(localNamespace); + await Assert.That(localNamespace).IsNull(); } - [Fact] + [Test] public async Task ProviderCanOptIntoNamedAndParameterisedSiPrefixes() { const string source = """ @@ -143,12 +146,12 @@ public static double[] Values() => [Voltage.FromMilliSparks(500).AsSiBaseUnit(), }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Equal([0.5, 2, 3000, 4], result); + await Assert.That(result).IsEquivalentTo([0.5, 2, 3000, 4], TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task CompoundFactorsPreserveOrderPowersAndAdditionalConversions() { const string source = """ @@ -183,12 +186,12 @@ public static double[] Values() => [CurrentDensity.FromAmpsPerSquareMilliMetre(1 }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Equal([1000000d, 2000000d, 1d], result); + await Assert.That(result).IsEquivalentTo([1000000d, 2000000d, 1d], TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() { const string source = """ @@ -222,11 +225,11 @@ public static double[] Values() => }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); - Assert.Equal([2d, 2000000d, 0.002d, 0.002d], Evaluate(test.Compilation, "Independent.Units.Consumer")); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); + await Assert.That(Evaluate(test.Compilation, "Independent.Units.Consumer")).IsEquivalentTo([2d, 2000000d, 0.002d, 0.002d], TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task OneUnitDeclarationCanServeDistinctQuantityTypes() { const string source = """ @@ -254,11 +257,11 @@ public static double[] Values() => }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); - Assert.Equal([2d, 3d], Evaluate(test.Compilation, "Independent.Units.Consumer")); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); + await Assert.That(Evaluate(test.Compilation, "Independent.Units.Consumer")).IsEquivalentTo([2d, 3d], TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] + [Test] public async Task ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() { const string consumer = """ @@ -275,12 +278,12 @@ public static class Consumer test.TestState.Sources.Add(FootProvider); test.TestState.Sources.Add(consumer); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Equal(0.55741824, Assert.Single(result), 12); + await Assert.That(Math.Round((await Assert.That(result).HasSingleItem()), 12)).IsEqualTo(Math.Round(0.55741824, 12)); } - [Fact] + [Test] public async Task RecordClassProvidersGenerateConversions() { const string provider = """ @@ -310,14 +313,14 @@ public static class Consumer test.TestState.Sources.Add(provider); test.TestState.Sources.Add(consumer); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Equal(0.3048, Assert.Single(result), 12); + await Assert.That(Math.Round((await Assert.That(result).HasSingleItem()), 12)).IsEqualTo(Math.Round(0.3048, 12)); } - [Theory] - [InlineData("Bad name", "Feet")] - [InlineData("Foot", "Bad names")] + [Test] + [Arguments("Bad name", "Feet")] + [Arguments("Foot", "Bad names")] public async Task InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) { string source = $$""" @@ -340,10 +343,10 @@ private sealed class Foot; test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0008", DiagnosticSeverity.Error) .WithLocation(0).WithMessage("Unit provider for Length produces an invalid C# identifier.")); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); } - [Fact] + [Test] public async Task ProvidersInSameNamespaceCanConvertSameQuantity() { const string source = """ @@ -378,11 +381,13 @@ public static class Consumer }; test.TestState.Sources.Add(source); - await test.RunAsync(TestContext.Current.CancellationToken); + await test.RunAsync(TestContext.Current!.Execution.CancellationToken); double[] result = Evaluate(test.Compilation, "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(1, result[0], 12), - () => Assert.Equal(6, result[1], 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(result[0], 12)).IsEqualTo(Math.Round(1d, 12)); + await Assert.That(Math.Round(result[1], 12)).IsEqualTo(Math.Round(6d, 12)); + } } private static double[] Evaluate(Compilation compilation, string consumerType) @@ -394,7 +399,7 @@ private static double[] Evaluate(Compilation compilation, string consumerType) private static byte[] Emit(Compilation compilation) { using MemoryStream stream = new(); - EmitResult result = compilation.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); + EmitResult result = compilation.Emit(stream, cancellationToken: TestContext.Current!.Execution.CancellationToken); if (!result.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, result.Diagnostics)); diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs index a556e11..29af403 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs @@ -4,14 +4,14 @@ using DimensionalQuantities.Units; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; +[NotInParallel(nameof(UnitProviderReaderTests))] public sealed class UnitProviderReaderTests { - [Fact] - public void InvalidPowerDenominatorReportsDiagnostic() + [Test] + public async Task InvalidPowerDenominatorReportsDiagnostic() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -26,13 +26,15 @@ private sealed class Foot; } """; (IReadOnlyList units, List diagnostics) = Read(source); - Assert.Multiple( - () => Assert.Empty(units), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); + using (Assert.Multiple()) + { + await Assert.That(units).IsEmpty(); + await Assert.That((await Assert.That(diagnostics).HasSingleItem()).Id).IsEqualTo("DQ0008"); + } } - [Fact] - public void RationalFactorPowerAndScaleAreReadFromDeclarations() + [Test] + public async Task RationalFactorPowerAndScaleAreReadFromDeclarations() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -47,15 +49,17 @@ private sealed class SquareMetre; } """; (IReadOnlyList units, List diagnostics) = Read(source); - UnitConversionSpec result = Assert.Single(units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Equal(new Rational(1, 2), result.Units[0].Expression.Terms[0].Power), - () => Assert.Equal(4, result.Units[0].Expression.Terms[0].Unit.Scale)); + UnitConversionSpec result = (await Assert.That(units).HasSingleItem()); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.Units[0].Expression.Terms[0].Power).IsEqualTo(new Rational(1, 2)); + await Assert.That(result.Units[0].Expression.Terms[0].Unit.Scale).IsEqualTo(4); + } } - [Fact] - public void MultipleAliasesForSameQuantityShareOneUnitDefinition() + [Test] + public async Task MultipleAliasesForSameQuantityShareOneUnitDefinition() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -71,15 +75,17 @@ private sealed class Pascal; } """; (IReadOnlyList units, List diagnostics) = Read(source); - UnitConversionSpec result = Assert.Single(units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Single(result.Units), - () => Assert.Equal("Pascal", result.ExtensionName)); + UnitConversionSpec result = (await Assert.That(units).HasSingleItem()); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(result.Units).HasSingleItem(); + await Assert.That(result.ExtensionName).IsEqualTo("Pascal"); + } } - [Fact] - public void AffineOffsetIsReadForAnAdditionalUnit() + [Test] + public async Task AffineOffsetIsReadForAnAdditionalUnit() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -100,18 +106,20 @@ private sealed class Fahrenheit; } """; (IReadOnlyList units, List diagnostics) = Read(source); - UnitDefinition unit = Assert.Single(Assert.Single(units).Units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Null(unit.OffsetBeforeScale), - () => Assert.Equal(459.67, Assert.Single(unit.AdditionalConversions).OffsetBeforeScale)); + UnitDefinition unit = (await Assert.That((await Assert.That(units).HasSingleItem()).Units).HasSingleItem()); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + await Assert.That(unit.OffsetBeforeScale).IsNull(); + await Assert.That((await Assert.That(unit.AdditionalConversions).HasSingleItem()).OffsetBeforeScale).IsEqualTo(459.67); + } } - [Theory] - [InlineData("[UnitFactor(typeof(Celsius), Power = 2)]", "")] - [InlineData("[UnitFactor(typeof(Celsius), PrefixExponent = 3)]", "")] - [InlineData("[UnitFactor(typeof(Celsius))]", "[UnitFactor(typeof(Metre))]")] - public void AffineUnitsRejectPoweredPrefixedAndCompoundDeclarations(string factor, string additionalFactor) + [Test] + [Arguments("[UnitFactor(typeof(Celsius), Power = 2)]", "")] + [Arguments("[UnitFactor(typeof(Celsius), PrefixExponent = 3)]", "")] + [Arguments("[UnitFactor(typeof(Celsius))]", "[UnitFactor(typeof(Metre))]")] + public async Task AffineUnitsRejectPoweredPrefixedAndCompoundDeclarations(string factor, string additionalFactor) { string source = $$""" using DimensionalQuantities.Units.Declarations; @@ -130,13 +138,15 @@ private sealed class Metre; } """; (IReadOnlyList units, List diagnostics) = Read(source); - Assert.Multiple( - () => Assert.Empty(units), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); + using (Assert.Multiple()) + { + await Assert.That(units).IsEmpty(); + await Assert.That((await Assert.That(diagnostics).HasSingleItem()).Id).IsEqualTo("DQ0008"); + } } - [Fact] - public void OneDeclarationCanAssociateDistinctQuantityTypes() + [Test] + public async Task OneDeclarationCanAssociateDistinctQuantityTypes() { const string source = """ using DimensionalQuantities.Units.Declarations; @@ -157,10 +167,15 @@ private sealed class Token; QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Length: 1)), QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Time: 1)) ]; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.All(units, unit => Assert.Equal("Token", unit.ExtensionName)), - () => Assert.Equal(expected.Order(StringComparer.Ordinal), units.Select(unit => unit.ReceiverType).Order(StringComparer.Ordinal))); + using (Assert.Multiple()) + { + await Assert.That(diagnostics).IsEmpty(); + foreach (UnitConversionSpec unit in units) + { + await Assert.That(unit.ExtensionName).IsEqualTo("Token"); + } + await Assert.That(units.Select(unit => unit.ReceiverType).Order(StringComparer.Ordinal)).IsEquivalentTo(expected.Order(StringComparer.Ordinal), TUnit.Assertions.Enums.CollectionOrdering.Matching); + } } private static (IReadOnlyList Units, List Diagnostics) Read(string source) diff --git a/src/DimensionalQuantities.Tests/DimensionalQuantities.Tests.csproj b/src/DimensionalQuantities.Tests/DimensionalQuantities.Tests.csproj index dce42f4..7bc3280 100644 --- a/src/DimensionalQuantities.Tests/DimensionalQuantities.Tests.csproj +++ b/src/DimensionalQuantities.Tests/DimensionalQuantities.Tests.csproj @@ -4,11 +4,11 @@ false true Exe - true - - + + + diff --git a/src/DimensionalQuantities.Tests/Dimensions/DimensionTests.cs b/src/DimensionalQuantities.Tests/Dimensions/DimensionTests.cs index e68faf8..63a105b 100644 --- a/src/DimensionalQuantities.Tests/Dimensions/DimensionTests.cs +++ b/src/DimensionalQuantities.Tests/Dimensions/DimensionTests.cs @@ -1,14 +1,13 @@ using DimensionalQuantities.Numerics; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Units; -using Xunit; namespace DimensionalQuantities.Tests.Dimensions; public sealed class DimensionTests { - [Fact] - public void ComponentsPairNonzeroExponentsWithTheirNamesInSiOrder() + [Test] + public async Task ComponentsPairNonzeroExponentsWithTheirNamesInSiOrder() { Dimension original = new(1, -2, new(3, 2), 4, 0, -6, 7); IEnumerable result = original.GetComponents(); @@ -22,64 +21,64 @@ public void ComponentsPairNonzeroExponentsWithTheirNamesInSiOrder() new(7, new("LuminousIntensity", [new(AtomicUnits.Candela)])) ]; - Assert.Equal(expected, result); + await Assert.That(result).IsEquivalentTo(expected, TUnit.Assertions.Enums.CollectionOrdering.Matching); } - [Fact] - public void DimensionlessHasNoComponents() + [Test] + public async Task DimensionlessHasNoComponents() { Dimension original = default; IEnumerable result = original.GetComponents(); - Assert.Empty(result); + await Assert.That(result).IsEmpty(); } - [Fact] - public void MultiplicationOperatorCombinesDimensions() + [Test] + public async Task MultiplicationOperatorCombinesDimensions() { Dimension original = new(ElectricCurrent: new(1, 2)); Dimension operand = new(ElectricCurrent: new(3, 2), Time: -1); Dimension result = original * operand; Dimension expected = new(ElectricCurrent: 2, Time: -1); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DivisionOperatorSubtractsDivisorDimensions() + [Test] + public async Task DivisionOperatorSubtractsDivisorDimensions() { Dimension original = new(Length: 1, Time: new(1, 2)); Dimension operand = new(Time: new(3, 2)); Dimension result = original / operand; Dimension expected = new(Length: 1, Time: -1); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void MultiplicationAddsEveryExponent() + [Test] + public async Task MultiplicationAddsEveryExponent() { Dimension original = new(1, -2, 3, -4, 5, -6, 7); Dimension operand = new(-7, 6, -5, 4, -3, 2, -1); Dimension result = original.Multiply(operand); Dimension expected = new(-6, 4, -2, 0, 2, -4, 6); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DivisionSubtractsEveryExponent() + [Test] + public async Task DivisionSubtractsEveryExponent() { Dimension original = new(1, -2, 3, -4, 5, -6, 7); Dimension operand = new(-7, 6, -5, 4, -3, 2, -1); Dimension result = original.Divide(operand); Dimension expected = new(8, -8, 8, -8, 8, -8, 8); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DimensionlessIsMultiplicativeIdentity() + [Test] + public async Task DimensionlessIsMultiplicativeIdentity() { Dimension original = new(Length: 2, Time: -3); Dimension dimensionless = default; @@ -87,34 +86,36 @@ public void DimensionlessIsMultiplicativeIdentity() Dimension reverseMultipliedResult = dimensionless.Multiply(original); Dimension expected = original; - Assert.Multiple( - () => Assert.Equal(expected, multipliedResult), - () => Assert.Equal(expected, reverseMultipliedResult)); + using (Assert.Multiple()) + { + await Assert.That(multipliedResult).IsEqualTo(expected); + await Assert.That(reverseMultipliedResult).IsEqualTo(expected); + } } - [Fact] - public void DivisionByDimensionlessPreservesDimension() + [Test] + public async Task DivisionByDimensionlessPreservesDimension() { Dimension original = new(Length: 2, Time: -3); Dimension dimensionless = default; Dimension result = original.Divide(dimensionless); Dimension expected = original; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void SelfDivisionCancelsEveryExponent() + [Test] + public async Task SelfDivisionCancelsEveryExponent() { Dimension original = new(Length: 2, Time: -3); Dimension result = original.Divide(original); Dimension expected = default; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GroupingDoesNotChangeElectricalLossDimension() + [Test] + public async Task GroupingDoesNotChangeElectricalLossDimension() { Dimension current = new(ElectricCurrent: 1); Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); @@ -122,109 +123,111 @@ public void GroupingDoesNotChangeElectricalLossDimension() Dimension regroupedResult = current.Multiply(current.Multiply(resistance)); Dimension expected = new(Length: 2, Mass: 1, Time: -3); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Equal(expected, regroupedResult)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(regroupedResult).IsEqualTo(expected); + } } - [Theory] - [InlineData(-2)] - [InlineData(-1)] - [InlineData(0)] - [InlineData(1)] - [InlineData(3)] - public void IntegerPowersScaleAllExponents(int power) + [Test] + [Arguments(-2)] + [Arguments(-1)] + [Arguments(0)] + [Arguments(1)] + [Arguments(3)] + public async Task IntegerPowersScaleAllExponents(int power) { Dimension original = new(1, -2, 3, -4, 5, -6, 7); Dimension result = original.Pow(power); Dimension expected = new(power, -2 * power, 3 * power, -4 * power, 5 * power, -6 * power, 7 * power); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1)] - [InlineData(2)] - [InlineData(3)] - public void ExactRootsDivideAllExponents(int degree) + [Test] + [Arguments(1)] + [Arguments(2)] + [Arguments(3)] + public async Task ExactRootsDivideAllExponents(int degree) { Dimension original = new(6, -12, 18, -24, 30, -36, 42); Dimension result = original.Root(degree); Dimension expected = new(6 / degree, -12 / degree, 18 / degree, -24 / degree, 30 / degree, -36 / degree, 42 / degree); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void RootsProduceFractionalExponents() + [Test] + public async Task RootsProduceFractionalExponents() { Dimension original = new(1, -2, 3, -4, 5, -6, 7); Dimension result = original.Root(2); Dimension expected = new(new(1, 2), -1, new(3, 2), -2, new(5, 2), -3, new(7, 2)); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void FractionalPowerScalesDimension() + [Test] + public async Task FractionalPowerScalesDimension() { Dimension original = new(Length: 3); Dimension result = original.Pow(new(2, 3)); Dimension expected = new(Length: 2); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void MultiplicationCombinesFractionalExponentsExactly() + [Test] + public async Task MultiplicationCombinesFractionalExponentsExactly() { Dimension original = new(ElectricCurrent: new(1, 3)); Dimension operand = new(ElectricCurrent: new(2, 3)); Dimension result = original.Multiply(operand); Dimension expected = new(ElectricCurrent: 1); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DivisionSubtractsFractionalExponentsExactly() + [Test] + public async Task DivisionSubtractsFractionalExponentsExactly() { Dimension original = new(ElectricCurrent: 2); Dimension operand = new(ElectricCurrent: new(3, 2)); Dimension result = original.Divide(operand); Dimension expected = new(ElectricCurrent: new(1, 2)); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void NoiseDensityTimesRootBandwidthProducesCurrent() + [Test] + public async Task NoiseDensityTimesRootBandwidthProducesCurrent() { Dimension original = new(ElectricCurrent: 1, Time: new(1, 2)); Dimension bandwidth = new(Time: -1); Dimension result = original.Multiply(bandwidth.Root(2)); Dimension expected = new(ElectricCurrent: 1); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DimensionlessHasAnExactRoot() + [Test] + public async Task DimensionlessHasAnExactRoot() { Dimension original = default; Dimension result = original.Root(2); Dimension expected = default; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(0)] - [InlineData(-1)] - public void RootRequiresPositiveDegree(int degree) + [Test] + [Arguments(0)] + [Arguments(-1)] + public async Task RootRequiresPositiveDegree(int degree) { Dimension original = default; - Assert.Throws(() => original.Root(degree)); + await Assert.That(() => original.Root(degree)).ThrowsExactly(); } } diff --git a/src/DimensionalQuantities.Tests/Naming/DimensionNameGeneratorTests.cs b/src/DimensionalQuantities.Tests/Naming/DimensionNameGeneratorTests.cs index 036ceeb..1f94461 100644 --- a/src/DimensionalQuantities.Tests/Naming/DimensionNameGeneratorTests.cs +++ b/src/DimensionalQuantities.Tests/Naming/DimensionNameGeneratorTests.cs @@ -1,148 +1,149 @@ using DimensionalQuantities.Dimensions; using DimensionalQuantities.Naming; -using Xunit; namespace DimensionalQuantities.Tests.Naming; public sealed class DimensionNameGeneratorTests { - [Theory] - [InlineData(1, 0, 0, 0, 0, 0, 0, "Length")] - [InlineData(0, 1, 0, 0, 0, 0, 0, "Mass")] - [InlineData(0, 0, 1, 0, 0, 0, 0, "Time")] - [InlineData(0, 0, 0, 1, 0, 0, 0, "Current")] - [InlineData(0, 0, 0, 0, 1, 0, 0, "Temperature")] - [InlineData(0, 0, 0, 0, 0, 1, 0, "AmountOfSubstance")] - [InlineData(0, 0, 0, 0, 0, 0, 1, "LuminousIntensity")] - public void GetQuantityNameUsesBaseVocabulary(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) + [Test] + [Arguments(1, 0, 0, 0, 0, 0, 0, "Length")] + [Arguments(0, 1, 0, 0, 0, 0, 0, "Mass")] + [Arguments(0, 0, 1, 0, 0, 0, 0, "Time")] + [Arguments(0, 0, 0, 1, 0, 0, 0, "Current")] + [Arguments(0, 0, 0, 0, 1, 0, 0, "Temperature")] + [Arguments(0, 0, 0, 0, 0, 1, 0, "AmountOfSubstance")] + [Arguments(0, 0, 0, 0, 0, 0, 1, "LuminousIntensity")] + public async Task GetQuantityNameUsesBaseVocabulary(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) { Dimension original = new(length, mass, time, electricCurrent, temperature, amountOfSubstance, luminousIntensity); string result = DimensionNameGenerator.GetQuantityName(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, "Current")] - [InlineData(2, "CurrentSquared")] - [InlineData(3, "CurrentCubed")] - [InlineData(4, "Current4")] - [InlineData(12, "Current12")] - [InlineData(-1, "InverseCurrent")] - [InlineData(-2, "InverseCurrentSquared")] - [InlineData(-3, "InverseCurrentCubed")] - [InlineData(-4, "InverseCurrent4")] - [InlineData(-12, "InverseCurrent12")] - public void GetQuantityNameFormatsIntegerPowers(int exponent, string expected) + [Test] + [Arguments(1, "Current")] + [Arguments(2, "CurrentSquared")] + [Arguments(3, "CurrentCubed")] + [Arguments(4, "Current4")] + [Arguments(12, "Current12")] + [Arguments(-1, "InverseCurrent")] + [Arguments(-2, "InverseCurrentSquared")] + [Arguments(-3, "InverseCurrentCubed")] + [Arguments(-4, "InverseCurrent4")] + [Arguments(-12, "InverseCurrent12")] + public async Task GetQuantityNameFormatsIntegerPowers(int exponent, string expected) { Dimension original = new(ElectricCurrent: exponent); string result = DimensionNameGenerator.GetQuantityName(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 1, 1, 1, 1, 1, 1, "LengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity")] - [InlineData(3, 0, -12, 0, 0, 0, 0, "LengthCubedPerTime12")] - [InlineData(1, 1, -2, 0, 0, 0, 0, "LengthMassPerTimeSquared")] - [InlineData(2, 1, -3, 0, 0, 0, 0, "LengthSquaredMassPerTimeCubed")] - [InlineData(0, 0, 0, 0, -1, 0, 1, "LuminousIntensityPerTemperature")] - [InlineData(-2, -1, 3, -4, 1, -2, 1, "TimeCubedTemperatureLuminousIntensityPerLengthSquaredMassCurrent4AmountOfSubstanceSquared")] - [InlineData(-1, -1, -1, -1, -1, -1, -1, "InverseLengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity")] - public void GetQuantityNameComposesFactorsInSiOrder(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) + [Test] + [Arguments(1, 1, 1, 1, 1, 1, 1, "LengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity")] + [Arguments(3, 0, -12, 0, 0, 0, 0, "LengthCubedPerTime12")] + [Arguments(1, 1, -2, 0, 0, 0, 0, "LengthMassPerTimeSquared")] + [Arguments(2, 1, -3, 0, 0, 0, 0, "LengthSquaredMassPerTimeCubed")] + [Arguments(0, 0, 0, 0, -1, 0, 1, "LuminousIntensityPerTemperature")] + [Arguments(-2, -1, 3, -4, 1, -2, 1, "TimeCubedTemperatureLuminousIntensityPerLengthSquaredMassCurrent4AmountOfSubstanceSquared")] + [Arguments(-1, -1, -1, -1, -1, -1, -1, "InverseLengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity")] + public async Task GetQuantityNameComposesFactorsInSiOrder(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) { Dimension original = new(length, mass, time, electricCurrent, temperature, amountOfSubstance, luminousIntensity); string result = DimensionNameGenerator.GetQuantityName(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 2, "SquareRootCurrent")] - [InlineData(1, 3, "CubeRootCurrent")] - [InlineData(3, 2, "SquareRootCurrentCubed")] - [InlineData(2, 3, "CubeRootCurrentSquared")] - [InlineData(2, 4, "SquareRootCurrent")] - [InlineData(4, 2, "CurrentSquared")] - [InlineData(-3, 2, "InverseSquareRootCurrentCubed")] - [InlineData(1, -2, "InverseSquareRootCurrent")] - [InlineData(1, 12, "Root12Current")] - [InlineData(1, 4, "Root4Current")] - [InlineData(1, 5, "Root5Current")] - [InlineData(4, 5, "Root5Current4")] - [InlineData(1, 45, "Root45Current")] - public void GetQuantityNameFormatsReducedRationalPowers(int numerator, int denominator, string expected) + [Test] + [Arguments(1, 2, "SquareRootCurrent")] + [Arguments(1, 3, "CubeRootCurrent")] + [Arguments(3, 2, "SquareRootCurrentCubed")] + [Arguments(2, 3, "CubeRootCurrentSquared")] + [Arguments(2, 4, "SquareRootCurrent")] + [Arguments(4, 2, "CurrentSquared")] + [Arguments(-3, 2, "InverseSquareRootCurrentCubed")] + [Arguments(1, -2, "InverseSquareRootCurrent")] + [Arguments(1, 12, "Root12Current")] + [Arguments(1, 4, "Root4Current")] + [Arguments(1, 5, "Root5Current")] + [Arguments(4, 5, "Root5Current4")] + [Arguments(1, 45, "Root45Current")] + public async Task GetQuantityNameFormatsReducedRationalPowers(int numerator, int denominator, string expected) { Dimension original = new(ElectricCurrent: new(numerator, denominator)); string result = DimensionNameGenerator.GetQuantityName(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetQuantityNameKeepsFractionalPowersAttachedToTheirFactors() + [Test] + public async Task GetQuantityNameKeepsFractionalPowersAttachedToTheirFactors() { Dimension original = new(Length: new(1, 2), Time: new(-3, 2), ElectricCurrent: 1); string result = DimensionNameGenerator.GetQuantityName(original); string expected = "SquareRootLengthCurrentPerSquareRootTimeCubed"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 0, 0, 0, 0, 0, 0, "m")] - [InlineData(0, 1, 0, 0, 0, 0, 0, "kg")] - [InlineData(0, 0, 1, 0, 0, 0, 0, "s")] - [InlineData(0, 0, 0, 1, 0, 0, 0, "A")] - [InlineData(0, 0, 0, 0, 1, 0, 0, "K")] - [InlineData(0, 0, 0, 0, 0, 1, 0, "mol")] - [InlineData(0, 0, 0, 0, 0, 0, 1, "cd")] - [InlineData(1, 1, 1, 1, 1, 1, 1, "mkgsAKmolcd")] - [InlineData(3, 0, -12, 0, 0, 0, 0, "m3s-12")] - [InlineData(0, 0, -1, 0, 0, 0, 0, "s-1")] - [InlineData(-2, 1, 3, 0, 0, 0, 0, "m-2kgs3")] - public void GetUnitExpressionUsesAdjacentSiSymbolsInAxisOrder(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) + [Test] + [Arguments(1, 0, 0, 0, 0, 0, 0, "m")] + [Arguments(0, 1, 0, 0, 0, 0, 0, "kg")] + [Arguments(0, 0, 1, 0, 0, 0, 0, "s")] + [Arguments(0, 0, 0, 1, 0, 0, 0, "A")] + [Arguments(0, 0, 0, 0, 1, 0, 0, "K")] + [Arguments(0, 0, 0, 0, 0, 1, 0, "mol")] + [Arguments(0, 0, 0, 0, 0, 0, 1, "cd")] + [Arguments(1, 1, 1, 1, 1, 1, 1, "mkgsAKmolcd")] + [Arguments(3, 0, -12, 0, 0, 0, 0, "m3s-12")] + [Arguments(0, 0, -1, 0, 0, 0, 0, "s-1")] + [Arguments(-2, 1, 3, 0, 0, 0, 0, "m-2kgs3")] + public async Task GetUnitExpressionUsesAdjacentSiSymbolsInAxisOrder(int length, int mass, int time, int electricCurrent, int temperature, int amountOfSubstance, int luminousIntensity, string expected) { Dimension original = new(length, mass, time, electricCurrent, temperature, amountOfSubstance, luminousIntensity); string result = DimensionNameGenerator.GetUnitExpression(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 2, "A1/2")] - [InlineData(3, 2, "A3/2")] - [InlineData(-3, 2, "A-3/2")] - [InlineData(1, -2, "A-1/2")] - [InlineData(2, 4, "A1/2")] - [InlineData(4, 2, "A2")] - [InlineData(2, 2, "A")] - [InlineData(4, 5, "A4/5")] - public void GetUnitExpressionFormatsReducedRationalPowers(int numerator, int denominator, string expected) + [Test] + [Arguments(1, 2, "A1/2")] + [Arguments(3, 2, "A3/2")] + [Arguments(-3, 2, "A-3/2")] + [Arguments(1, -2, "A-1/2")] + [Arguments(2, 4, "A1/2")] + [Arguments(4, 2, "A2")] + [Arguments(2, 2, "A")] + [Arguments(4, 5, "A4/5")] + public async Task GetUnitExpressionFormatsReducedRationalPowers(int numerator, int denominator, string expected) { Dimension original = new(ElectricCurrent: new(numerator, denominator)); string result = DimensionNameGenerator.GetUnitExpression(original); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetUnitExpressionKeepsFractionalPowersAttachedToTheirSymbols() + [Test] + public async Task GetUnitExpressionKeepsFractionalPowersAttachedToTheirSymbols() { Dimension original = new(Length: new(1, 2), Time: new(-3, 2), ElectricCurrent: 1); string result = DimensionNameGenerator.GetUnitExpression(original); string expected = "m1/2s-3/2A"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void NamingMethodsRejectDimensionlessQuantities() + [Test] + public async Task NamingMethodsRejectDimensionlessQuantities() { Dimension original = default; - Assert.Multiple( - () => Assert.Throws(() => DimensionNameGenerator.GetQuantityName(original)), - () => Assert.Throws(() => DimensionNameGenerator.GetUnitExpression(original))); + using (Assert.Multiple()) + { + await Assert.That(() => DimensionNameGenerator.GetQuantityName(original)).ThrowsExactly(); + await Assert.That(() => DimensionNameGenerator.GetUnitExpression(original)).ThrowsExactly(); + } } } diff --git a/src/DimensionalQuantities.Tests/Naming/DimensionNameParserTests.cs b/src/DimensionalQuantities.Tests/Naming/DimensionNameParserTests.cs index 02818ea..743358e 100644 --- a/src/DimensionalQuantities.Tests/Naming/DimensionNameParserTests.cs +++ b/src/DimensionalQuantities.Tests/Naming/DimensionNameParserTests.cs @@ -1,72 +1,77 @@ using DimensionalQuantities.Dimensions; using DimensionalQuantities.Naming; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Naming; public sealed class DimensionNameParserTests { - [Theory] - [InlineData("LengthCurrent", 1, 0, 0, 1, 0, 0, 0)] - [InlineData("LengthSquaredTimeCubed", 2, 0, 3, 0, 0, 0, 0)] - [InlineData("Mass4", 0, 4, 0, 0, 0, 0, 0)] - [InlineData("Time1048576", 0, 0, 1048576, 0, 0, 0, 0)] - [InlineData("InverseLengthCurrent", -1, 0, 0, -1, 0, 0, 0)] - [InlineData("LengthPerTimeCurrentSquared", 1, 0, -1, -2, 0, 0, 0)] - [InlineData("LengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity", 1, 1, 1, 1, 1, 1, 1)] - public void ParsesCanonicalDimensionNames(string name, int length, int mass, int time, int current, int temperature, int amount, int intensity) + [Test] + [Arguments("LengthCurrent", 1, 0, 0, 1, 0, 0, 0)] + [Arguments("LengthSquaredTimeCubed", 2, 0, 3, 0, 0, 0, 0)] + [Arguments("Mass4", 0, 4, 0, 0, 0, 0, 0)] + [Arguments("Time1048576", 0, 0, 1048576, 0, 0, 0, 0)] + [Arguments("InverseLengthCurrent", -1, 0, 0, -1, 0, 0, 0)] + [Arguments("LengthPerTimeCurrentSquared", 1, 0, -1, -2, 0, 0, 0)] + [Arguments("LengthMassTimeCurrentTemperatureAmountOfSubstanceLuminousIntensity", 1, 1, 1, 1, 1, 1, 1)] + public async Task ParsesCanonicalDimensionNames(string name, int length, int mass, int time, int current, int temperature, int amount, int intensity) { bool success = DimensionNameParser.TryParse(name, out Dimension result); Dimension expected = new(length, mass, time, current, temperature, amount, intensity); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result), - () => Assert.Equal(name, DimensionNameGenerator.GetQuantityName(result))); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + await Assert.That(DimensionNameGenerator.GetQuantityName(result)).IsEqualTo(name); + } } - [Theory] - [InlineData("SquareRootLengthCurrent", 1, 2, 1, 1)] - [InlineData("CubeRootLengthSquared", 2, 3, 0, 1)] - [InlineData("Root5LengthCubedPerRoot4Current", 3, 5, -1, 4)] - public void ParsesRationalPowers(string name, int lengthNumerator, int lengthDenominator, int currentNumerator, int currentDenominator) + [Test] + [Arguments("SquareRootLengthCurrent", 1, 2, 1, 1)] + [Arguments("CubeRootLengthSquared", 2, 3, 0, 1)] + [Arguments("Root5LengthCubedPerRoot4Current", 3, 5, -1, 4)] + public async Task ParsesRationalPowers(string name, int lengthNumerator, int lengthDenominator, int currentNumerator, int currentDenominator) { bool success = DimensionNameParser.TryParse(name, out Dimension result); Dimension expected = new(Length: new Rational(lengthNumerator, lengthDenominator), ElectricCurrent: new Rational(currentNumerator, currentDenominator)); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData(null)] - [InlineData("")] - [InlineData("Missing")] - [InlineData("length")] - [InlineData("Length0")] - [InlineData("Length1")] - [InlineData("Length2")] - [InlineData("Length04")] - [InlineData("CurrentLength")] - [InlineData("LengthLength")] - [InlineData("LengthPerLength")] - [InlineData("LengthPerTimePerCurrent")] - [InlineData("PerLength")] - [InlineData("Inverse")] - [InlineData("Root0Length")] - [InlineData("Root1Length")] - [InlineData("Root2Length")] - [InlineData("SquareRootLengthSquared")] - [InlineData("LengthPow4")] - [InlineData("Length Current")] - public void RejectsNoncanonicalOrInvalidNames(string? name) + [Test] + [Arguments(null)] + [Arguments("")] + [Arguments("Missing")] + [Arguments("length")] + [Arguments("Length0")] + [Arguments("Length1")] + [Arguments("Length2")] + [Arguments("Length04")] + [Arguments("CurrentLength")] + [Arguments("LengthLength")] + [Arguments("LengthPerLength")] + [Arguments("LengthPerTimePerCurrent")] + [Arguments("PerLength")] + [Arguments("Inverse")] + [Arguments("Root0Length")] + [Arguments("Root1Length")] + [Arguments("Root2Length")] + [Arguments("SquareRootLengthSquared")] + [Arguments("LengthPow4")] + [Arguments("Length Current")] + public async Task RejectsNoncanonicalOrInvalidNames(string? name) { bool success = DimensionNameParser.TryParse(name, out Dimension result); - Assert.Multiple( - () => Assert.False(success), - () => Assert.Equal(default, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsFalse(); + await Assert.That(result).IsEqualTo(default); + } } } diff --git a/src/DimensionalQuantities.Tests/Numerics/EnglishRationalParserTests.cs b/src/DimensionalQuantities.Tests/Numerics/EnglishRationalParserTests.cs index 7f80d96..73f5b1a 100644 --- a/src/DimensionalQuantities.Tests/Numerics/EnglishRationalParserTests.cs +++ b/src/DimensionalQuantities.Tests/Numerics/EnglishRationalParserTests.cs @@ -1,191 +1,202 @@ using System.Numerics; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Numerics; public sealed class EnglishRationalParserTests { - [Theory] - [InlineData("Zero", 0)] - [InlineData("One", 1)] - [InlineData("Nine", 9)] - [InlineData("Ten", 10)] - [InlineData("Eleven", 11)] - [InlineData("Twelve", 12)] - [InlineData("Thirteen", 13)] - [InlineData("Nineteen", 19)] - [InlineData("Twenty", 20)] - [InlineData("TwentyOne", 21)] - [InlineData("FortyTwo", 42)] - [InlineData("NinetyNine", 99)] - [InlineData("OneHundred", 100)] - [InlineData("OneHundredAndOne", 101)] - [InlineData("OneHundredAndTwentyThree", 123)] - [InlineData("OneHundredTwentyThree", 123)] - [InlineData("NineHundredAndNinetyNine", 999)] - [InlineData("OneThousand", 1000)] - [InlineData("OneThousandAndOne", 1001)] - [InlineData("OneThousandOneHundredAndOne", 1101)] - [InlineData("TwelveThousandThreeHundredAndFortyFive", 12345)] - [InlineData("TwoHundredAndThirtyFourThousandFiveHundredAndSix", 234506)] - [InlineData("TwoHundredThousandAndSix", 200006)] - [InlineData("OneMillionTwoHundredAndThirtyFourThousandFiveHundredAndSixtySeven", 1234567)] - [InlineData("OneMillionAndOne", 1000001)] - [InlineData("OneBillion", 1000000000)] - [InlineData("MinusThree", -3)] - [InlineData("MinusOneHundredAndTwentyThree", -123)] - [InlineData("MinusZero", 0)] - public void ParsesIntegerNames(string text, int expectedValue) + [Test] + [Arguments("Zero", 0)] + [Arguments("One", 1)] + [Arguments("Nine", 9)] + [Arguments("Ten", 10)] + [Arguments("Eleven", 11)] + [Arguments("Twelve", 12)] + [Arguments("Thirteen", 13)] + [Arguments("Nineteen", 19)] + [Arguments("Twenty", 20)] + [Arguments("TwentyOne", 21)] + [Arguments("FortyTwo", 42)] + [Arguments("NinetyNine", 99)] + [Arguments("OneHundred", 100)] + [Arguments("OneHundredAndOne", 101)] + [Arguments("OneHundredAndTwentyThree", 123)] + [Arguments("OneHundredTwentyThree", 123)] + [Arguments("NineHundredAndNinetyNine", 999)] + [Arguments("OneThousand", 1000)] + [Arguments("OneThousandAndOne", 1001)] + [Arguments("OneThousandOneHundredAndOne", 1101)] + [Arguments("TwelveThousandThreeHundredAndFortyFive", 12345)] + [Arguments("TwoHundredAndThirtyFourThousandFiveHundredAndSix", 234506)] + [Arguments("TwoHundredThousandAndSix", 200006)] + [Arguments("OneMillionTwoHundredAndThirtyFourThousandFiveHundredAndSixtySeven", 1234567)] + [Arguments("OneMillionAndOne", 1000001)] + [Arguments("OneBillion", 1000000000)] + [Arguments("MinusThree", -3)] + [Arguments("MinusOneHundredAndTwentyThree", -123)] + [Arguments("MinusZero", 0)] + public async Task ParsesIntegerNames(string text, int expectedValue) { bool success = EnglishRationalParser.TryParse(text, out Rational result); Rational expected = new(expectedValue); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("Half", 1, 2)] - [InlineData("OneHalf", 1, 2)] - [InlineData("ThreeHalves", 3, 2)] - [InlineData("Quarter", 1, 4)] - [InlineData("OneQuarter", 1, 4)] - [InlineData("ThreeQuarters", 3, 4)] - [InlineData("Third", 1, 3)] - [InlineData("OneThird", 1, 3)] - [InlineData("TwoThirds", 2, 3)] - [InlineData("Fourth", 1, 4)] - [InlineData("ThreeFourths", 3, 4)] - [InlineData("TwoFifths", 2, 5)] - [InlineData("FiveSixths", 5, 6)] - [InlineData("SixSevenths", 6, 7)] - [InlineData("SevenEighths", 7, 8)] - [InlineData("EightNinths", 8, 9)] - [InlineData("NineTenths", 9, 10)] - [InlineData("TwoElevenths", 2, 11)] - [InlineData("FiveTwelfths", 5, 12)] - [InlineData("OneTwentieth", 1, 20)] - [InlineData("ThreeHundredths", 3, 100)] - [InlineData("Thousandth", 1, 1000)] - [InlineData("OneThousandth", 1, 1000)] - [InlineData("ThreeThousandths", 3, 1000)] - [InlineData("Millionth", 1, 1000000)] - [InlineData("OneMillionth", 1, 1000000)] - [InlineData("ThreeMillionths", 3, 1000000)] - [InlineData("MinusThreeMillionths", -3, 1000000)] - [InlineData("TwoQuarters", 1, 2)] - [InlineData("ZeroThirds", 0, 1)] - [InlineData("MinusHalf", -1, 2)] - [InlineData("MinusThreeQuarters", -3, 4)] - public void ParsesNaturalFractions(string text, int numerator, int denominator) + [Test] + [Arguments("Half", 1, 2)] + [Arguments("OneHalf", 1, 2)] + [Arguments("ThreeHalves", 3, 2)] + [Arguments("Quarter", 1, 4)] + [Arguments("OneQuarter", 1, 4)] + [Arguments("ThreeQuarters", 3, 4)] + [Arguments("Third", 1, 3)] + [Arguments("OneThird", 1, 3)] + [Arguments("TwoThirds", 2, 3)] + [Arguments("Fourth", 1, 4)] + [Arguments("ThreeFourths", 3, 4)] + [Arguments("TwoFifths", 2, 5)] + [Arguments("FiveSixths", 5, 6)] + [Arguments("SixSevenths", 6, 7)] + [Arguments("SevenEighths", 7, 8)] + [Arguments("EightNinths", 8, 9)] + [Arguments("NineTenths", 9, 10)] + [Arguments("TwoElevenths", 2, 11)] + [Arguments("FiveTwelfths", 5, 12)] + [Arguments("OneTwentieth", 1, 20)] + [Arguments("ThreeHundredths", 3, 100)] + [Arguments("Thousandth", 1, 1000)] + [Arguments("OneThousandth", 1, 1000)] + [Arguments("ThreeThousandths", 3, 1000)] + [Arguments("Millionth", 1, 1000000)] + [Arguments("OneMillionth", 1, 1000000)] + [Arguments("ThreeMillionths", 3, 1000000)] + [Arguments("MinusThreeMillionths", -3, 1000000)] + [Arguments("TwoQuarters", 1, 2)] + [Arguments("ZeroThirds", 0, 1)] + [Arguments("MinusHalf", -1, 2)] + [Arguments("MinusThreeQuarters", -3, 4)] + public async Task ParsesNaturalFractions(string text, int numerator, int denominator) { bool success = EnglishRationalParser.TryParse(text, out Rational result); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("TwoOverThree", 2, 3)] - [InlineData("SeventeenOverTwentyThree", 17, 23)] - [InlineData("OneHundredAndTwentyThreeOverFortyFive", 41, 15)] - [InlineData("TwoOverFour", 1, 2)] - [InlineData("SixOverThree", 2, 1)] - [InlineData("ZeroOverSeven", 0, 1)] - [InlineData("MinusThreeOverTwo", -3, 2)] - [InlineData("ThreeOverMinusTwo", -3, 2)] - [InlineData("MinusThreeOverMinusTwo", 3, 2)] - public void ParsesFractionsSeparatedByOver(string text, int numerator, int denominator) + [Test] + [Arguments("TwoOverThree", 2, 3)] + [Arguments("SeventeenOverTwentyThree", 17, 23)] + [Arguments("OneHundredAndTwentyThreeOverFortyFive", 41, 15)] + [Arguments("TwoOverFour", 1, 2)] + [Arguments("SixOverThree", 2, 1)] + [Arguments("ZeroOverSeven", 0, 1)] + [Arguments("MinusThreeOverTwo", -3, 2)] + [Arguments("ThreeOverMinusTwo", -3, 2)] + [Arguments("MinusThreeOverMinusTwo", 3, 2)] + public async Task ParsesFractionsSeparatedByOver(string text, int numerator, int denominator) { bool success = EnglishRationalParser.TryParse(text, out Rational result); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void ParsesNumbersLargerThanLong() + [Test] + public async Task ParsesNumbersLargerThanLong() { bool success = EnglishRationalParser.TryParse("TwentyQuintillionAndOneOverThree", out Rational result); Rational expected = new(20 * BigInteger.Pow(10, 18) + 1, 3); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("OneTrillion", 12)] - [InlineData("OneQuadrillion", 15)] - [InlineData("OneQuintillion", 18)] - [InlineData("OneSextillion", 21)] - [InlineData("OneSeptillion", 24)] - [InlineData("OneOctillion", 27)] - [InlineData("OneNonillion", 30)] - [InlineData("OneDecillion", 33)] - public void ParsesLargeScaleNames(string text, int exponent) + [Test] + [Arguments("OneTrillion", 12)] + [Arguments("OneQuadrillion", 15)] + [Arguments("OneQuintillion", 18)] + [Arguments("OneSextillion", 21)] + [Arguments("OneSeptillion", 24)] + [Arguments("OneOctillion", 27)] + [Arguments("OneNonillion", 30)] + [Arguments("OneDecillion", 33)] + public async Task ParsesLargeScaleNames(string text, int exponent) { bool success = EnglishRationalParser.TryParse(text, out Rational result); Rational expected = new(BigInteger.Pow(10, exponent)); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData((string?)null)] - [InlineData("")] - [InlineData(" ")] - [InlineData("one")] - [InlineData("ONE")] - [InlineData("One Two")] - [InlineData("Twenty-One")] - [InlineData("Twenty1")] - [InlineData("ThreePointFive")] - [InlineData("OneTwo")] - [InlineData("TwentyTen")] - [InlineData("ZeroOne")] - [InlineData("ZeroHundred")] - [InlineData("Hundred")] - [InlineData("OneHundredHundred")] - [InlineData("TenHundred")] - [InlineData("OneThousandMillion")] - [InlineData("OneThousandAndTwoHundred")] - [InlineData("OneMillionTwoMillion")] - [InlineData("OneAndTwo")] - [InlineData("AndOne")] - [InlineData("OneHundredAnd")] - [InlineData("OneHundredAndAndOne")] - [InlineData("Minus")] - [InlineData("MinusMinusOne")] - [InlineData("OneMinusTwo")] - [InlineData("OneOverZero")] - [InlineData("ZeroOverZero")] - [InlineData("OneOverMinusZero")] - [InlineData("OverTwo")] - [InlineData("OneOver")] - [InlineData("OneOverTwoOverThree")] - [InlineData("HalfOverTwo")] - [InlineData("OneHalfExtra")] - [InlineData("TwoHalf")] - [InlineData("OneThirds")] - [InlineData("Halves")] - [InlineData("OneAndAHalf")] - [InlineData("OneUndecillion")] - public void RejectsInvalidNames(string? text) + [Test] + [Arguments((string?)null)] + [Arguments("")] + [Arguments(" ")] + [Arguments("one")] + [Arguments("ONE")] + [Arguments("One Two")] + [Arguments("Twenty-One")] + [Arguments("Twenty1")] + [Arguments("ThreePointFive")] + [Arguments("OneTwo")] + [Arguments("TwentyTen")] + [Arguments("ZeroOne")] + [Arguments("ZeroHundred")] + [Arguments("Hundred")] + [Arguments("OneHundredHundred")] + [Arguments("TenHundred")] + [Arguments("OneThousandMillion")] + [Arguments("OneThousandAndTwoHundred")] + [Arguments("OneMillionTwoMillion")] + [Arguments("OneAndTwo")] + [Arguments("AndOne")] + [Arguments("OneHundredAnd")] + [Arguments("OneHundredAndAndOne")] + [Arguments("Minus")] + [Arguments("MinusMinusOne")] + [Arguments("OneMinusTwo")] + [Arguments("OneOverZero")] + [Arguments("ZeroOverZero")] + [Arguments("OneOverMinusZero")] + [Arguments("OverTwo")] + [Arguments("OneOver")] + [Arguments("OneOverTwoOverThree")] + [Arguments("HalfOverTwo")] + [Arguments("OneHalfExtra")] + [Arguments("TwoHalf")] + [Arguments("OneThirds")] + [Arguments("Halves")] + [Arguments("OneAndAHalf")] + [Arguments("OneUndecillion")] + public async Task RejectsInvalidNames(string? text) { bool success = EnglishRationalParser.TryParse(text, out Rational result); Rational expected = default; - Assert.Multiple( - () => Assert.False(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsFalse(); + await Assert.That(result).IsEqualTo(expected); + } } } diff --git a/src/DimensionalQuantities.Tests/Numerics/RationalTests.Conversions.cs b/src/DimensionalQuantities.Tests/Numerics/RationalTests.Conversions.cs index a4cf567..dc38343 100644 --- a/src/DimensionalQuantities.Tests/Numerics/RationalTests.Conversions.cs +++ b/src/DimensionalQuantities.Tests/Numerics/RationalTests.Conversions.cs @@ -1,176 +1,189 @@ using System.Numerics; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Numerics; public sealed partial class RationalTests { - [Fact] - public void DecimalCastPreservesExactBaseTenValue() + [Test] + public async Task DecimalCastPreservesExactBaseTenValue() { decimal original = 0.1m; Rational result = (Rational)original; - Assert.Multiple( - () => Assert.Equal(new Rational(1, 10), result), - () => Assert.Equal(original, (decimal)result)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(new Rational(1, 10)); + await Assert.That((decimal)result).IsEqualTo(original); + } } - [Fact] - public void DoubleCastPreservesExactBinaryValue() + [Test] + public async Task DoubleCastPreservesExactBinaryValue() { double original = 0.1d; Rational result = (Rational)original; - Assert.Multiple( - () => Assert.Equal(new Rational(3602879701896397, 36028797018963968), result), - () => Assert.Equal(original, (double)result)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(new Rational(3602879701896397, 36028797018963968)); + await Assert.That((double)result).IsEqualTo(original); + } } - [Theory] - [InlineData(double.NaN)] - [InlineData(double.PositiveInfinity)] - [InlineData(double.NegativeInfinity)] - public void NonFiniteNumbersHaveNoRationalRepresentation(double value) => - Assert.Throws(() => (Rational)value); + [Test] + [Arguments(double.NaN)] + [Arguments(double.PositiveInfinity)] + [Arguments(double.NegativeInfinity)] + public async Task NonFiniteNumbersHaveNoRationalRepresentation(double value) => + await Assert.That(() => (Rational)value).ThrowsExactly(); - [Fact] - public void IntegerCastsTruncateTowardsZeroAndCheckRange() + [Test] + public async Task IntegerCastsTruncateTowardsZeroAndCheckRange() { Rational fraction = new(-7, 3); Rational tooLarge = new(601, 2); - Assert.Multiple( - () => Assert.Equal(-2, (int)fraction), - () => Assert.Equal((byte)42, (byte)new Rational(85, 2)), - () => Assert.Throws(() => (byte)tooLarge)); + using (Assert.Multiple()) + { + await Assert.That((int)fraction).IsEqualTo(-2); + await Assert.That((byte)new Rational(85, 2)).IsEqualTo((byte)42); + await Assert.That(() => (byte)tooLarge).ThrowsExactly(); + } } - [Fact] - public void IntegerCastsCoverSignedAndUnsignedRanges() + [Test] + public async Task IntegerCastsCoverSignedAndUnsignedRanges() { Rational value = new(42); Rational negative = new(-1); - Assert.Multiple( - () => Assert.Equal((sbyte)42, (sbyte)value), - () => Assert.Equal((short)42, (short)value), - () => Assert.Equal((ushort)42, (ushort)value), - () => Assert.Equal(42u, (uint)value), - () => Assert.Equal(42L, (long)value), - () => Assert.Equal(42UL, (ulong)value), - () => Assert.Throws(() => (uint)negative), - () => Assert.Throws(() => (sbyte)new Rational(128))); + using (Assert.Multiple()) + { + await Assert.That((sbyte)value).IsEqualTo((sbyte)42); + await Assert.That((short)value).IsEqualTo((short)42); + await Assert.That((ushort)value).IsEqualTo((ushort)42); + await Assert.That((uint)value).IsEqualTo(42u); + await Assert.That((long)value).IsEqualTo(42L); + await Assert.That((ulong)value).IsEqualTo(42UL); + await Assert.That(() => (uint)negative).ThrowsExactly(); + await Assert.That(() => (sbyte)new Rational(128)).ThrowsExactly(); + } } - [Fact] - public void BigIntegerRoundTripPreservesWholeValue() + [Test] + public async Task BigIntegerRoundTripPreservesWholeValue() { BigInteger original = BigInteger.One << 128; Rational converted = original; BigInteger result = (BigInteger)converted; - Assert.Equal(original, result); + await Assert.That(result).IsEqualTo(original); } - [Fact] - public void PrimitiveIntegerInputsPreserveValues() + [Test] + public async Task PrimitiveIntegerInputsPreserveValues() { Rational expected = new(42); - Assert.Multiple( - () => Assert.Equal(expected, (Rational)(byte)42), - () => Assert.Equal(expected, (Rational)(sbyte)42), - () => Assert.Equal(expected, (Rational)(short)42), - () => Assert.Equal(expected, (Rational)(ushort)42), - () => Assert.Equal(expected, (Rational)42), - () => Assert.Equal(expected, (Rational)42u), - () => Assert.Equal(expected, (Rational)42L), - () => Assert.Equal(expected, (Rational)42UL)); + using (Assert.Multiple()) + { + await Assert.That((Rational)(byte)42).IsEqualTo(expected); + await Assert.That((Rational)(sbyte)42).IsEqualTo(expected); + await Assert.That((Rational)(short)42).IsEqualTo(expected); + await Assert.That((Rational)(ushort)42).IsEqualTo(expected); + await Assert.That((Rational)42).IsEqualTo(expected); + await Assert.That((Rational)42u).IsEqualTo(expected); + await Assert.That((Rational)42L).IsEqualTo(expected); + await Assert.That((Rational)42UL).IsEqualTo(expected); + } } - [Theory] - [InlineData(0.0)] - [InlineData(-0.125)] - [InlineData(double.Epsilon)] - [InlineData(double.MaxValue)] - [InlineData(double.MinValue)] - public void DoubleRoundTripPreservesRepresentableValues(double original) + [Test] + [Arguments(0.0)] + [Arguments(-0.125)] + [Arguments(double.Epsilon)] + [Arguments(double.MaxValue)] + [Arguments(double.MinValue)] + public async Task DoubleRoundTripPreservesRepresentableValues(double original) { Rational converted = (Rational)original; - Assert.Equal(original, (double)converted); + await Assert.That((double)converted).IsEqualTo(original); } - [Theory] - [InlineData(float.Epsilon)] - [InlineData(float.MaxValue)] - [InlineData(-0.1f)] - public void SingleRoundTripPreservesRepresentableValues(float original) + [Test] + [Arguments(float.Epsilon)] + [Arguments(float.MaxValue)] + [Arguments(-0.1f)] + public async Task SingleRoundTripPreservesRepresentableValues(float original) { Rational converted = (Rational)original; - Assert.Equal(original, (float)converted); + await Assert.That((float)converted).IsEqualTo(original); } - [Fact] - public void BinaryConversionRoundsMidpointToEven() + [Test] + public async Task BinaryConversionRoundsMidpointToEven() { Rational original = new((BigInteger.One << 53) + 1, BigInteger.One << 53); - Assert.Equal(1.0, (double)original); + await Assert.That((double)original).IsEqualTo(1.0); } - [Fact] - public void BinaryConversionDividesBeforeLosingLargeComponents() + [Test] + public async Task BinaryConversionDividesBeforeLosingLargeComponents() { BigInteger scale = BigInteger.One << 2000; Rational original = new(scale + 1, 2 * scale + 1); - Assert.Equal(0.5, (double)original); + await Assert.That((double)original).IsEqualTo(0.5); } - [Fact] - public void BinaryConversionRoundsAtSubnormalBoundary() + [Test] + public async Task BinaryConversionRoundsAtSubnormalBoundary() { Rational halfwayToMinimum = new(1, BigInteger.One << 1075); Rational halfwayToSecond = new(3, BigInteger.One << 1075); - Assert.Multiple( - () => Assert.Equal(0.0, (double)halfwayToMinimum), - () => Assert.Equal(2 * double.Epsilon, (double)halfwayToSecond)); + using (Assert.Multiple()) + { + await Assert.That((double)halfwayToMinimum).IsEqualTo(0.0); + await Assert.That((double)halfwayToSecond).IsEqualTo(2 * double.Epsilon); + } } - [Fact] - public void DecimalConversionRoundsRepeatingFractions() + [Test] + public async Task DecimalConversionRoundsRepeatingFractions() { Rational original = new(1, 3); - Assert.Equal(1m / 3m, (decimal)original); + await Assert.That((decimal)original).IsEqualTo(1m / 3m); } - [Fact] - public void DecimalCastRejectsOutOfRangeValue() + [Test] + public async Task DecimalCastRejectsOutOfRangeValue() { Rational original = new(new BigInteger(decimal.MaxValue) + 1); - Assert.Throws(() => (decimal)original); + await Assert.That(() => (decimal)original).ThrowsExactly(); } - [Theory] - [InlineData(1.5)] - [InlineData(-0.125)] - [InlineData(0.0)] - public void RealComplexInputsPreserveFractions(double real) + [Test] + [Arguments(1.5)] + [Arguments(-0.125)] + [Arguments(0.0)] + public async Task RealComplexInputsPreserveFractions(double real) { Complex original = new(real, 0); Rational converted = (Rational)original; - Assert.Multiple( - () => Assert.Equal((Rational)real, converted), - () => Assert.Equal(original, (Complex)converted)); + using (Assert.Multiple()) + { + await Assert.That(converted).IsEqualTo((Rational)real); + await Assert.That((Complex)converted).IsEqualTo(original); + } } - [Theory] - [InlineData(1.0)] - [InlineData(-1.0)] - public void NonRealComplexInputsAreRejected(double imaginary) + [Test] + [Arguments(1.0)] + [Arguments(-1.0)] + public async Task NonRealComplexInputsAreRejected(double imaginary) { Complex original = new(1.5, imaginary); - Assert.Throws(() => (Rational)original); + await Assert.That(() => (Rational)original).ThrowsExactly(); } } diff --git a/src/DimensionalQuantities.Tests/Numerics/RationalTests.Text.cs b/src/DimensionalQuantities.Tests/Numerics/RationalTests.Text.cs index defbefb..8d273f9 100644 --- a/src/DimensionalQuantities.Tests/Numerics/RationalTests.Text.cs +++ b/src/DimensionalQuantities.Tests/Numerics/RationalTests.Text.cs @@ -1,143 +1,154 @@ using System.Globalization; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Numerics; public sealed partial class RationalTests { - [Theory] - [InlineData("6/8", 3, 4)] - [InlineData(" 6 / -8 ", -3, 4)] - [InlineData("7", 7, 1)] - [InlineData("0/15", 0, 1)] - public void ParsingNormalisesFractions(string text, int numerator, int denominator) + [Test] + [Arguments("6/8", 3, 4)] + [Arguments(" 6 / -8 ", -3, 4)] + [Arguments("7", 7, 1)] + [Arguments("0/15", 0, 1)] + public async Task ParsingNormalisesFractions(string text, int numerator, int denominator) { Rational result = Rational.Parse(text, CultureInfo.InvariantCulture); Rational expected = new(numerator, denominator); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData((string?)null)] - [InlineData("")] - [InlineData("1/0")] - [InlineData("1/2/3")] - [InlineData("x/2")] - [InlineData("1/")] - public void TryParseRejectsInvalidFractions(string? text) + [Test] + [Arguments((string?)null)] + [Arguments("")] + [Arguments("1/0")] + [Arguments("1/2/3")] + [Arguments("x/2")] + [Arguments("1/")] + public async Task TryParseRejectsInvalidFractions(string? text) { bool success = Rational.TryParse(text, CultureInfo.InvariantCulture, out Rational result); Rational expected = default; - Assert.Multiple( - () => Assert.False(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsFalse(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("Seventeen", 17, 1)] - [InlineData("TwoThirds", 2, 3)] - [InlineData("MinusThreeOverTwo", -3, 2)] - [InlineData("TwoOverFour", 1, 2)] - public void TryParseAcceptsEnglishNames(string text, int numerator, int denominator) + [Test] + [Arguments("Seventeen", 17, 1)] + [Arguments("TwoThirds", 2, 3)] + [Arguments("MinusThreeOverTwo", -3, 2)] + [Arguments("TwoOverFour", 1, 2)] + public async Task TryParseAcceptsEnglishNames(string text, int numerator, int denominator) { bool success = Rational.TryParse(text, CultureInfo.InvariantCulture, out Rational result); Rational expected = new(numerator, denominator); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void TryParseWithNumberStylesAcceptsEnglishNames() + [Test] + public async Task TryParseWithNumberStylesAcceptsEnglishNames() { bool success = Rational.TryParse("OneHundredAndTwentyThreeOverFortyFive", NumberStyles.Integer, CultureInfo.InvariantCulture, out Rational result); Rational expected = new(41, 15); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData("OneOverZero")] - [InlineData("OneTwo")] - [InlineData("One/Two")] - public void TryParseRejectsInvalidEnglishNames(string text) + [Test] + [Arguments("OneOverZero")] + [Arguments("OneTwo")] + [Arguments("One/Two")] + public async Task TryParseRejectsInvalidEnglishNames(string text) { bool success = Rational.TryParse(text, CultureInfo.InvariantCulture, out Rational result); Rational expected = default; - Assert.Multiple( - () => Assert.False(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsFalse(); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void TryParseHonoursComponentNumberStyles() + [Test] + public async Task TryParseHonoursComponentNumberStyles() { bool success = Rational.TryParse("1,000/2,000", NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out Rational result); Rational expected = new(1, 2); - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(success).IsTrue(); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void ParseRejectsZeroDenominator() + [Test] + public async Task ParseRejectsZeroDenominator() { - Assert.Throws(() => Rational.Parse("1/0", CultureInfo.InvariantCulture)); + await Assert.That(() => Rational.Parse("1/0", CultureInfo.InvariantCulture)).ThrowsExactly(); } - [Fact] - public void ParseHonoursComponentNumberStyles() + [Test] + public async Task ParseHonoursComponentNumberStyles() { Rational result = Rational.Parse("1,000/2,000", NumberStyles.AllowThousands, CultureInfo.InvariantCulture); Rational expected = new(1, 2); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void FormattingProducesReducedFraction() + [Test] + public async Task FormattingProducesReducedFraction() { Rational original = new(-6, 8); string result = original.ToString(null, CultureInfo.InvariantCulture); string expected = "-3/4"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void FormattingWholeNumbersOmitsDenominator() + [Test] + public async Task FormattingWholeNumbersOmitsDenominator() { Rational original = new(6, 2); string result = original.ToString(null, CultureInfo.InvariantCulture); string expected = "3"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void StringFormattingAndParsingRoundTrip() + [Test] + public async Task StringFormattingAndParsingRoundTrip() { Rational original = new(-3, 4); string formattedText = original.ToString(null, CultureInfo.InvariantCulture); bool parsed = Rational.TryParse(formattedText, CultureInfo.InvariantCulture, out Rational result); Rational expected = new(-3, 4); - Assert.Multiple( - () => Assert.True(parsed), - () => Assert.Equal("-3/4", formattedText), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(parsed).IsTrue(); + await Assert.That(formattedText).IsEqualTo("-3/4"); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void FormattingAndParsingHonourCulture() + [Test] + public async Task FormattingAndParsingHonourCulture() { Rational original = new(-3, 4); NumberFormatInfo provider = new() { NegativeSign = "−" }; @@ -145,9 +156,11 @@ public void FormattingAndParsingHonourCulture() bool parsed = Rational.TryParse(formattedText, provider, out Rational result); Rational expected = new(-3, 4); - Assert.Multiple( - () => Assert.True(parsed), - () => Assert.Equal("−3/4", formattedText), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(parsed).IsTrue(); + await Assert.That(formattedText).IsEqualTo("−3/4"); + await Assert.That(result).IsEqualTo(expected); + } } } diff --git a/src/DimensionalQuantities.Tests/Numerics/RationalTests.cs b/src/DimensionalQuantities.Tests/Numerics/RationalTests.cs index 2ca5a74..e7ecd69 100644 --- a/src/DimensionalQuantities.Tests/Numerics/RationalTests.cs +++ b/src/DimensionalQuantities.Tests/Numerics/RationalTests.cs @@ -1,277 +1,294 @@ using System.Numerics; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Numerics; public sealed partial class RationalTests { - [Fact] - public void ConstructionReducesFractionToLowestTerms() + [Test] + public async Task ConstructionReducesFractionToLowestTerms() { Rational result = new(6, 8); - Assert.Multiple( - () => Assert.Equal(3, result.Numerator), - () => Assert.Equal(4, result.Denominator)); + using (Assert.Multiple()) + { + await Assert.That(result.Numerator).IsEqualTo(3); + await Assert.That(result.Denominator).IsEqualTo(4); + } } - [Fact] - public void NegativeDenominatorMovesSignToNumerator() + [Test] + public async Task NegativeDenominatorMovesSignToNumerator() { Rational result = new(2, -4); Rational expected = new(-1, 2); - Assert.Multiple( - () => Assert.Equal(-1, result.Numerator), - () => Assert.Equal(2, result.Denominator), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(result.Numerator).IsEqualTo(-1); + await Assert.That(result.Denominator).IsEqualTo(2); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void TwoNegativeSignsCancel() + [Test] + public async Task TwoNegativeSignsCancel() { Rational result = new(-2, -4); Rational expected = new(1, 2); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ZeroHasCanonicalDenominator() + [Test] + public async Task ZeroHasCanonicalDenominator() { Rational result = new(0, 7); Rational expected = default; - Assert.Multiple( - () => Assert.Equal(0, result.Numerator), - () => Assert.Equal(1, result.Denominator), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(result.Numerator).IsEqualTo(0); + await Assert.That(result.Denominator).IsEqualTo(1); + await Assert.That(result).IsEqualTo(expected); + } } - [Fact] - public void DefaultRepresentsZeroOverOne() + [Test] + public async Task DefaultRepresentsZeroOverOne() { Rational result = default; - Assert.Multiple( - () => Assert.Equal(0, result.Numerator), - () => Assert.Equal(1, result.Denominator)); + using (Assert.Multiple()) + { + await Assert.That(result.Numerator).IsEqualTo(0); + await Assert.That(result.Denominator).IsEqualTo(1); + } } - [Fact] - public void EquivalentFractionsHaveEqualValuesAndHashes() + [Test] + public async Task EquivalentFractionsHaveEqualValuesAndHashes() { Rational result = new(2, 4); Rational expected = new(1, 2); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Equal(expected.GetHashCode(), result.GetHashCode())); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(result.GetHashCode()).IsEqualTo(expected.GetHashCode()); + } } - [Fact] - public void IntegerConversionProducesWholeFraction() + [Test] + public async Task IntegerConversionProducesWholeFraction() { Rational result = 3; Rational expected = new(3, 1); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void AdditionCombinesDifferentDenominators() + [Test] + public async Task AdditionCombinesDifferentDenominators() { Rational original = new(1, 2); Rational operand = new(1, 3); Rational result = original + operand; Rational expected = new(5, 6); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void SubtractionCombinesDifferentDenominators() + [Test] + public async Task SubtractionCombinesDifferentDenominators() { Rational original = new(1, 3); Rational operand = new(1, 2); Rational result = original - operand; Rational expected = new(-1, 6); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void MultiplicationReducesResult() + [Test] + public async Task MultiplicationReducesResult() { Rational original = new(2, 3); Rational operand = new(3, 4); Rational result = original * operand; Rational expected = new(1, 2); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DivisionUsesReciprocal() + [Test] + public async Task DivisionUsesReciprocal() { Rational original = new(2, 3); Rational operand = new(4, 5); Rational result = original / operand; Rational expected = new(5, 6); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void DefaultZeroIsAdditiveIdentity() + [Test] + public async Task DefaultZeroIsAdditiveIdentity() { Rational original = new(2, 3); Rational zero = default; Rational result = original + zero; Rational expected = new(2, 3); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ZeroDenominatorIsRejected() + [Test] + public async Task ZeroDenominatorIsRejected() { - Assert.Throws(() => new Rational(1, 0)); + await Assert.That(() => new Rational(1, 0)).ThrowsExactly(); } - [Fact] - public void DivisionByZeroIsRejected() + [Test] + public async Task DivisionByZeroIsRejected() { Rational original = new(1, 2); Rational zero = default; - Assert.Throws(() => original / zero); + await Assert.That(() => original / zero).ThrowsExactly(); } - [Fact] - public void ComparisonUsesFractionValues() + [Test] + public async Task ComparisonUsesFractionValues() { Rational original = new(-1, 2); Rational other = new(-1, 3); - Assert.Multiple( - () => Assert.True(original < other), - () => Assert.True(original <= other), - () => Assert.True(other > original), - () => Assert.True(other >= original), - () => Assert.Equal(-1, original.CompareTo(other)), - () => Assert.Equal(-1, original.CompareTo((object)other))); + using (Assert.Multiple()) + { + await Assert.That(original < other).IsTrue(); + await Assert.That(original <= other).IsTrue(); + await Assert.That(other > original).IsTrue(); + await Assert.That(other >= original).IsTrue(); + await Assert.That(original.CompareTo(other)).IsEqualTo(-1); + await Assert.That(original.CompareTo((object)other)).IsEqualTo(-1); + } } - [Fact] - public void RemainderUsesQuotientTruncatedTowardsZero() + [Test] + public async Task RemainderUsesQuotientTruncatedTowardsZero() { Rational original = new(-7, 3); Rational divisor = new(1, 2); Rational result = original % divisor; Rational expected = new(-1, 3); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void UnaryPlusPreservesValue() + [Test] + public async Task UnaryPlusPreservesValue() { Rational original = new(1, 3); Rational result = +original; Rational expected = original; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void UnaryMinusNegatesValue() + [Test] + public async Task UnaryMinusNegatesValue() { Rational original = new(1, 3); Rational result = -original; Rational expected = new(-1, 3); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void IncrementAddsOneAndPreservesOriginalValue() + [Test] + public async Task IncrementAddsOneAndPreservesOriginalValue() { Rational original = new(1, 3); Rational result = original; result++; Rational expected = new(4, 3); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Equal(new Rational(1, 3), original)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(original).IsEqualTo(new Rational(1, 3)); + } } - [Fact] - public void DecrementSubtractsOneAndPreservesOriginalValue() + [Test] + public async Task DecrementSubtractsOneAndPreservesOriginalValue() { Rational original = new(4, 3); Rational result = original; result--; Rational expected = new(1, 3); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Equal(new Rational(4, 3), original)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(original).IsEqualTo(new Rational(4, 3)); + } } - [Fact] - public void ClassificationDistinguishesFractionsAndIntegers() + [Test] + public async Task ClassificationDistinguishesFractionsAndIntegers() { Rational fraction = new(-3, 2); Rational even = new(8, 2); Rational odd = new(-6, 2); - Assert.Multiple( - () => Assert.True(Rational.IsFinite(fraction)), - () => Assert.True(Rational.IsRealNumber(fraction)), - () => Assert.True(Rational.IsNormal(fraction)), - () => Assert.True(Rational.IsNegative(fraction)), - () => Assert.False(Rational.IsInteger(fraction)), - () => Assert.False(Rational.IsEvenInteger(fraction)), - () => Assert.False(Rational.IsOddInteger(fraction)), - () => Assert.True(Rational.IsEvenInteger(even)), - () => Assert.True(Rational.IsOddInteger(odd)), - () => Assert.True(Rational.IsZero(default)), - () => Assert.False(Rational.IsNormal(default))); + using (Assert.Multiple()) + { + await Assert.That(Rational.IsFinite(fraction)).IsTrue(); + await Assert.That(Rational.IsRealNumber(fraction)).IsTrue(); + await Assert.That(Rational.IsNormal(fraction)).IsTrue(); + await Assert.That(Rational.IsNegative(fraction)).IsTrue(); + await Assert.That(Rational.IsInteger(fraction)).IsFalse(); + await Assert.That(Rational.IsEvenInteger(fraction)).IsFalse(); + await Assert.That(Rational.IsOddInteger(fraction)).IsFalse(); + await Assert.That(Rational.IsEvenInteger(even)).IsTrue(); + await Assert.That(Rational.IsOddInteger(odd)).IsTrue(); + await Assert.That(Rational.IsZero(default)).IsTrue(); + await Assert.That(Rational.IsNormal(default)).IsFalse(); + } } - [Fact] - public void EqualMagnitudesPreferPositiveForMaximum() + [Test] + public async Task EqualMagnitudesPreferPositiveForMaximum() { Rational original = new(-2, 3); Rational positive = new(2, 3); Rational result = Rational.MaxMagnitude(original, positive); Rational expected = positive; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void EqualMagnitudesPreferNegativeForMinimum() + [Test] + public async Task EqualMagnitudesPreferNegativeForMinimum() { Rational original = new(-2, 3); Rational positive = new(2, 3); Rational result = Rational.MinMagnitude(positive, original); Rational expected = original; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void AbsoluteValueMakesNegativeFractionPositive() + [Test] + public async Task AbsoluteValueMakesNegativeFractionPositive() { Rational original = new(-2, 3); Rational result = Rational.Abs(original); Rational expected = new(2, 3); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } } diff --git a/src/DimensionalQuantities.Tests/TypeSystem/QuantityTests.cs b/src/DimensionalQuantities.Tests/TypeSystem/QuantityTests.cs index 863a24c..bcaf462 100644 --- a/src/DimensionalQuantities.Tests/TypeSystem/QuantityTests.cs +++ b/src/DimensionalQuantities.Tests/TypeSystem/QuantityTests.cs @@ -1,5 +1,4 @@ using DimensionalQuantities.TypeSystem; -using Xunit; using AllAxes = DimensionalQuantities.TypeSystem.Quantity Assert.Equal(less, left < right), - () => Assert.Equal(greater, left > right), - () => Assert.Equal(lessOrEqual, left <= right), - () => Assert.Equal(greaterOrEqual, left >= right)); + using (Assert.Multiple()) + { + await Assert.That(left < right).IsEqualTo(less); + await Assert.That(left > right).IsEqualTo(greater); + await Assert.That(left <= right).IsEqualTo(lessOrEqual); + await Assert.That(left >= right).IsEqualTo(greaterOrEqual); + } } - [Fact] - public void RelationalOperatorsReturnFalseForNanOnEitherSide() + [Test] + public async Task RelationalOperatorsReturnFalseForNanOnEitherSide() { Current nan = Current.FromSiBaseUnit(double.NaN); Current finite = Current.FromSiBaseUnit(1); - Assert.Multiple( - () => Assert.False(nan < finite), - () => Assert.False(nan > finite), - () => Assert.False(nan <= finite), - () => Assert.False(nan >= finite), - () => Assert.False(finite < nan), - () => Assert.False(finite > nan), - () => Assert.False(finite <= nan), - () => Assert.False(finite >= nan)); + using (Assert.Multiple()) + { + await Assert.That(nan < finite).IsFalse(); + await Assert.That(nan > finite).IsFalse(); + await Assert.That(nan <= finite).IsFalse(); + await Assert.That(nan >= finite).IsFalse(); + await Assert.That(finite < nan).IsFalse(); + await Assert.That(finite > nan).IsFalse(); + await Assert.That(finite <= nan).IsFalse(); + await Assert.That(finite >= nan).IsFalse(); + } } - [Theory] - [InlineData(-3, 3)] - [InlineData(3, 3)] - [InlineData(double.NegativeInfinity, double.PositiveInfinity)] - public void AbsReturnsQuantityWithAbsoluteSiMagnitude(double value, double expectedValue) + [Test] + [Arguments(-3, 3)] + [Arguments(3, 3)] + [Arguments(double.NegativeInfinity, double.PositiveInfinity)] + public async Task AbsReturnsQuantityWithAbsoluteSiMagnitude(double value, double expectedValue) { Current original = Current.FromSiBaseUnit(value); Current result = Current.Abs(original); Current expected = Current.FromSiBaseUnit(expectedValue); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(2, 3, 2, 3)] - [InlineData(3, 2, 2, 3)] - [InlineData(-2, -2, -2, -2)] - public void MinAndMaxReturnMatchingDimension(double leftValue, double rightValue, double expectedMinValue, double expectedMaxValue) + [Test] + [Arguments(2, 3, 2, 3)] + [Arguments(3, 2, 2, 3)] + [Arguments(-2, -2, -2, -2)] + public async Task MinAndMaxReturnMatchingDimension(double leftValue, double rightValue, double expectedMinValue, double expectedMaxValue) { Current left = Current.FromSiBaseUnit(leftValue); Current right = Current.FromSiBaseUnit(rightValue); @@ -105,16 +108,18 @@ public void MinAndMaxReturnMatchingDimension(double leftValue, double rightValue Current expectedMin = Current.FromSiBaseUnit(expectedMinValue); Current expectedMax = Current.FromSiBaseUnit(expectedMaxValue); - Assert.Multiple( - () => Assert.Equal(expectedMin, minResult), - () => Assert.Equal(expectedMax, maxResult)); + using (Assert.Multiple()) + { + await Assert.That(minResult).IsEqualTo(expectedMin); + await Assert.That(maxResult).IsEqualTo(expectedMax); + } } - [Theory] - [InlineData(-2, 0, 10, 0)] - [InlineData(5, 0, 10, 5)] - [InlineData(12, 0, 10, 10)] - public void ClampReturnsQuantityWithinBounds(double value, double minValue, double maxValue, double expectedValue) + [Test] + [Arguments(-2, 0, 10, 0)] + [Arguments(5, 0, 10, 5)] + [Arguments(12, 0, 10, 10)] + public async Task ClampReturnsQuantityWithinBounds(double value, double minValue, double maxValue, double expectedValue) { Current original = Current.FromSiBaseUnit(value); Current min = Current.FromSiBaseUnit(minValue); @@ -122,21 +127,21 @@ public void ClampReturnsQuantityWithinBounds(double value, double minValue, doub Current result = Current.Clamp(original, min, max); Current expected = Current.FromSiBaseUnit(expectedValue); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ClampRejectsReversedBounds() + [Test] + public async Task ClampRejectsReversedBounds() { Current original = Current.FromSiBaseUnit(5); Current min = Current.FromSiBaseUnit(10); Current max = Current.FromSiBaseUnit(0); - Assert.Throws(() => Current.Clamp(original, min, max)); + await Assert.That(() => Current.Clamp(original, min, max)).ThrowsExactly(); } - [Fact] - public void HelpersFollowDoubleNanAndSignedZeroBehavior() + [Test] + public async Task HelpersFollowDoubleNanAndSignedZeroBehavior() { Current nan = Current.FromSiBaseUnit(double.NaN); Current finite = Current.FromSiBaseUnit(1); @@ -147,73 +152,75 @@ public void HelpersFollowDoubleNanAndSignedZeroBehavior() Current nanMinimumResult = Current.Clamp(Current.FromSiBaseUnit(2), nan, finite); Current nanMaximumResult = Current.Clamp(Current.FromSiBaseUnit(-1), positiveZero, nan); - Assert.Multiple( - () => Assert.True(double.IsNaN(Current.Abs(nan).AsSiBaseUnit())), - () => Assert.True(double.IsNaN(Current.Min(nan, finite).AsSiBaseUnit())), - () => Assert.True(double.IsNaN(Current.Max(finite, nan).AsSiBaseUnit())), - () => Assert.True(double.IsNaN(Current.Clamp(nan, negativeZero, finite).AsSiBaseUnit())), - () => Assert.Equal(finite, nanMinimumResult), - () => Assert.Equal(positiveZero, nanMaximumResult), - () => Assert.Equal(0L, BitConverter.DoubleToInt64Bits(absResult.AsSiBaseUnit())), - () => Assert.Equal(long.MinValue, BitConverter.DoubleToInt64Bits(clampResult.AsSiBaseUnit()))); + using (Assert.Multiple()) + { + await Assert.That(double.IsNaN(Current.Abs(nan).AsSiBaseUnit())).IsTrue(); + await Assert.That(double.IsNaN(Current.Min(nan, finite).AsSiBaseUnit())).IsTrue(); + await Assert.That(double.IsNaN(Current.Max(finite, nan).AsSiBaseUnit())).IsTrue(); + await Assert.That(double.IsNaN(Current.Clamp(nan, negativeZero, finite).AsSiBaseUnit())).IsTrue(); + await Assert.That(nanMinimumResult).IsEqualTo(finite); + await Assert.That(nanMaximumResult).IsEqualTo(positiveZero); + await Assert.That(BitConverter.DoubleToInt64Bits(absResult.AsSiBaseUnit())).IsEqualTo(0L); + await Assert.That(BitConverter.DoubleToInt64Bits(clampResult.AsSiBaseUnit())).IsEqualTo(long.MinValue); + } } - [Theory] - [InlineData(6, 2, 3)] - [InlineData(-6, 2, -3)] - [InlineData(0, 2, 0)] - public void DividingMatchingDimensionsReturnsDouble(double numerator, double denominator, double expected) + [Test] + [Arguments(6, 2, 3)] + [Arguments(-6, 2, -3)] + [Arguments(0, 2, 0)] + public async Task DividingMatchingDimensionsReturnsDouble(double numerator, double denominator, double expected) { SquareRootLength original = SquareRootLength.FromSiBaseUnit(numerator); SquareRootLength divisor = SquareRootLength.FromSiBaseUnit(denominator); double result = original / divisor; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(3, 2, 5)] - [InlineData(-3, 2, -1)] - [InlineData(3, -3, 0)] - public void AdditionPreservesDimensionAndAddsSiMagnitudes(double first, double second, double expectedValue) + [Test] + [Arguments(3, 2, 5)] + [Arguments(-3, 2, -1)] + [Arguments(3, -3, 0)] + public async Task AdditionPreservesDimensionAndAddsSiMagnitudes(double first, double second, double expectedValue) { Current original = Current.FromSiBaseUnit(first); Current other = Current.FromSiBaseUnit(second); Current result = original + other; Current expected = Current.FromSiBaseUnit(expectedValue); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(3, 2, 1)] - [InlineData(2, 3, -1)] - [InlineData(-3, -3, 0)] - public void SubtractionPreservesDimensionAndSubtractsSiMagnitudes(double first, double second, double expectedValue) + [Test] + [Arguments(3, 2, 1)] + [Arguments(2, 3, -1)] + [Arguments(-3, -3, 0)] + public async Task SubtractionPreservesDimensionAndSubtractsSiMagnitudes(double first, double second, double expectedValue) { Current original = Current.FromSiBaseUnit(first); Current other = Current.FromSiBaseUnit(second); Current result = original - other; Current expected = Current.FromSiBaseUnit(expectedValue); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(3, -3)] - [InlineData(-3, 3)] - [InlineData(0, 0)] - public void NegationPreservesDimensionAndReversesSign(double value, double expectedValue) + [Test] + [Arguments(3, -3)] + [Arguments(-3, 3)] + [Arguments(0, 0)] + public async Task NegationPreservesDimensionAndReversesSign(double value, double expectedValue) { SquareRootLength original = SquareRootLength.FromSiBaseUnit(value); SquareRootLength result = -original; SquareRootLength expected = SquareRootLength.FromSiBaseUnit(expectedValue); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void MultiplyingAndDividingByScalarsPreservesQuantityTypeAndSiMagnitude() + [Test] + public async Task MultiplyingAndDividingByScalarsPreservesQuantityTypeAndSiMagnitude() { Current original = Current.FromSiBaseUnit(6); Current rightProduct = original * 2; @@ -222,84 +229,88 @@ public void MultiplyingAndDividingByScalarsPreservesQuantityTypeAndSiMagnitude() Current expectedProduct = Current.FromSiBaseUnit(12); Current expectedQuotient = Current.FromSiBaseUnit(3); - Assert.Multiple( - () => Assert.Equal(expectedProduct, rightProduct), - () => Assert.Equal(expectedProduct, leftProduct), - () => Assert.Equal(expectedQuotient, quotient)); + using (Assert.Multiple()) + { + await Assert.That(rightProduct).IsEqualTo(expectedProduct); + await Assert.That(leftProduct).IsEqualTo(expectedProduct); + await Assert.That(quotient).IsEqualTo(expectedQuotient); + } } - [Theory] - [InlineData(0)] - [InlineData(-0.125)] - [InlineData(1234.5)] - public void ConstructionPreservesSiMagnitude(double expected) + [Test] + [Arguments(0)] + [Arguments(-0.125)] + [Arguments(1234.5)] + public async Task ConstructionPreservesSiMagnitude(double expected) { Current original = Current.FromSiBaseUnit(expected); double result = original.AsSiBaseUnit(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(0)] - [InlineData(-4.5)] - [InlineData(12.25)] - public void AsDeltaPreservesSiMagnitudeForAnyQuantity(double expected) + [Test] + [Arguments(0)] + [Arguments(-4.5)] + [Arguments(12.25)] + public async Task AsDeltaPreservesSiMagnitudeForAnyQuantity(double expected) { Current original = Current.FromSiBaseUnit(expected); Delta result = original.AsDelta(); - Assert.Equal(expected, result.AsSiBaseUnit()); + await Assert.That(result.AsSiBaseUnit()).IsEqualTo(expected); } - [Theory] - [InlineData(20, 10, 10)] - [InlineData(10, 10, 0)] - [InlineData(10, 20, -10)] - public void AsDeltaUsesTheMagnitudeAfterSubtraction(double firstValue, double secondValue, double expected) + [Test] + [Arguments(20, 10, 10)] + [Arguments(10, 10, 0)] + [Arguments(10, 20, -10)] + public async Task AsDeltaUsesTheMagnitudeAfterSubtraction(double firstValue, double secondValue, double expected) { Length first = Length.FromSiBaseUnit(firstValue); Length second = Length.FromSiBaseUnit(secondValue); Delta result = (first - second).AsDelta(); - Assert.Equal(expected, result.AsSiBaseUnit()); + await Assert.That(result.AsSiBaseUnit()).IsEqualTo(expected); } - [Fact] - public void ArbitraryComponentsUseKilogramsByDefaultAndAllowGrams() + [Test] + public async Task ArbitraryComponentsUseKilogramsByDefaultAndAllowGrams() { Mass original = Mass.FromArbitrarySiComponents(2, massPrefixExponent: 0); double siResult = original.AsSiBaseUnit(); double gramResult = original.AsArbitrarySiComponents(massPrefixExponent: 0); - Assert.Multiple( - () => Assert.Equal(0.002, siResult), - () => Assert.Equal(2, gramResult), - () => Assert.Equal(2, Mass.FromArbitrarySiComponents(2).AsSiBaseUnit())); + using (Assert.Multiple()) + { + await Assert.That(siResult).IsEqualTo(0.002); + await Assert.That(gramResult).IsEqualTo(2); + await Assert.That(Mass.FromArbitrarySiComponents(2).AsSiBaseUnit()).IsEqualTo(2); + } } - [Fact] - public void ArbitraryComponentsApplyAllSevenAxisPrefixesAndOverallScale() + [Test] + public async Task ArbitraryComponentsApplyAllSevenAxisPrefixesAndOverallScale() { AllAxes original = AllAxes.FromArbitrarySiComponents(2, 1, 0, 2, 3, 4, 5, 6, 2); double result = original.AsSiBaseUnit(); double expected = 2e25; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ArbitraryComponentsApplyFractionalDimensionPower() + [Test] + public async Task ArbitraryComponentsApplyFractionalDimensionPower() { SquareRootLength original = SquareRootLength.FromArbitrarySiComponents(4, lengthPrefixExponent: -3); double result = original.AsSiBaseUnit(); double expected = 4 * Math.Sqrt(0.001); - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] - public void ArbitraryComponentsUseEachClosedQuantityDimensionAcrossInterleavedConversions() + [Test] + public async Task ArbitraryComponentsUseEachClosedQuantityDimensionAcrossInterleavedConversions() { Length firstLength = Length.FromArbitrarySiComponents(2, lengthPrefixExponent: -2); SquareRootLength squareRootLength = SquareRootLength.FromArbitrarySiComponents(2, lengthPrefixExponent: -2); @@ -309,31 +320,35 @@ public void ArbitraryComponentsUseEachClosedQuantityDimensionAcrossInterleavedCo double secondLengthResult = secondLength.AsSiBaseUnit(); double squareRootLengthComponentsResult = squareRootLength.AsArbitrarySiComponents(lengthPrefixExponent: -2); - Assert.Multiple( - () => Assert.Equal(0.02, firstLengthResult, 12), - () => Assert.Equal(0.2, squareRootLengthResult, 12), - () => Assert.Equal(0.03, secondLengthResult, 12), - () => Assert.Equal(2, squareRootLengthComponentsResult, 12)); + using (Assert.Multiple()) + { + await Assert.That(Math.Round(firstLengthResult, 12)).IsEqualTo(Math.Round(0.02, 12)); + await Assert.That(Math.Round(squareRootLengthResult, 12)).IsEqualTo(Math.Round(0.2, 12)); + await Assert.That(Math.Round(secondLengthResult, 12)).IsEqualTo(Math.Round(0.03, 12)); + await Assert.That(Math.Round(squareRootLengthComponentsResult, 12)).IsEqualTo(Math.Round(2.0, 12)); + } } - [Fact] - public void ArbitraryComponentsAccessorAppliesPrefixAndOverallScale() + [Test] + public async Task ArbitraryComponentsAccessorAppliesPrefixAndOverallScale() { Current original = Current.FromSiBaseUnit(0.3); double result = original.AsArbitrarySiComponents(electricCurrentPrefixExponent: -3, overallScaleExponent: 2); double expected = 3; - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] - public void RawSiMagnitudeIsNotPartOfPublicApi() + [Test] + public async Task RawSiMagnitudeIsNotPartOfPublicApi() { Type quantityType = typeof(Current); - Assert.Multiple( - () => Assert.Empty(quantityType.GetProperties()), - () => Assert.Empty(quantityType.GetFields()), - () => Assert.Null(quantityType.GetConstructor([typeof(double)]))); + using (Assert.Multiple()) + { + await Assert.That(quantityType.GetProperties()).IsEmpty(); + await Assert.That(quantityType.GetFields()).IsEmpty(); + await Assert.That(quantityType.GetConstructor([typeof(double)])).IsNull(); + } } } diff --git a/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumberCodecTests.cs b/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumberCodecTests.cs index 92fe01e..812782b 100644 --- a/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumberCodecTests.cs +++ b/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumberCodecTests.cs @@ -1,58 +1,57 @@ using System.Numerics; using DimensionalQuantities.Numerics; using DimensionalQuantities.TypeSystem; -using Xunit; namespace DimensionalQuantities.Tests.TypeSystem; public sealed class TypeSystemNumberCodecTests { - [Theory] - [InlineData(typeof(TerminalHex0), 0)] - [InlineData(typeof(TerminalHex1), 1)] - [InlineData(typeof(TerminalHex2), 2)] - [InlineData(typeof(TerminalHex3), 3)] - [InlineData(typeof(TerminalHex4), 4)] - [InlineData(typeof(TerminalHex5), 5)] - [InlineData(typeof(TerminalHex6), 6)] - [InlineData(typeof(TerminalHex7), 7)] - [InlineData(typeof(TerminalHex8), 8)] - [InlineData(typeof(TerminalHex9), 9)] - [InlineData(typeof(TerminalHexA), 10)] - [InlineData(typeof(TerminalHexB), 11)] - [InlineData(typeof(TerminalHexC), 12)] - [InlineData(typeof(TerminalHexD), 13)] - [InlineData(typeof(TerminalHexE), 14)] - [InlineData(typeof(TerminalHexF), 15)] - public void ParseDecodesEachTerminalDigit(Type type, int expected) + [Test] + [Arguments(typeof(TerminalHex0), 0)] + [Arguments(typeof(TerminalHex1), 1)] + [Arguments(typeof(TerminalHex2), 2)] + [Arguments(typeof(TerminalHex3), 3)] + [Arguments(typeof(TerminalHex4), 4)] + [Arguments(typeof(TerminalHex5), 5)] + [Arguments(typeof(TerminalHex6), 6)] + [Arguments(typeof(TerminalHex7), 7)] + [Arguments(typeof(TerminalHex8), 8)] + [Arguments(typeof(TerminalHex9), 9)] + [Arguments(typeof(TerminalHexA), 10)] + [Arguments(typeof(TerminalHexB), 11)] + [Arguments(typeof(TerminalHexC), 12)] + [Arguments(typeof(TerminalHexD), 13)] + [Arguments(typeof(TerminalHexE), 14)] + [Arguments(typeof(TerminalHexF), 15)] + public async Task ParseDecodesEachTerminalDigit(Type type, int expected) { Rational expectedValue = new(expected); Rational result = TypeSystemNumberCodec.Parse(type); - Assert.Equal(expectedValue, result); + await Assert.That(result).IsEqualTo(expectedValue); } - public static TheoryData NumberCases => new() + public static IEnumerable<(Func, int, int)> NumberCases() => + [ + (() => TypeSystemNumberCodec.Parse>>(), 291, 1), + (() => TypeSystemNumberCodec.Parse>>(), -43, 1), + (() => TypeSystemNumberCodec.Parse>(), 1, 2), + (() => TypeSystemNumberCodec.Parse, TerminalHex2>>(), -3, 2), + (() => TypeSystemNumberCodec.Parse>(), 0, 1) + ]; + + [Test] + [MethodDataSource(nameof(NumberCases))] + public async Task ParseGenericDecodesNumber(Func parse, int numerator, int denominator) { - { new Hex>(), 291, 1 }, - { new Negative>(), -43, 1 }, - { new Fraction(), 1, 2 }, - { new Fraction, TerminalHex2>(), -3, 2 }, - { new Fraction(), 0, 1 } - }; - - [Theory] - [MemberData(nameof(NumberCases))] - public void ParseGenericDecodesNumber(T _, int numerator, int denominator) where T : ITypeSystemNumber - { - Rational result = TypeSystemNumberCodec.Parse(); + Rational result = (Rational)parse(); Rational expected = new(numerator, denominator); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void ParseTypeDecodesIntegerBeyondLongRange() + [Test] + public async Task ParseTypeDecodesIntegerBeyondLongRange() { Type encoding = typeof(TerminalHex1); for (int index = 0; index < 16; index++) @@ -63,29 +62,29 @@ public void ParseTypeDecodesIntegerBeyondLongRange() Rational expected = new(BigInteger.One << 64); Rational result = TypeSystemNumberCodec.Parse(encoding); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(0, 1, typeof(TerminalHex0))] - [InlineData(1, 1, typeof(TerminalHex1))] - [InlineData(15, 1, typeof(TerminalHexF))] - [InlineData(16, 1, typeof(Hex))] - [InlineData(291, 1, typeof(Hex>))] - [InlineData(-43, 1, typeof(Negative>))] - [InlineData(-3, 2, typeof(Fraction, TerminalHex2>))] - [InlineData(2, 4, typeof(Fraction))] - [InlineData(0, 2, typeof(TerminalHex0))] - public void CreateTypeUsesCanonicalEncoding(int numerator, int denominator, Type expected) + [Test] + [Arguments(0, 1, typeof(TerminalHex0))] + [Arguments(1, 1, typeof(TerminalHex1))] + [Arguments(15, 1, typeof(TerminalHexF))] + [Arguments(16, 1, typeof(Hex))] + [Arguments(291, 1, typeof(Hex>))] + [Arguments(-43, 1, typeof(Negative>))] + [Arguments(-3, 2, typeof(Fraction, TerminalHex2>))] + [Arguments(2, 4, typeof(Fraction))] + [Arguments(0, 2, typeof(TerminalHex0))] + public async Task CreateTypeUsesCanonicalEncoding(int numerator, int denominator, Type expected) { Rational value = new(numerator, denominator); Type result = TypeSystemNumberCodec.CreateType(value); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void CreateTypePreservesLargeExactFraction() + [Test] + public async Task CreateTypePreservesLargeExactFraction() { BigInteger numerator = (BigInteger.One << 80) + 3; BigInteger denominator = (BigInteger.One << 65) + 2; @@ -94,25 +93,27 @@ public void CreateTypePreservesLargeExactFraction() Type encoding = TypeSystemNumberCodec.CreateType(expected); Rational result = TypeSystemNumberCodec.Parse(encoding); - Assert.Multiple( - () => Assert.Equal(typeof(Fraction<,>), encoding.GetGenericTypeDefinition()), - () => Assert.Equal(expected, result)); + using (Assert.Multiple()) + { + await Assert.That(encoding.GetGenericTypeDefinition()).IsEqualTo(typeof(Fraction<,>)); + await Assert.That(result).IsEqualTo(expected); + } } - [Theory] - [InlineData(typeof(int))] - [InlineData(typeof(CustomNumber))] - [InlineData(typeof(Hex))] - [InlineData(typeof(Hex<,>))] - public void ParseTypeRejectsUnsupportedTypesAndMarkerImplementations(Type type) + [Test] + [Arguments(typeof(int))] + [Arguments(typeof(CustomNumber))] + [Arguments(typeof(Hex))] + [Arguments(typeof(Hex<,>))] + public async Task ParseTypeRejectsUnsupportedTypesAndMarkerImplementations(Type type) { - Assert.Throws(() => TypeSystemNumberCodec.Parse(type)); + await Assert.That(() => TypeSystemNumberCodec.Parse(type)).ThrowsExactly(); } - [Fact] - public void ParseGenericRejectsUnsupportedMarkerImplementation() + [Test] + public async Task ParseGenericRejectsUnsupportedMarkerImplementation() { - Assert.Throws(() => TypeSystemNumberCodec.Parse()); + await Assert.That(() => TypeSystemNumberCodec.Parse()).ThrowsExactly(); } private readonly struct CustomNumber : ITypeSystemNumber; diff --git a/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumbersTests.cs b/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumbersTests.cs index b1b9749..c5b4cb9 100644 --- a/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumbersTests.cs +++ b/src/DimensionalQuantities.Tests/TypeSystem/TypeSystemNumbersTests.cs @@ -1,67 +1,66 @@ using DimensionalQuantities.TypeSystem; -using Xunit; namespace DimensionalQuantities.Tests.TypeSystem; public sealed class TypeSystemNumbersTests { - [Theory] - [InlineData(typeof(TerminalHex0), typeof(TerminalHex1))] - [InlineData(typeof(TerminalHexF), typeof(Hex))] - public void HexAcceptsDigitsAndPositiveRemainders(Type digit, Type remainder) + [Test] + [Arguments(typeof(TerminalHex0), typeof(TerminalHex1))] + [Arguments(typeof(TerminalHexF), typeof(Hex))] + public async Task HexAcceptsDigitsAndPositiveRemainders(Type digit, Type remainder) { Type result = typeof(Hex<,>).MakeGenericType(digit, remainder); - Assert.True(typeof(IPositiveTypeSystemInteger).IsAssignableFrom(result)); + await Assert.That(typeof(IPositiveTypeSystemInteger).IsAssignableFrom(result)).IsTrue(); } - [Theory] - [InlineData(typeof(int), typeof(TerminalHex1))] - [InlineData(typeof(Hex), typeof(TerminalHex1))] - [InlineData(typeof(Fraction), typeof(TerminalHex1))] - [InlineData(typeof(TerminalHexC), typeof(TerminalHex0))] - [InlineData(typeof(TerminalHexC), typeof(Negative))] - public void HexRejectsNonDigitsAndNonPositiveRemainders(Type digit, Type remainder) + [Test] + [Arguments(typeof(int), typeof(TerminalHex1))] + [Arguments(typeof(Hex), typeof(TerminalHex1))] + [Arguments(typeof(Fraction), typeof(TerminalHex1))] + [Arguments(typeof(TerminalHexC), typeof(TerminalHex0))] + [Arguments(typeof(TerminalHexC), typeof(Negative))] + public async Task HexRejectsNonDigitsAndNonPositiveRemainders(Type digit, Type remainder) { - Assert.Throws(() => typeof(Hex<,>).MakeGenericType(digit, remainder)); + await Assert.That(() => typeof(Hex<,>).MakeGenericType(digit, remainder)).ThrowsExactly(); } - [Theory] - [InlineData(typeof(TerminalHexC))] - [InlineData(typeof(Hex))] - public void NegativeAcceptsPositiveIntegerMagnitudes(Type magnitude) + [Test] + [Arguments(typeof(TerminalHexC))] + [Arguments(typeof(Hex))] + public async Task NegativeAcceptsPositiveIntegerMagnitudes(Type magnitude) { Type result = typeof(Negative<>).MakeGenericType(magnitude); - Assert.True(typeof(ITypeSystemInteger).IsAssignableFrom(result)); + await Assert.That(typeof(ITypeSystemInteger).IsAssignableFrom(result)).IsTrue(); } - [Theory] - [InlineData(typeof(TerminalHex0))] - [InlineData(typeof(Negative))] - [InlineData(typeof(Fraction))] - public void NegativeRejectsZeroNegativeAndFractionalMagnitudes(Type magnitude) + [Test] + [Arguments(typeof(TerminalHex0))] + [Arguments(typeof(Negative))] + [Arguments(typeof(Fraction))] + public async Task NegativeRejectsZeroNegativeAndFractionalMagnitudes(Type magnitude) { - Assert.Throws(() => typeof(Negative<>).MakeGenericType(magnitude)); + await Assert.That(() => typeof(Negative<>).MakeGenericType(magnitude)).ThrowsExactly(); } - [Theory] - [InlineData(typeof(TerminalHex1), typeof(TerminalHex2))] - [InlineData(typeof(Negative), typeof(Hex))] - public void FractionAcceptsSignedIntegerNumeratorsAndPositiveDenominators(Type numerator, Type denominator) + [Test] + [Arguments(typeof(TerminalHex1), typeof(TerminalHex2))] + [Arguments(typeof(Negative), typeof(Hex))] + public async Task FractionAcceptsSignedIntegerNumeratorsAndPositiveDenominators(Type numerator, Type denominator) { Type result = typeof(Fraction<,>).MakeGenericType(numerator, denominator); - Assert.True(typeof(ITypeSystemNumber).IsAssignableFrom(result)); + await Assert.That(typeof(ITypeSystemNumber).IsAssignableFrom(result)).IsTrue(); } - [Theory] - [InlineData(typeof(Fraction), typeof(TerminalHex2))] - [InlineData(typeof(TerminalHex1), typeof(TerminalHex0))] - [InlineData(typeof(TerminalHex1), typeof(Negative))] - [InlineData(typeof(TerminalHex1), typeof(Fraction))] - public void FractionRejectsFractionalComponentsAndNonPositiveDenominators(Type numerator, Type denominator) + [Test] + [Arguments(typeof(Fraction), typeof(TerminalHex2))] + [Arguments(typeof(TerminalHex1), typeof(TerminalHex0))] + [Arguments(typeof(TerminalHex1), typeof(Negative))] + [Arguments(typeof(TerminalHex1), typeof(Fraction))] + public async Task FractionRejectsFractionalComponentsAndNonPositiveDenominators(Type numerator, Type denominator) { - Assert.Throws(() => typeof(Fraction<,>).MakeGenericType(numerator, denominator)); + await Assert.That(() => typeof(Fraction<,>).MakeGenericType(numerator, denominator)).ThrowsExactly(); } } diff --git a/src/DimensionalQuantities.Tests/Units/UnitExpressionTests.cs b/src/DimensionalQuantities.Tests/Units/UnitExpressionTests.cs index 221f677..bf5ca98 100644 --- a/src/DimensionalQuantities.Tests/Units/UnitExpressionTests.cs +++ b/src/DimensionalQuantities.Tests/Units/UnitExpressionTests.cs @@ -1,6 +1,5 @@ using DimensionalQuantities.Units; using DimensionalQuantities.Numerics; -using Xunit; namespace DimensionalQuantities.Tests.Units; @@ -9,47 +8,47 @@ public sealed class UnitExpressionTests private static readonly AtomicUnit _newton = new("Newton", "Newtons", "N"); private static readonly AtomicUnit _volt = new("Volt", "Volts", "V"); private static readonly AtomicUnit _watt = new("Watt", "Watts", "W"); - [Theory] - [InlineData(1, "Metres")] - [InlineData(2, "SquareMetres")] - [InlineData(3, "CubicMetres")] - [InlineData(5, "Power5Metres")] - public void GetNameFormatsAtomicPowers(int power, string expected) + [Test] + [Arguments(1, "Metres")] + [Arguments(2, "SquareMetres")] + [Arguments(3, "CubicMetres")] + [Arguments(5, "Power5Metres")] + public async Task GetNameFormatsAtomicPowers(int power, string expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, power)); string result = original.GetName(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 2, "SquareRootMetres")] - [InlineData(3, 2, "SquareRootCubicMetres")] - [InlineData(2, 3, "CubeRootSquareMetres")] - [InlineData(1, 4, "Root4Metres")] - [InlineData(-1, 2, "InverseSquareRootMetre")] - public void GetNameFormatsFractionalPowers(int numerator, int denominator, string expected) + [Test] + [Arguments(1, 2, "SquareRootMetres")] + [Arguments(3, 2, "SquareRootCubicMetres")] + [Arguments(2, 3, "CubeRootSquareMetres")] + [Arguments(1, 4, "Root4Metres")] + [Arguments(-1, 2, "InverseSquareRootMetre")] + public async Task GetNameFormatsFractionalPowers(int numerator, int denominator, string expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, new Rational(numerator, denominator))); string result = original.GetName(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 12, "Root12Amps")] - [InlineData(4, 5, "Root5Power4Amps")] - [InlineData(-3, 2, "InverseSquareRootCubicAmp")] - public void GetNameFormatsHigherAndInverseRationalPowers(int numerator, int denominator, string expected) + [Test] + [Arguments(1, 12, "Root12Amps")] + [Arguments(4, 5, "Root5Power4Amps")] + [Arguments(-3, 2, "InverseSquareRootCubicAmp")] + public async Task GetNameFormatsHigherAndInverseRationalPowers(int numerator, int denominator, string expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Amp, new Rational(numerator, denominator))); string result = original.GetName(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameKeepsFractionalPowersWithTheirFactorsInOrderedCompound() + [Test] + public async Task GetNameKeepsFractionalPowersWithTheirFactorsInOrderedCompound() { UnitExpression original = new( new UnitTerm(AtomicUnits.Metre, new Rational(1, 2)), @@ -58,241 +57,247 @@ public void GetNameKeepsFractionalPowersWithTheirFactorsInOrderedCompound() string result = original.GetName(); string expected = "SquareRootMetreAmpsPerSquareRootCubicSecond"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameFormatsCompoundNumeratorAndDenominator() + [Test] + public async Task GetNameFormatsCompoundNumeratorAndDenominator() { UnitExpression original = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Second, -1)); string result = original.GetName(); string expected = "AmpsPerSecond"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNamePluralisesOnlyTheLastNumeratorFactor() + [Test] + public async Task GetNamePluralisesOnlyTheLastNumeratorFactor() { UnitExpression original = new(new UnitTerm(_newton), new UnitTerm(AtomicUnits.Metre)); string result = original.GetName(); string expected = "NewtonMetres"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameFormatsInverseWithSingularUnitName() + [Test] + public async Task GetNameFormatsInverseWithSingularUnitName() { UnitExpression original = new(new UnitTerm(AtomicUnits.Second, -1)); string result = original.GetName(); string expected = "InverseSecond"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNamePreservesKelvinSpelling() + [Test] + public async Task GetNamePreservesKelvinSpelling() { UnitExpression original = new(new UnitTerm(AtomicUnits.Kelvin)); string result = original.GetName(); string expected = "Kelvin"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameFormatsKilogramsWithFixedPrefixCasing() + [Test] + public async Task GetNameFormatsKilogramsWithFixedPrefixCasing() { UnitExpression original = new(new UnitTerm(AtomicUnits.Gram, prefixExponent: 3)); string result = original.GetName(); string expected = "Kilograms"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameCapitalisesThePrefixOfAVariableFactor() + [Test] + public async Task GetNameCapitalisesThePrefixOfAVariableFactor() { UnitExpression original = new(new UnitTerm(AtomicUnits.Gram, prefixExponent: 3)); string result = original.GetName(variableFactorIndex: 0); string expected = "KiloGrams"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameFormatsReferenceAwareCurrentDensityDenominator() + [Test] + public async Task GetNameFormatsReferenceAwareCurrentDensityDenominator() { UnitExpression currentDensityReference = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2)); UnitExpression currentDensity = currentDensityReference.WithPrefix(1, -3); string currentDensityResult = currentDensity.GetName(currentDensityReference); string expected = "AmpsPerSquareMilliMetre"; - Assert.Equal(expected, currentDensityResult); + await Assert.That(currentDensityResult).IsEqualTo(expected); } - [Fact] - public void GetNameFormatsReferenceAwareMassDensityDenominator() + [Test] + public async Task GetNameFormatsReferenceAwareMassDensityDenominator() { UnitExpression reference = new(new UnitTerm(AtomicUnits.Gram, prefixExponent: 3), new UnitTerm(AtomicUnits.Metre, -3)); UnitExpression original = new(new UnitTerm(AtomicUnits.Gram), new UnitTerm(AtomicUnits.Metre, -3, -2)); string result = original.GetName(reference); string expected = "GramsPerCubicCentiMetre"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 0, "m")] - [InlineData(2, 0, "m²")] - [InlineData(3, 0, "m³")] - [InlineData(1, -3, "mm")] - public void GetSymbolFormatsUnitPowerAndPrefix(int power, int prefixExponent, string expected) + [Test] + [Arguments(1, 0, "m")] + [Arguments(2, 0, "m²")] + [Arguments(3, 0, "m³")] + [Arguments(1, -3, "mm")] + public async Task GetSymbolFormatsUnitPowerAndPrefix(int power, int prefixExponent, string expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, power, prefixExponent)); string result = original.GetSymbol(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 2, "m¹⁄²")] - [InlineData(3, 2, "m³⁄²")] - [InlineData(-1, 2, "m⁻¹⁄²")] - public void GetSymbolFormatsFractionalPowers(int numerator, int denominator, string expected) + [Test] + [Arguments(1, 2, "m¹⁄²")] + [Arguments(3, 2, "m³⁄²")] + [Arguments(-1, 2, "m⁻¹⁄²")] + public async Task GetSymbolFormatsFractionalPowers(int numerator, int denominator, string expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, new Rational(numerator, denominator))); string result = original.GetSymbol(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetSymbolFormatsInverseAndCompoundUnits() + [Test] + public async Task GetSymbolFormatsInverseAndCompoundUnits() { UnitExpression inverse = new(new UnitTerm(AtomicUnits.Second, -1)); UnitExpression compound = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2, -3)); string inverseResult = inverse.GetSymbol(); string compoundResult = compound.GetSymbol(); - Assert.Multiple( - () => Assert.Equal("s⁻¹", inverseResult), - () => Assert.Equal("A/mm²", compoundResult)); + using (Assert.Multiple()) + { + await Assert.That(inverseResult).IsEqualTo("s⁻¹"); + await Assert.That(compoundResult).IsEqualTo("A/mm²"); + } } - [Theory] - [InlineData(1, -3, -3)] - [InlineData(1, 3, 3)] - [InlineData(2, -3, -6)] - [InlineData(-2, -3, 6)] - [InlineData(3, -3, -9)] - [InlineData(-3, -3, 9)] - public void GetSiScaleExponentAppliesMetrePrefixPowerAndSign(int power, int prefixExponent, int expected) + [Test] + [Arguments(1, -3, -3)] + [Arguments(1, 3, 3)] + [Arguments(2, -3, -6)] + [Arguments(-2, -3, 6)] + [Arguments(3, -3, -9)] + [Arguments(-3, -3, 9)] + public async Task GetSiScaleExponentAppliesMetrePrefixPowerAndSign(int power, int prefixExponent, int expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, power, prefixExponent)); Rational result = original.GetSiScaleExponent(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(1, 2, -3, -3, 2)] - [InlineData(-1, 2, -3, 3, 2)] - [InlineData(3, 2, -3, -9, 2)] - public void GetSiScaleExponentAppliesFractionalPower(int numerator, int denominator, int prefixExponent, int expectedNumerator, int expectedDenominator) + [Test] + [Arguments(1, 2, -3, -3, 2)] + [Arguments(-1, 2, -3, 3, 2)] + [Arguments(3, 2, -3, -9, 2)] + public async Task GetSiScaleExponentAppliesFractionalPower(int numerator, int denominator, int prefixExponent, int expectedNumerator, int expectedDenominator) { UnitExpression original = new(new UnitTerm(AtomicUnits.Metre, new Rational(numerator, denominator), prefixExponent)); Rational result = original.GetSiScaleExponent(); Rational expected = new(expectedNumerator, expectedDenominator); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetSiScaleExponentCombinesFractionalGramOffsetAndPrefixedDenominator() + [Test] + public async Task GetSiScaleExponentCombinesFractionalGramOffsetAndPrefixedDenominator() { UnitExpression original = new(new UnitTerm(AtomicUnits.Gram, new Rational(1, 2)), new UnitTerm(AtomicUnits.Second, -1, -3)); Rational result = original.GetSiScaleExponent(); Rational expected = new(3, 2); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(3, 3)] - [InlineData(-3, -3)] - [InlineData(-27, -27)] - [InlineData(30, 30)] - [InlineData(-30, -30)] - public void GetSiScaleExponentAppliesVoltagePrefix(int prefixExponent, int expected) + [Test] + [Arguments(3, 3)] + [Arguments(-3, -3)] + [Arguments(-27, -27)] + [Arguments(30, 30)] + [Arguments(-30, -30)] + public async Task GetSiScaleExponentAppliesVoltagePrefix(int prefixExponent, int expected) { UnitExpression original = new(new UnitTerm(_volt, prefixExponent: prefixExponent)); Rational result = original.GetSiScaleExponent(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Theory] - [InlineData(0, -3)] - [InlineData(3, 0)] - [InlineData(-3, -6)] - public void GetSiScaleExponentAccountsForGramBasePrefixOffset(int prefixExponent, int expected) + [Test] + [Arguments(0, -3)] + [Arguments(3, 0)] + [Arguments(-3, -6)] + public async Task GetSiScaleExponentAccountsForGramBasePrefixOffset(int prefixExponent, int expected) { UnitExpression original = new(new UnitTerm(AtomicUnits.Gram, prefixExponent: prefixExponent)); Rational result = original.GetSiScaleExponent(); - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetSiScaleExponentCombinesReciprocalFactors() + [Test] + public async Task GetSiScaleExponentCombinesReciprocalFactors() { UnitExpression ampPerSquareMillimetre = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2, -3)); UnitExpression gramPerCubicCentimetre = new(new UnitTerm(AtomicUnits.Gram), new UnitTerm(AtomicUnits.Metre, -3, -2)); Rational currentDensityResult = ampPerSquareMillimetre.GetSiScaleExponent(); Rational massDensityResult = gramPerCubicCentimetre.GetSiScaleExponent(); - Assert.Multiple( - () => Assert.Equal(6, currentDensityResult), - () => Assert.Equal(3, massDensityResult)); + using (Assert.Multiple()) + { + await Assert.That(currentDensityResult).IsEqualTo(6); + await Assert.That(massDensityResult).IsEqualTo(3); + } } - [Fact] - public void GetSiScaleExponentCancelsKilogramInWattsPerKilogram() + [Test] + public async Task GetSiScaleExponentCancelsKilogramInWattsPerKilogram() { UnitExpression original = new(new UnitTerm(_watt), new UnitTerm(AtomicUnits.Gram, -1, 3)); Rational result = original.GetSiScaleExponent(); Rational expected = Rational.Zero; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetSiScaleExponentIncludesKilowattPrefix() + [Test] + public async Task GetSiScaleExponentIncludesKilowattPrefix() { UnitExpression original = new(new UnitTerm(_watt, prefixExponent: 3), new UnitTerm(AtomicUnits.Gram, -1, 3)); Rational result = original.GetSiScaleExponent(); Rational expected = 3; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void WithPrefixChangesOnlyTheSelectedTermAndPreservesOriginal() + [Test] + public async Task WithPrefixChangesOnlyTheSelectedTermAndPreservesOriginal() { UnitExpression original = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2)); UnitExpression result = original.WithPrefix(1, -3); UnitExpression expected = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2, -3)); UnitExpression expectedOriginal = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2)); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Equal(expectedOriginal, original)); + using (Assert.Multiple()) + { + await Assert.That(result).IsEqualTo(expected); + await Assert.That(original).IsEqualTo(expectedOriginal); + } } - [Fact] - public void GetScaleCombinesNonDecimalFactorsAndNegativePowers() + [Test] + public async Task GetScaleCombinesNonDecimalFactorsAndNegativePowers() { AtomicUnit foot = new("Foot", "Feet", "ft", Scale: 0.3048); AtomicUnit minute = new("Minute", "Minutes", "min", Scale: 60); @@ -300,28 +305,28 @@ public void GetScaleCombinesNonDecimalFactorsAndNegativePowers() double result = original.GetScale(); double expected = 0.001548384; - Assert.Equal(expected, result, 12); + await Assert.That(Math.Round(result, 12)).IsEqualTo(Math.Round(expected, 12)); } - [Fact] - public void GetScaleAppliesFractionalPowers() + [Test] + public async Task GetScaleAppliesFractionalPowers() { AtomicUnit unit = new("Sample", "Samples", "x", Scale: 16); UnitExpression original = new(new UnitTerm(unit, new Rational(3, 2))); double result = original.GetScale(); double expected = 64; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } - [Fact] - public void GetNameAcceptsAReferenceWithDifferentFactors() + [Test] + public async Task GetNameAcceptsAReferenceWithDifferentFactors() { UnitExpression reference = new(new UnitTerm(AtomicUnits.Amp)); UnitExpression original = new(new UnitTerm(AtomicUnits.Amp), new UnitTerm(AtomicUnits.Metre, -2)); string result = original.GetName(reference); string expected = "AmpsPerSquareMetre"; - Assert.Equal(expected, result); + await Assert.That(result).IsEqualTo(expected); } }