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