Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -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();
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -4,11 +4,11 @@
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
<OutputType>Exe</OutputType>
<UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="xunit.v3" Version="4.0.2" />
<PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.5.2" />
<PackageReference Include="TUnit.Engine" Version="1.85.0" />
<PackageReference Include="TUnit.Assertions" Version="1.85.0" />
<PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.5.3" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="../DimensionalQuantities.Extensions.CgsEmag/DimensionalQuantities.Extensions.CgsEmag.csproj" />
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -4,11 +4,11 @@
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
<OutputType>Exe</OutputType>
<UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="xunit.v3" Version="4.0.2" />
<PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.5.2" />
<PackageReference Include="TUnit.Engine" Version="1.85.0" />
<PackageReference Include="TUnit.Assertions" Version="1.85.0" />
<PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="2.5.3" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="../DimensionalQuantities.Extensions.Imperial/DimensionalQuantities.Extensions.Imperial.csproj" />
Expand Down
Original file line number Diff line number Diff line change
@@ -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();
}
}
}
Loading
Loading