From cf426fb3d300e1e51576bf18e552661197e4a861 Mon Sep 17 00:00:00 2001 From: lipchev Date: Tue, 21 Jan 2025 14:56:59 +0200 Subject: [PATCH] VolumeConcentration: fix the SingularName for LiterPerLiter and LiterPerMilliliter --- .../UnitDefinitions/VolumeConcentration.json | 4 +- Common/UnitEnumValues.g.json | 28 +- .../Quantities/VolumeConcentration.g.cs | 168 +++--- .../Units/VolumeConcentrationUnit.g.cs | 28 +- UnitsNet.Tests/CustomCode/MolarityTests.cs | 2 +- .../CustomCode/VolumeConcentrationTests.cs | 4 +- .../GeneratedCode/IQuantityTests.g.cs | 2 +- .../VolumeConcentrationTestsBase.g.cs | 480 +++++++++--------- .../Quantities/VolumeConcentration.g.cs | 252 ++++----- .../Units/VolumeConcentrationUnit.g.cs | 28 +- 10 files changed, 498 insertions(+), 498 deletions(-) diff --git a/Common/UnitDefinitions/VolumeConcentration.json b/Common/UnitDefinitions/VolumeConcentration.json index 170d9f22b5..4cb5f09795 100644 --- a/Common/UnitDefinitions/VolumeConcentration.json +++ b/Common/UnitDefinitions/VolumeConcentration.json @@ -17,7 +17,7 @@ ] }, { - "SingularName": "LitersPerLiter", + "SingularName": "LiterPerLiter", "PluralName": "LitersPerLiter", "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}", @@ -30,7 +30,7 @@ ] }, { - "SingularName": "LitersPerMilliliter", + "SingularName": "LiterPerMilliliter", "PluralName": "LitersPerMilliliter", "FromUnitToBaseFunc": "{x} / 1e-3", "FromBaseToUnitFunc": "{x} * 1e-3", diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index 82ae7db2ed..9d2e96173d 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -1579,26 +1579,26 @@ "ImperialQuart": 57 }, "VolumeConcentration": { - "CentilitersPerLiter": 1, - "CentilitersPerMilliliter": 2, - "DecilitersPerLiter": 3, - "DecilitersPerMilliliter": 4, + "CentiliterPerLiter": 1, + "CentiliterPerMilliliter": 2, + "DeciliterPerLiter": 3, + "DeciliterPerMilliliter": 4, "DecimalFraction": 5, - "LitersPerLiter": 6, - "LitersPerMilliliter": 7, - "MicrolitersPerLiter": 8, - "MicrolitersPerMilliliter": 9, - "MillilitersPerLiter": 10, - "MillilitersPerMilliliter": 11, - "NanolitersPerLiter": 12, - "NanolitersPerMilliliter": 13, + "LiterPerLiter": 6, + "LiterPerMilliliter": 7, + "MicroliterPerLiter": 8, + "MicroliterPerMilliliter": 9, + "MilliliterPerLiter": 10, + "MilliliterPerMilliliter": 11, + "NanoliterPerLiter": 12, + "NanoliterPerMilliliter": 13, "PartPerBillion": 14, "PartPerMillion": 15, "PartPerThousand": 16, "PartPerTrillion": 17, "Percent": 18, - "PicolitersPerLiter": 19, - "PicolitersPerMilliliter": 20 + "PicoliterPerLiter": 19, + "PicoliterPerMilliliter": 20 }, "VolumeFlow": { "AcreFootPerDay": 1, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs index a58548a834..c9549407cc 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -82,24 +82,24 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) #region Conversion Properties /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter); + public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentiliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentilitersPerMilliliter); + public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentiliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter); + public double DecilitersPerLiter => As(VolumeConcentrationUnit.DeciliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DecilitersPerMilliliter); + public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DeciliterPerMilliliter); /// /// Gets a value of this quantity converted into @@ -107,44 +107,44 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter); + public double LitersPerLiter => As(VolumeConcentrationUnit.LiterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerMilliliter => As(VolumeConcentrationUnit.LitersPerMilliliter); + public double LitersPerMilliliter => As(VolumeConcentrationUnit.LiterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter); + public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicroliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicrolitersPerMilliliter); + public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicroliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter); + public double MillilitersPerLiter => As(VolumeConcentrationUnit.MilliliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MillilitersPerMilliliter); + public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MilliliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter); + public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanoliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanolitersPerMilliliter); + public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanoliterPerMilliliter); /// /// Gets a value of this quantity converted into @@ -172,38 +172,38 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double Percent => As(VolumeConcentrationUnit.Percent); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter); + public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicoliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicolitersPerMilliliter); + public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicoliterPerMilliliter); #endregion #region Static Factory Methods /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter) => new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentilitersPerLiter); + public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter) => new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentiliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromCentilitersPerMilliliter(double centiliterspermilliliter) => new VolumeConcentration(centiliterspermilliliter, VolumeConcentrationUnit.CentilitersPerMilliliter); + public static VolumeConcentration FromCentilitersPerMilliliter(double centiliterspermilliliter) => new VolumeConcentration(centiliterspermilliliter, VolumeConcentrationUnit.CentiliterPerMilliliter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter) => new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DecilitersPerLiter); + public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter) => new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DeciliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromDecilitersPerMilliliter(double deciliterspermilliliter) => new VolumeConcentration(deciliterspermilliliter, VolumeConcentrationUnit.DecilitersPerMilliliter); + public static VolumeConcentration FromDecilitersPerMilliliter(double deciliterspermilliliter) => new VolumeConcentration(deciliterspermilliliter, VolumeConcentrationUnit.DeciliterPerMilliliter); /// /// Creates a from . @@ -211,44 +211,44 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromDecimalFractions(double decimalfractions) => new VolumeConcentration(decimalfractions, VolumeConcentrationUnit.DecimalFraction); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromLitersPerLiter(double litersperliter) => new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LitersPerLiter); + public static VolumeConcentration FromLitersPerLiter(double litersperliter) => new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LiterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromLitersPerMilliliter(double literspermilliliter) => new VolumeConcentration(literspermilliliter, VolumeConcentrationUnit.LitersPerMilliliter); + public static VolumeConcentration FromLitersPerMilliliter(double literspermilliliter) => new VolumeConcentration(literspermilliliter, VolumeConcentrationUnit.LiterPerMilliliter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter) => new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicrolitersPerLiter); + public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter) => new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicroliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMicrolitersPerMilliliter(double microliterspermilliliter) => new VolumeConcentration(microliterspermilliliter, VolumeConcentrationUnit.MicrolitersPerMilliliter); + public static VolumeConcentration FromMicrolitersPerMilliliter(double microliterspermilliliter) => new VolumeConcentration(microliterspermilliliter, VolumeConcentrationUnit.MicroliterPerMilliliter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter) => new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MillilitersPerLiter); + public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter) => new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MilliliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMillilitersPerMilliliter(double milliliterspermilliliter) => new VolumeConcentration(milliliterspermilliliter, VolumeConcentrationUnit.MillilitersPerMilliliter); + public static VolumeConcentration FromMillilitersPerMilliliter(double milliliterspermilliliter) => new VolumeConcentration(milliliterspermilliliter, VolumeConcentrationUnit.MilliliterPerMilliliter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter) => new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanolitersPerLiter); + public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter) => new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanoliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromNanolitersPerMilliliter(double nanoliterspermilliliter) => new VolumeConcentration(nanoliterspermilliliter, VolumeConcentrationUnit.NanolitersPerMilliliter); + public static VolumeConcentration FromNanolitersPerMilliliter(double nanoliterspermilliliter) => new VolumeConcentration(nanoliterspermilliliter, VolumeConcentrationUnit.NanoliterPerMilliliter); /// /// Creates a from . @@ -276,14 +276,14 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromPercent(double percent) => new VolumeConcentration(percent, VolumeConcentrationUnit.Percent); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter) => new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicolitersPerLiter); + public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter) => new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicoliterPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromPicolitersPerMilliliter(double picoliterspermilliliter) => new VolumeConcentration(picoliterspermilliliter, VolumeConcentrationUnit.PicolitersPerMilliliter); + public static VolumeConcentration FromPicolitersPerMilliliter(double picoliterspermilliliter) => new VolumeConcentration(picoliterspermilliliter, VolumeConcentrationUnit.PicoliterPerMilliliter); /// /// Dynamically convert from value and unit enum to . @@ -325,26 +325,26 @@ private double GetValueInBaseUnit() { return Unit switch { - VolumeConcentrationUnit.CentilitersPerLiter => (_value) * 1e-2d, - VolumeConcentrationUnit.CentilitersPerMilliliter => (_value / 1e-3) * 1e-2d, - VolumeConcentrationUnit.DecilitersPerLiter => (_value) * 1e-1d, - VolumeConcentrationUnit.DecilitersPerMilliliter => (_value / 1e-3) * 1e-1d, + VolumeConcentrationUnit.CentiliterPerLiter => (_value) * 1e-2d, + VolumeConcentrationUnit.CentiliterPerMilliliter => (_value / 1e-3) * 1e-2d, + VolumeConcentrationUnit.DeciliterPerLiter => (_value) * 1e-1d, + VolumeConcentrationUnit.DeciliterPerMilliliter => (_value / 1e-3) * 1e-1d, VolumeConcentrationUnit.DecimalFraction => _value, - VolumeConcentrationUnit.LitersPerLiter => _value, - VolumeConcentrationUnit.LitersPerMilliliter => _value / 1e-3, - VolumeConcentrationUnit.MicrolitersPerLiter => (_value) * 1e-6d, - VolumeConcentrationUnit.MicrolitersPerMilliliter => (_value / 1e-3) * 1e-6d, - VolumeConcentrationUnit.MillilitersPerLiter => (_value) * 1e-3d, - VolumeConcentrationUnit.MillilitersPerMilliliter => (_value / 1e-3) * 1e-3d, - VolumeConcentrationUnit.NanolitersPerLiter => (_value) * 1e-9d, - VolumeConcentrationUnit.NanolitersPerMilliliter => (_value / 1e-3) * 1e-9d, + VolumeConcentrationUnit.LiterPerLiter => _value, + VolumeConcentrationUnit.LiterPerMilliliter => _value / 1e-3, + VolumeConcentrationUnit.MicroliterPerLiter => (_value) * 1e-6d, + VolumeConcentrationUnit.MicroliterPerMilliliter => (_value / 1e-3) * 1e-6d, + VolumeConcentrationUnit.MilliliterPerLiter => (_value) * 1e-3d, + VolumeConcentrationUnit.MilliliterPerMilliliter => (_value / 1e-3) * 1e-3d, + VolumeConcentrationUnit.NanoliterPerLiter => (_value) * 1e-9d, + VolumeConcentrationUnit.NanoliterPerMilliliter => (_value / 1e-3) * 1e-9d, VolumeConcentrationUnit.PartPerBillion => _value / 1e9, VolumeConcentrationUnit.PartPerMillion => _value / 1e6, VolumeConcentrationUnit.PartPerThousand => _value / 1e3, VolumeConcentrationUnit.PartPerTrillion => _value / 1e12, VolumeConcentrationUnit.Percent => _value / 1e2, - VolumeConcentrationUnit.PicolitersPerLiter => (_value) * 1e-12d, - VolumeConcentrationUnit.PicolitersPerMilliliter => (_value / 1e-3) * 1e-12d, + VolumeConcentrationUnit.PicoliterPerLiter => (_value) * 1e-12d, + VolumeConcentrationUnit.PicoliterPerMilliliter => (_value / 1e-3) * 1e-12d, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -358,26 +358,26 @@ private double GetValueAs(VolumeConcentrationUnit unit) return unit switch { - VolumeConcentrationUnit.CentilitersPerLiter => (baseUnitValue) / 1e-2d, - VolumeConcentrationUnit.CentilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d, - VolumeConcentrationUnit.DecilitersPerLiter => (baseUnitValue) / 1e-1d, - VolumeConcentrationUnit.DecilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d, + VolumeConcentrationUnit.CentiliterPerLiter => (baseUnitValue) / 1e-2d, + VolumeConcentrationUnit.CentiliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d, + VolumeConcentrationUnit.DeciliterPerLiter => (baseUnitValue) / 1e-1d, + VolumeConcentrationUnit.DeciliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d, VolumeConcentrationUnit.DecimalFraction => baseUnitValue, - VolumeConcentrationUnit.LitersPerLiter => baseUnitValue, - VolumeConcentrationUnit.LitersPerMilliliter => baseUnitValue * 1e-3, - VolumeConcentrationUnit.MicrolitersPerLiter => (baseUnitValue) / 1e-6d, - VolumeConcentrationUnit.MicrolitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d, - VolumeConcentrationUnit.MillilitersPerLiter => (baseUnitValue) / 1e-3d, - VolumeConcentrationUnit.MillilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d, - VolumeConcentrationUnit.NanolitersPerLiter => (baseUnitValue) / 1e-9d, - VolumeConcentrationUnit.NanolitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-9d, + VolumeConcentrationUnit.LiterPerLiter => baseUnitValue, + VolumeConcentrationUnit.LiterPerMilliliter => baseUnitValue * 1e-3, + VolumeConcentrationUnit.MicroliterPerLiter => (baseUnitValue) / 1e-6d, + VolumeConcentrationUnit.MicroliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d, + VolumeConcentrationUnit.MilliliterPerLiter => (baseUnitValue) / 1e-3d, + VolumeConcentrationUnit.MilliliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d, + VolumeConcentrationUnit.NanoliterPerLiter => (baseUnitValue) / 1e-9d, + VolumeConcentrationUnit.NanoliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-9d, VolumeConcentrationUnit.PartPerBillion => baseUnitValue * 1e9, VolumeConcentrationUnit.PartPerMillion => baseUnitValue * 1e6, VolumeConcentrationUnit.PartPerThousand => baseUnitValue * 1e3, VolumeConcentrationUnit.PartPerTrillion => baseUnitValue * 1e12, VolumeConcentrationUnit.Percent => baseUnitValue * 1e2, - VolumeConcentrationUnit.PicolitersPerLiter => (baseUnitValue) / 1e-12d, - VolumeConcentrationUnit.PicolitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-12d, + VolumeConcentrationUnit.PicoliterPerLiter => (baseUnitValue) / 1e-12d, + VolumeConcentrationUnit.PicoliterPerMilliliter => (baseUnitValue * 1e-3) / 1e-12d, _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.") }; } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs index 283715f8af..5624e121d1 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs @@ -25,26 +25,26 @@ namespace UnitsNet.Units public enum VolumeConcentrationUnit { - CentilitersPerLiter = 1, - CentilitersPerMilliliter = 2, - DecilitersPerLiter = 3, - DecilitersPerMilliliter = 4, + CentiliterPerLiter = 1, + CentiliterPerMilliliter = 2, + DeciliterPerLiter = 3, + DeciliterPerMilliliter = 4, DecimalFraction = 5, - LitersPerLiter = 6, - LitersPerMilliliter = 7, - MicrolitersPerLiter = 8, - MicrolitersPerMilliliter = 9, - MillilitersPerLiter = 10, - MillilitersPerMilliliter = 11, - NanolitersPerLiter = 12, - NanolitersPerMilliliter = 13, + LiterPerLiter = 6, + LiterPerMilliliter = 7, + MicroliterPerLiter = 8, + MicroliterPerMilliliter = 9, + MilliliterPerLiter = 10, + MilliliterPerMilliliter = 11, + NanoliterPerLiter = 12, + NanoliterPerMilliliter = 13, PartPerBillion = 14, PartPerMillion = 15, PartPerThousand = 16, PartPerTrillion = 17, Percent = 18, - PicolitersPerLiter = 19, - PicolitersPerMilliliter = 20, + PicoliterPerLiter = 19, + PicoliterPerMilliliter = 20, } #pragma warning restore 1591 diff --git a/UnitsNet.Tests/CustomCode/MolarityTests.cs b/UnitsNet.Tests/CustomCode/MolarityTests.cs index 9d409e10d1..ca0523318f 100644 --- a/UnitsNet.Tests/CustomCode/MolarityTests.cs +++ b/UnitsNet.Tests/CustomCode/MolarityTests.cs @@ -50,7 +50,7 @@ public class MolarityTests : MolarityTestsBase [InlineData(0.5, MolarityUnit.MolePerLiter, KnownQuantities.DensityOfEthanolInKgPerCubicMeter, DensityUnit.KilogramPerCubicMeter, KnownQuantities.MolarMassOfEthanolInGramsPerMole, MolarMassUnit.GramPerMole, - 29.19419518377693, VolumeConcentrationUnit.MillilitersPerLiter)] // 0.5M ethanol + 29.19419518377693, VolumeConcentrationUnit.MilliliterPerLiter)] // 0.5M ethanol public void VolumeConcentrationFromComponentDensityAndMolarity( double molarityValue, MolarityUnit molarityUnit, double componentDensityValue, DensityUnit componentDensityUnit, diff --git a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs index 7a80012573..198575580c 100644 --- a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs @@ -60,7 +60,7 @@ public class VolumeConcentrationTests : VolumeConcentrationTestsBase [InlineData(50, VolumeConcentrationUnit.Percent, 10, DensityUnit.GramPerCubicMeter, 5, MassConcentrationUnit.GramPerCubicMeter)] // synthetic data - [InlineData(29.19419518377693, VolumeConcentrationUnit.MillilitersPerLiter, + [InlineData(29.19419518377693, VolumeConcentrationUnit.MilliliterPerLiter, KnownQuantities.DensityOfEthanolInKgPerCubicMeter, DensityUnit.KilogramPerCubicMeter, 23.03422, MassConcentrationUnit.GramPerLiter)] // 29.19419518377693 = VolumeConcentration_0_5M_Ethanol public void MassConcentrationFromVolumeConcentrationAndComponentDensity( @@ -78,7 +78,7 @@ public void MassConcentrationFromVolumeConcentrationAndComponentDensity( } [Theory] - [InlineData(29.19419518377693, VolumeConcentrationUnit.MillilitersPerLiter, + [InlineData(29.19419518377693, VolumeConcentrationUnit.MilliliterPerLiter, KnownQuantities.DensityOfEthanolInKgPerCubicMeter, DensityUnit.KilogramPerCubicMeter, KnownQuantities.MolarMassOfEthanolInGramsPerMole, MolarMassUnit.GramPerMole, 0.5, MolarityUnit.MolePerLiter)] // 29.19419518377693 = VolumeConcentration_0_5M_Ethanol diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index b76b821b63..5f3673754f 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -154,7 +154,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, TurbidityUnit.NTU, Quantity.From(3, TurbidityUnit.NTU)); Assertion(3, VitaminAUnit.InternationalUnit, Quantity.From(3, VitaminAUnit.InternationalUnit)); Assertion(3, VolumeUnit.UsTeaspoon, Quantity.From(3, VolumeUnit.UsTeaspoon)); - Assertion(3, VolumeConcentrationUnit.PicolitersPerMilliliter, Quantity.From(3, VolumeConcentrationUnit.PicolitersPerMilliliter)); + Assertion(3, VolumeConcentrationUnit.PicoliterPerMilliliter, Quantity.From(3, VolumeConcentrationUnit.PicoliterPerMilliliter)); Assertion(3, VolumeFlowUnit.UsGallonPerSecond, Quantity.From(3, VolumeFlowUnit.UsGallonPerSecond)); Assertion(3, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter, Quantity.From(3, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter)); Assertion(3, VolumePerLengthUnit.UsGallonPerMile, Quantity.From(3, VolumePerLengthUnit.UsGallonPerMile)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs index 618934d8f7..486cbf8750 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs @@ -87,52 +87,52 @@ public abstract partial class VolumeConcentrationTestsBase : QuantityTestsBase { return unit switch { - VolumeConcentrationUnit.CentilitersPerLiter => (CentilitersPerLiterInOneDecimalFraction, CentilitersPerLiterTolerance), - VolumeConcentrationUnit.CentilitersPerMilliliter => (CentilitersPerMilliliterInOneDecimalFraction, CentilitersPerMilliliterTolerance), - VolumeConcentrationUnit.DecilitersPerLiter => (DecilitersPerLiterInOneDecimalFraction, DecilitersPerLiterTolerance), - VolumeConcentrationUnit.DecilitersPerMilliliter => (DecilitersPerMilliliterInOneDecimalFraction, DecilitersPerMilliliterTolerance), + VolumeConcentrationUnit.CentiliterPerLiter => (CentilitersPerLiterInOneDecimalFraction, CentilitersPerLiterTolerance), + VolumeConcentrationUnit.CentiliterPerMilliliter => (CentilitersPerMilliliterInOneDecimalFraction, CentilitersPerMilliliterTolerance), + VolumeConcentrationUnit.DeciliterPerLiter => (DecilitersPerLiterInOneDecimalFraction, DecilitersPerLiterTolerance), + VolumeConcentrationUnit.DeciliterPerMilliliter => (DecilitersPerMilliliterInOneDecimalFraction, DecilitersPerMilliliterTolerance), VolumeConcentrationUnit.DecimalFraction => (DecimalFractionsInOneDecimalFraction, DecimalFractionsTolerance), - VolumeConcentrationUnit.LitersPerLiter => (LitersPerLiterInOneDecimalFraction, LitersPerLiterTolerance), - VolumeConcentrationUnit.LitersPerMilliliter => (LitersPerMilliliterInOneDecimalFraction, LitersPerMilliliterTolerance), - VolumeConcentrationUnit.MicrolitersPerLiter => (MicrolitersPerLiterInOneDecimalFraction, MicrolitersPerLiterTolerance), - VolumeConcentrationUnit.MicrolitersPerMilliliter => (MicrolitersPerMilliliterInOneDecimalFraction, MicrolitersPerMilliliterTolerance), - VolumeConcentrationUnit.MillilitersPerLiter => (MillilitersPerLiterInOneDecimalFraction, MillilitersPerLiterTolerance), - VolumeConcentrationUnit.MillilitersPerMilliliter => (MillilitersPerMilliliterInOneDecimalFraction, MillilitersPerMilliliterTolerance), - VolumeConcentrationUnit.NanolitersPerLiter => (NanolitersPerLiterInOneDecimalFraction, NanolitersPerLiterTolerance), - VolumeConcentrationUnit.NanolitersPerMilliliter => (NanolitersPerMilliliterInOneDecimalFraction, NanolitersPerMilliliterTolerance), + VolumeConcentrationUnit.LiterPerLiter => (LitersPerLiterInOneDecimalFraction, LitersPerLiterTolerance), + VolumeConcentrationUnit.LiterPerMilliliter => (LitersPerMilliliterInOneDecimalFraction, LitersPerMilliliterTolerance), + VolumeConcentrationUnit.MicroliterPerLiter => (MicrolitersPerLiterInOneDecimalFraction, MicrolitersPerLiterTolerance), + VolumeConcentrationUnit.MicroliterPerMilliliter => (MicrolitersPerMilliliterInOneDecimalFraction, MicrolitersPerMilliliterTolerance), + VolumeConcentrationUnit.MilliliterPerLiter => (MillilitersPerLiterInOneDecimalFraction, MillilitersPerLiterTolerance), + VolumeConcentrationUnit.MilliliterPerMilliliter => (MillilitersPerMilliliterInOneDecimalFraction, MillilitersPerMilliliterTolerance), + VolumeConcentrationUnit.NanoliterPerLiter => (NanolitersPerLiterInOneDecimalFraction, NanolitersPerLiterTolerance), + VolumeConcentrationUnit.NanoliterPerMilliliter => (NanolitersPerMilliliterInOneDecimalFraction, NanolitersPerMilliliterTolerance), VolumeConcentrationUnit.PartPerBillion => (PartsPerBillionInOneDecimalFraction, PartsPerBillionTolerance), VolumeConcentrationUnit.PartPerMillion => (PartsPerMillionInOneDecimalFraction, PartsPerMillionTolerance), VolumeConcentrationUnit.PartPerThousand => (PartsPerThousandInOneDecimalFraction, PartsPerThousandTolerance), VolumeConcentrationUnit.PartPerTrillion => (PartsPerTrillionInOneDecimalFraction, PartsPerTrillionTolerance), VolumeConcentrationUnit.Percent => (PercentInOneDecimalFraction, PercentTolerance), - VolumeConcentrationUnit.PicolitersPerLiter => (PicolitersPerLiterInOneDecimalFraction, PicolitersPerLiterTolerance), - VolumeConcentrationUnit.PicolitersPerMilliliter => (PicolitersPerMilliliterInOneDecimalFraction, PicolitersPerMilliliterTolerance), + VolumeConcentrationUnit.PicoliterPerLiter => (PicolitersPerLiterInOneDecimalFraction, PicolitersPerLiterTolerance), + VolumeConcentrationUnit.PicoliterPerMilliliter => (PicolitersPerMilliliterInOneDecimalFraction, PicolitersPerMilliliterTolerance), _ => throw new NotSupportedException() }; } public static IEnumerable UnitTypes = new List { - new object[] { VolumeConcentrationUnit.CentilitersPerLiter }, - new object[] { VolumeConcentrationUnit.CentilitersPerMilliliter }, - new object[] { VolumeConcentrationUnit.DecilitersPerLiter }, - new object[] { VolumeConcentrationUnit.DecilitersPerMilliliter }, + new object[] { VolumeConcentrationUnit.CentiliterPerLiter }, + new object[] { VolumeConcentrationUnit.CentiliterPerMilliliter }, + new object[] { VolumeConcentrationUnit.DeciliterPerLiter }, + new object[] { VolumeConcentrationUnit.DeciliterPerMilliliter }, new object[] { VolumeConcentrationUnit.DecimalFraction }, - new object[] { VolumeConcentrationUnit.LitersPerLiter }, - new object[] { VolumeConcentrationUnit.LitersPerMilliliter }, - new object[] { VolumeConcentrationUnit.MicrolitersPerLiter }, - new object[] { VolumeConcentrationUnit.MicrolitersPerMilliliter }, - new object[] { VolumeConcentrationUnit.MillilitersPerLiter }, - new object[] { VolumeConcentrationUnit.MillilitersPerMilliliter }, - new object[] { VolumeConcentrationUnit.NanolitersPerLiter }, - new object[] { VolumeConcentrationUnit.NanolitersPerMilliliter }, + new object[] { VolumeConcentrationUnit.LiterPerLiter }, + new object[] { VolumeConcentrationUnit.LiterPerMilliliter }, + new object[] { VolumeConcentrationUnit.MicroliterPerLiter }, + new object[] { VolumeConcentrationUnit.MicroliterPerMilliliter }, + new object[] { VolumeConcentrationUnit.MilliliterPerLiter }, + new object[] { VolumeConcentrationUnit.MilliliterPerMilliliter }, + new object[] { VolumeConcentrationUnit.NanoliterPerLiter }, + new object[] { VolumeConcentrationUnit.NanoliterPerMilliliter }, new object[] { VolumeConcentrationUnit.PartPerBillion }, new object[] { VolumeConcentrationUnit.PartPerMillion }, new object[] { VolumeConcentrationUnit.PartPerThousand }, new object[] { VolumeConcentrationUnit.PartPerTrillion }, new object[] { VolumeConcentrationUnit.Percent }, - new object[] { VolumeConcentrationUnit.PicolitersPerLiter }, - new object[] { VolumeConcentrationUnit.PicolitersPerMilliliter }, + new object[] { VolumeConcentrationUnit.PicoliterPerLiter }, + new object[] { VolumeConcentrationUnit.PicoliterPerMilliliter }, }; [Fact] @@ -204,57 +204,57 @@ public void DecimalFractionToVolumeConcentrationUnits() [Fact] public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { - var quantity00 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerLiter); + var quantity00 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentiliterPerLiter); AssertEx.EqualTolerance(1, quantity00.CentilitersPerLiter, CentilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, quantity00.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerLiter, quantity00.Unit); - var quantity01 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerMilliliter); + var quantity01 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentiliterPerMilliliter); AssertEx.EqualTolerance(1, quantity01.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, quantity01.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerMilliliter, quantity01.Unit); - var quantity02 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerLiter); + var quantity02 = VolumeConcentration.From(1, VolumeConcentrationUnit.DeciliterPerLiter); AssertEx.EqualTolerance(1, quantity02.DecilitersPerLiter, DecilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, quantity02.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerLiter, quantity02.Unit); - var quantity03 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerMilliliter); + var quantity03 = VolumeConcentration.From(1, VolumeConcentrationUnit.DeciliterPerMilliliter); AssertEx.EqualTolerance(1, quantity03.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, quantity03.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerMilliliter, quantity03.Unit); var quantity04 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecimalFraction); AssertEx.EqualTolerance(1, quantity04.DecimalFractions, DecimalFractionsTolerance); Assert.Equal(VolumeConcentrationUnit.DecimalFraction, quantity04.Unit); - var quantity05 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerLiter); + var quantity05 = VolumeConcentration.From(1, VolumeConcentrationUnit.LiterPerLiter); AssertEx.EqualTolerance(1, quantity05.LitersPerLiter, LitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, quantity05.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerLiter, quantity05.Unit); - var quantity06 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerMilliliter); + var quantity06 = VolumeConcentration.From(1, VolumeConcentrationUnit.LiterPerMilliliter); AssertEx.EqualTolerance(1, quantity06.LitersPerMilliliter, LitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, quantity06.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerMilliliter, quantity06.Unit); - var quantity07 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerLiter); + var quantity07 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicroliterPerLiter); AssertEx.EqualTolerance(1, quantity07.MicrolitersPerLiter, MicrolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, quantity07.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerLiter, quantity07.Unit); - var quantity08 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerMilliliter); + var quantity08 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicroliterPerMilliliter); AssertEx.EqualTolerance(1, quantity08.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, quantity08.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerMilliliter, quantity08.Unit); - var quantity09 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerLiter); + var quantity09 = VolumeConcentration.From(1, VolumeConcentrationUnit.MilliliterPerLiter); AssertEx.EqualTolerance(1, quantity09.MillilitersPerLiter, MillilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, quantity09.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerLiter, quantity09.Unit); - var quantity10 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerMilliliter); + var quantity10 = VolumeConcentration.From(1, VolumeConcentrationUnit.MilliliterPerMilliliter); AssertEx.EqualTolerance(1, quantity10.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, quantity10.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerMilliliter, quantity10.Unit); - var quantity11 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerLiter); + var quantity11 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanoliterPerLiter); AssertEx.EqualTolerance(1, quantity11.NanolitersPerLiter, NanolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, quantity11.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerLiter, quantity11.Unit); - var quantity12 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerMilliliter); + var quantity12 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanoliterPerMilliliter); AssertEx.EqualTolerance(1, quantity12.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, quantity12.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerMilliliter, quantity12.Unit); var quantity13 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerBillion); AssertEx.EqualTolerance(1, quantity13.PartsPerBillion, PartsPerBillionTolerance); @@ -276,13 +276,13 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity17.Percent, PercentTolerance); Assert.Equal(VolumeConcentrationUnit.Percent, quantity17.Unit); - var quantity18 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerLiter); + var quantity18 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicoliterPerLiter); AssertEx.EqualTolerance(1, quantity18.PicolitersPerLiter, PicolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, quantity18.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerLiter, quantity18.Unit); - var quantity19 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerMilliliter); + var quantity19 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicoliterPerMilliliter); AssertEx.EqualTolerance(1, quantity19.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, quantity19.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerMilliliter, quantity19.Unit); } @@ -308,26 +308,26 @@ public void FromDecimalFractions_WithNanValue_DoNotThrowsArgumentException() public void As() { var decimalfraction = VolumeConcentration.FromDecimalFractions(1); - AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerLiter), CentilitersPerLiterTolerance); - AssertEx.EqualTolerance(CentilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerMilliliter), CentilitersPerMilliliterTolerance); - AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerLiter), DecilitersPerLiterTolerance); - AssertEx.EqualTolerance(DecilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerMilliliter), DecilitersPerMilliliterTolerance); + AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentiliterPerLiter), CentilitersPerLiterTolerance); + AssertEx.EqualTolerance(CentilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentiliterPerMilliliter), CentilitersPerMilliliterTolerance); + AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DeciliterPerLiter), DecilitersPerLiterTolerance); + AssertEx.EqualTolerance(DecilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DeciliterPerMilliliter), DecilitersPerMilliliterTolerance); AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecimalFraction), DecimalFractionsTolerance); - AssertEx.EqualTolerance(LitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LitersPerLiter), LitersPerLiterTolerance); - AssertEx.EqualTolerance(LitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LitersPerMilliliter), LitersPerMilliliterTolerance); - AssertEx.EqualTolerance(MicrolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicrolitersPerLiter), MicrolitersPerLiterTolerance); - AssertEx.EqualTolerance(MicrolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicrolitersPerMilliliter), MicrolitersPerMilliliterTolerance); - AssertEx.EqualTolerance(MillilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MillilitersPerLiter), MillilitersPerLiterTolerance); - AssertEx.EqualTolerance(MillilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MillilitersPerMilliliter), MillilitersPerMilliliterTolerance); - AssertEx.EqualTolerance(NanolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanolitersPerLiter), NanolitersPerLiterTolerance); - AssertEx.EqualTolerance(NanolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanolitersPerMilliliter), NanolitersPerMilliliterTolerance); + AssertEx.EqualTolerance(LitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LiterPerLiter), LitersPerLiterTolerance); + AssertEx.EqualTolerance(LitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LiterPerMilliliter), LitersPerMilliliterTolerance); + AssertEx.EqualTolerance(MicrolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicroliterPerLiter), MicrolitersPerLiterTolerance); + AssertEx.EqualTolerance(MicrolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicroliterPerMilliliter), MicrolitersPerMilliliterTolerance); + AssertEx.EqualTolerance(MillilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MilliliterPerLiter), MillilitersPerLiterTolerance); + AssertEx.EqualTolerance(MillilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MilliliterPerMilliliter), MillilitersPerMilliliterTolerance); + AssertEx.EqualTolerance(NanolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanoliterPerLiter), NanolitersPerLiterTolerance); + AssertEx.EqualTolerance(NanolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanoliterPerMilliliter), NanolitersPerMilliliterTolerance); AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PartPerBillion), PartsPerBillionTolerance); AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PartPerMillion), PartsPerMillionTolerance); AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PartPerThousand), PartsPerThousandTolerance); AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PartPerTrillion), PartsPerTrillionTolerance); AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.Percent), PercentTolerance); - AssertEx.EqualTolerance(PicolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicolitersPerLiter), PicolitersPerLiterTolerance); - AssertEx.EqualTolerance(PicolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicolitersPerMilliliter), PicolitersPerMilliliterTolerance); + AssertEx.EqualTolerance(PicolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicoliterPerLiter), PicolitersPerLiterTolerance); + AssertEx.EqualTolerance(PicolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicoliterPerMilliliter), PicolitersPerMilliliterTolerance); } [Fact] @@ -404,28 +404,28 @@ public void Parse() { var parsed = VolumeConcentration.Parse("1 cl/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.CentilitersPerLiter, CentilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 cl/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 dl/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.DecilitersPerLiter, DecilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 dl/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -439,56 +439,56 @@ public void Parse() { var parsed = VolumeConcentration.Parse("1 l/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.LitersPerLiter, LitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 l/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.LitersPerMilliliter, LitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 µl/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.MicrolitersPerLiter, MicrolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 µl/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 ml/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.MillilitersPerLiter, MillilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 ml/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 nl/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.NanolitersPerLiter, NanolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 nl/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -537,14 +537,14 @@ public void Parse() { var parsed = VolumeConcentration.Parse("1 pl/l", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.PicolitersPerLiter, PicolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = VolumeConcentration.Parse("1 pl/ml", CultureInfo.GetCultureInfo("en-US")); AssertEx.EqualTolerance(1, parsed.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } } @@ -555,25 +555,25 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 cl/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.CentilitersPerLiter, CentilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 cl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.CentiliterPerMilliliter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 dl/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.DecilitersPerLiter, DecilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 dl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.DeciliterPerMilliliter, parsed.Unit); } { @@ -585,49 +585,49 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 l/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.LitersPerLiter, LitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 l/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.LitersPerMilliliter, LitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.LiterPerMilliliter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 µl/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MicrolitersPerLiter, MicrolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 µl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MicroliterPerMilliliter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 ml/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MillilitersPerLiter, MillilitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 ml/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.MilliliterPerMilliliter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 nl/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.NanolitersPerLiter, NanolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 nl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.NanoliterPerMilliliter, parsed.Unit); } { @@ -669,39 +669,39 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 pl/l", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.PicolitersPerLiter, PicolitersPerLiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerLiter, parsed.Unit); } { Assert.True(VolumeConcentration.TryParse("1 pl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, parsed.Unit); + Assert.Equal(VolumeConcentrationUnit.PicoliterPerMilliliter, parsed.Unit); } } [Theory] - [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -711,27 +711,27 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeCon } [Theory] - [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -741,27 +741,27 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string } [Theory] - [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("en-US", "l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("en-US", "ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("en-US", "%", VolumeConcentrationUnit.Percent)] [InlineData("en-US", "% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -770,27 +770,27 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo } [Theory] - [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("en-US", "l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("en-US", "ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("en-US", "%", VolumeConcentrationUnit.Percent)] [InlineData("en-US", "% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { VolumeConcentrationUnit parsedUnit = VolumeConcentration.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)); @@ -798,27 +798,27 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeCon } [Theory] - [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -828,27 +828,27 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume } [Theory] - [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -858,27 +858,27 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri } [Theory] - [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("en-US", "l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("en-US", "ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("en-US", "%", VolumeConcentrationUnit.Percent)] [InlineData("en-US", "% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -887,27 +887,27 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, } [Theory] - [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] - [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] + [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentiliterPerLiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentiliterPerMilliliter)] + [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DeciliterPerLiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DeciliterPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] - [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] - [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] - [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] - [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] + [InlineData("en-US", "l/l", VolumeConcentrationUnit.LiterPerLiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LiterPerMilliliter)] + [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicroliterPerLiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicroliterPerMilliliter)] + [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MilliliterPerLiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MilliliterPerMilliliter)] + [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanoliterPerLiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanoliterPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] [InlineData("en-US", "ppt", VolumeConcentrationUnit.PartPerTrillion)] [InlineData("en-US", "%", VolumeConcentrationUnit.Percent)] [InlineData("en-US", "% (v/v)", VolumeConcentrationUnit.Percent)] - [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] + [InlineData("en-US", "pl/l", VolumeConcentrationUnit.PicoliterPerLiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicoliterPerMilliliter)] public void TryParseUnit_WithCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { Assert.True(VolumeConcentration.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out VolumeConcentrationUnit parsedUnit)); @@ -1057,8 +1057,8 @@ public void CompareToThrowsOnNull() [Theory] [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.DecimalFraction, true)] // Same value and unit. [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 2, VolumeConcentrationUnit.DecimalFraction, false)] // Different value. - [InlineData(2, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentilitersPerLiter, false)] // Different value and unit. - [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentilitersPerLiter, false)] // Different unit. + [InlineData(2, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentiliterPerLiter, false)] // Different value and unit. + [InlineData(1, VolumeConcentrationUnit.DecimalFraction, 1, VolumeConcentrationUnit.CentiliterPerLiter, false)] // Different unit. public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, VolumeConcentrationUnit unitA, double valueB, VolumeConcentrationUnit unitB, bool expectEqual) { var a = new VolumeConcentration(valueA, unitA); @@ -1146,26 +1146,26 @@ public void BaseDimensionsShouldNeverBeNull() public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() { using var _ = new CultureScope("en-US"); - Assert.Equal("1 cl/l", new VolumeConcentration(1, VolumeConcentrationUnit.CentilitersPerLiter).ToString()); - Assert.Equal("1 cl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.CentilitersPerMilliliter).ToString()); - Assert.Equal("1 dl/l", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerLiter).ToString()); - Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerMilliliter).ToString()); + Assert.Equal("1 cl/l", new VolumeConcentration(1, VolumeConcentrationUnit.CentiliterPerLiter).ToString()); + Assert.Equal("1 cl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.CentiliterPerMilliliter).ToString()); + Assert.Equal("1 dl/l", new VolumeConcentration(1, VolumeConcentrationUnit.DeciliterPerLiter).ToString()); + Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DeciliterPerMilliliter).ToString()); Assert.Equal("1", new VolumeConcentration(1, VolumeConcentrationUnit.DecimalFraction).ToString()); - Assert.Equal("1 l/l", new VolumeConcentration(1, VolumeConcentrationUnit.LitersPerLiter).ToString()); - Assert.Equal("1 l/ml", new VolumeConcentration(1, VolumeConcentrationUnit.LitersPerMilliliter).ToString()); - Assert.Equal("1 µl/l", new VolumeConcentration(1, VolumeConcentrationUnit.MicrolitersPerLiter).ToString()); - Assert.Equal("1 µl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MicrolitersPerMilliliter).ToString()); - Assert.Equal("1 ml/l", new VolumeConcentration(1, VolumeConcentrationUnit.MillilitersPerLiter).ToString()); - Assert.Equal("1 ml/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MillilitersPerMilliliter).ToString()); - Assert.Equal("1 nl/l", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerLiter).ToString()); - Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerMilliliter).ToString()); + Assert.Equal("1 l/l", new VolumeConcentration(1, VolumeConcentrationUnit.LiterPerLiter).ToString()); + Assert.Equal("1 l/ml", new VolumeConcentration(1, VolumeConcentrationUnit.LiterPerMilliliter).ToString()); + Assert.Equal("1 µl/l", new VolumeConcentration(1, VolumeConcentrationUnit.MicroliterPerLiter).ToString()); + Assert.Equal("1 µl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MicroliterPerMilliliter).ToString()); + Assert.Equal("1 ml/l", new VolumeConcentration(1, VolumeConcentrationUnit.MilliliterPerLiter).ToString()); + Assert.Equal("1 ml/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MilliliterPerMilliliter).ToString()); + Assert.Equal("1 nl/l", new VolumeConcentration(1, VolumeConcentrationUnit.NanoliterPerLiter).ToString()); + Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanoliterPerMilliliter).ToString()); Assert.Equal("1 ppb", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerBillion).ToString()); Assert.Equal("1 ppm", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerMillion).ToString()); Assert.Equal("1 ‰", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerThousand).ToString()); Assert.Equal("1 ppt", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerTrillion).ToString()); Assert.Equal("1 %", new VolumeConcentration(1, VolumeConcentrationUnit.Percent).ToString()); - Assert.Equal("1 pl/l", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerLiter).ToString()); - Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerMilliliter).ToString()); + Assert.Equal("1 pl/l", new VolumeConcentration(1, VolumeConcentrationUnit.PicoliterPerLiter).ToString()); + Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicoliterPerMilliliter).ToString()); } [Fact] @@ -1174,26 +1174,26 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback. var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); - Assert.Equal("1 cl/l", new VolumeConcentration(1, VolumeConcentrationUnit.CentilitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 cl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.CentilitersPerMilliliter).ToString(swedishCulture)); - Assert.Equal("1 dl/l", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 cl/l", new VolumeConcentration(1, VolumeConcentrationUnit.CentiliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 cl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.CentiliterPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 dl/l", new VolumeConcentration(1, VolumeConcentrationUnit.DeciliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DeciliterPerMilliliter).ToString(swedishCulture)); Assert.Equal("1", new VolumeConcentration(1, VolumeConcentrationUnit.DecimalFraction).ToString(swedishCulture)); - Assert.Equal("1 l/l", new VolumeConcentration(1, VolumeConcentrationUnit.LitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 l/ml", new VolumeConcentration(1, VolumeConcentrationUnit.LitersPerMilliliter).ToString(swedishCulture)); - Assert.Equal("1 µl/l", new VolumeConcentration(1, VolumeConcentrationUnit.MicrolitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 µl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MicrolitersPerMilliliter).ToString(swedishCulture)); - Assert.Equal("1 ml/l", new VolumeConcentration(1, VolumeConcentrationUnit.MillilitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 ml/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MillilitersPerMilliliter).ToString(swedishCulture)); - Assert.Equal("1 nl/l", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 l/l", new VolumeConcentration(1, VolumeConcentrationUnit.LiterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 l/ml", new VolumeConcentration(1, VolumeConcentrationUnit.LiterPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 µl/l", new VolumeConcentration(1, VolumeConcentrationUnit.MicroliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 µl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MicroliterPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 ml/l", new VolumeConcentration(1, VolumeConcentrationUnit.MilliliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 ml/ml", new VolumeConcentration(1, VolumeConcentrationUnit.MilliliterPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 nl/l", new VolumeConcentration(1, VolumeConcentrationUnit.NanoliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanoliterPerMilliliter).ToString(swedishCulture)); Assert.Equal("1 ppb", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerBillion).ToString(swedishCulture)); Assert.Equal("1 ppm", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerMillion).ToString(swedishCulture)); Assert.Equal("1 ‰", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerThousand).ToString(swedishCulture)); Assert.Equal("1 ppt", new VolumeConcentration(1, VolumeConcentrationUnit.PartPerTrillion).ToString(swedishCulture)); Assert.Equal("1 %", new VolumeConcentration(1, VolumeConcentrationUnit.Percent).ToString(swedishCulture)); - Assert.Equal("1 pl/l", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerLiter).ToString(swedishCulture)); - Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerMilliliter).ToString(swedishCulture)); + Assert.Equal("1 pl/l", new VolumeConcentration(1, VolumeConcentrationUnit.PicoliterPerLiter).ToString(swedishCulture)); + Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicoliterPerMilliliter).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs index 90a6161a5b..6a598defda 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -80,26 +80,26 @@ static VolumeConcentration() Info = new QuantityInfo("VolumeConcentration", new UnitInfo[] { - new UnitInfo(VolumeConcentrationUnit.CentilitersPerLiter, "CentilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.CentilitersPerMilliliter, "CentilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.DecilitersPerLiter, "DecilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.DecilitersPerMilliliter, "DecilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.CentiliterPerLiter, "CentilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.CentiliterPerMilliliter, "CentilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.DeciliterPerLiter, "DecilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.DeciliterPerMilliliter, "DecilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.DecimalFraction, "DecimalFractions", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.LitersPerLiter, "LitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.LitersPerMilliliter, "LitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MicrolitersPerLiter, "MicrolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MicrolitersPerMilliliter, "MicrolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MillilitersPerLiter, "MillilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MillilitersPerMilliliter, "MillilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.NanolitersPerLiter, "NanolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.NanolitersPerMilliliter, "NanolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.LiterPerLiter, "LitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.LiterPerMilliliter, "LitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MicroliterPerLiter, "MicrolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MicroliterPerMilliliter, "MicrolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MilliliterPerLiter, "MillilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MilliliterPerMilliliter, "MillilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.NanoliterPerLiter, "NanolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.NanoliterPerMilliliter, "NanolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.PartPerBillion, "PartsPerBillion", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.PartPerMillion, "PartsPerMillion", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.PartPerThousand, "PartsPerThousand", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.PartPerTrillion, "PartsPerTrillion", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.Percent, "Percent", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.PicolitersPerLiter, "PicolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.PicolitersPerMilliliter, "PicolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.PicoliterPerLiter, "PicolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.PicoliterPerMilliliter, "PicolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), }, BaseUnit, Zero, BaseDimensions); @@ -184,24 +184,24 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) #region Conversion Properties /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter); + public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentiliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentilitersPerMilliliter); + public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentiliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter); + public double DecilitersPerLiter => As(VolumeConcentrationUnit.DeciliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DecilitersPerMilliliter); + public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DeciliterPerMilliliter); /// /// Gets a value of this quantity converted into @@ -209,44 +209,44 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double DecimalFractions => As(VolumeConcentrationUnit.DecimalFraction); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter); + public double LitersPerLiter => As(VolumeConcentrationUnit.LiterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerMilliliter => As(VolumeConcentrationUnit.LitersPerMilliliter); + public double LitersPerMilliliter => As(VolumeConcentrationUnit.LiterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter); + public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicroliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicrolitersPerMilliliter); + public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicroliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter); + public double MillilitersPerLiter => As(VolumeConcentrationUnit.MilliliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MillilitersPerMilliliter); + public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MilliliterPerMilliliter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter); + public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanoliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanolitersPerMilliliter); + public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanoliterPerMilliliter); /// /// Gets a value of this quantity converted into @@ -274,14 +274,14 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double Percent => As(VolumeConcentrationUnit.Percent); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter); + public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicoliterPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicolitersPerMilliliter); + public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicoliterPerMilliliter); #endregion @@ -294,49 +294,49 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) internal static void RegisterDefaultConversions(UnitConverter unitConverter) { // Register in unit converter: VolumeConcentrationUnit -> BaseUnit - unitConverter.SetConversionFunction(VolumeConcentrationUnit.CentilitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.CentilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecilitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.LitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.LitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.MicrolitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.MicrolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.MillilitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.MillilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.NanolitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.NanolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.CentiliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.CentiliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DeciliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DeciliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.LiterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.LiterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.MicroliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.MicroliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.MilliliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.MilliliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.NanoliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.NanoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.PartPerBillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.PartPerMillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.PartPerThousand, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.PartPerTrillion, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.Percent, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.PicolitersPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.PicolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.PicoliterPerLiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.PicoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); // Register in unit converter: BaseUnit <-> BaseUnit unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecimalFraction, quantity => quantity); // Register in unit converter: BaseUnit -> VolumeConcentrationUnit - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentilitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentilitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentilitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentilitersPerMilliliter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecilitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecilitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecilitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecilitersPerMilliliter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LitersPerMilliliter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicrolitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicrolitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicrolitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicrolitersPerMilliliter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MillilitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MillilitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MillilitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MillilitersPerMilliliter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanolitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanolitersPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentiliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentiliterPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DeciliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DeciliterPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LiterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LiterPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicroliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicroliterPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MilliliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MilliliterPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanoliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanoliterPerMilliliter)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerBillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerBillion)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerMillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerMillion)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerThousand, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerThousand)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerTrillion, quantity => quantity.ToUnit(VolumeConcentrationUnit.PartPerTrillion)); unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.Percent, quantity => quantity.ToUnit(VolumeConcentrationUnit.Percent)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicolitersPerLiter)); - unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicolitersPerMilliliter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerLiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicoliterPerLiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicoliterPerMilliliter)); } /// @@ -365,35 +365,35 @@ public static string GetAbbreviation(VolumeConcentrationUnit unit, IFormatProvid #region Static Factory Methods /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromCentilitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.CentiliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromCentilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.CentiliterPerMilliliter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromDecilitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.DeciliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromDecilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.DeciliterPerMilliliter); } /// @@ -405,67 +405,67 @@ public static VolumeConcentration FromDecimalFractions(double value) } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromLitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.LiterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromLitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.LiterPerMilliliter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromMicrolitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MicroliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromMicrolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MicroliterPerMilliliter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromMillilitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MilliliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromMillilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MilliliterPerMilliliter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromNanolitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.NanoliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromNanolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.NanoliterPerMilliliter); } /// @@ -509,19 +509,19 @@ public static VolumeConcentration FromPercent(double value) } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromPicolitersPerLiter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.PicoliterPerLiter); } /// - /// Creates a from . + /// Creates a from . /// public static VolumeConcentration FromPicolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMilliliter); + return new VolumeConcentration(value, VolumeConcentrationUnit.PicoliterPerMilliliter); } /// @@ -1006,46 +1006,46 @@ private bool TryToUnit(VolumeConcentrationUnit unit, [NotNullWhen(true)] out Vol VolumeConcentration? convertedOrNull = (Unit, unit) switch { // VolumeConcentrationUnit -> BaseUnit - (VolumeConcentrationUnit.CentilitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-2d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.CentilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-2d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.DecilitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-1d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.DecilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-1d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.LitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.LitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e-3, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.MicrolitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-6d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.MicrolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-6d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.MillilitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-3d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.MillilitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-3d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.NanolitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-9d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.NanolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-9d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.CentiliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-2d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.CentiliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-2d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.DeciliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-1d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.DeciliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-1d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.LiterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.LiterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e-3, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.MicroliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-6d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.MicroliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-6d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.MilliliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-3d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.MilliliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-3d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.NanoliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-9d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.NanoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-9d, VolumeConcentrationUnit.DecimalFraction), (VolumeConcentrationUnit.PartPerBillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e9, VolumeConcentrationUnit.DecimalFraction), (VolumeConcentrationUnit.PartPerMillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e6, VolumeConcentrationUnit.DecimalFraction), (VolumeConcentrationUnit.PartPerThousand, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e3, VolumeConcentrationUnit.DecimalFraction), (VolumeConcentrationUnit.PartPerTrillion, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e12, VolumeConcentrationUnit.DecimalFraction), (VolumeConcentrationUnit.Percent, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e2, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.PicolitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-12d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.PicolitersPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-12d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.PicoliterPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-12d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.PicoliterPerMilliliter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-12d, VolumeConcentrationUnit.DecimalFraction), // BaseUnit -> VolumeConcentrationUnit - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentilitersPerLiter) => new VolumeConcentration((_value) / 1e-2d, VolumeConcentrationUnit.CentilitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentilitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-2d, VolumeConcentrationUnit.CentilitersPerMilliliter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecilitersPerLiter) => new VolumeConcentration((_value) / 1e-1d, VolumeConcentrationUnit.DecilitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DecilitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-1d, VolumeConcentrationUnit.DecilitersPerMilliliter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LitersPerLiter) => new VolumeConcentration(_value, VolumeConcentrationUnit.LitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LitersPerMilliliter) => new VolumeConcentration(_value * 1e-3, VolumeConcentrationUnit.LitersPerMilliliter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicrolitersPerLiter) => new VolumeConcentration((_value) / 1e-6d, VolumeConcentrationUnit.MicrolitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicrolitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-6d, VolumeConcentrationUnit.MicrolitersPerMilliliter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MillilitersPerLiter) => new VolumeConcentration((_value) / 1e-3d, VolumeConcentrationUnit.MillilitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MillilitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-3d, VolumeConcentrationUnit.MillilitersPerMilliliter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerLiter) => new VolumeConcentration((_value) / 1e-9d, VolumeConcentrationUnit.NanolitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-9d, VolumeConcentrationUnit.NanolitersPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerLiter) => new VolumeConcentration((_value) / 1e-2d, VolumeConcentrationUnit.CentiliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.CentiliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-2d, VolumeConcentrationUnit.CentiliterPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerLiter) => new VolumeConcentration((_value) / 1e-1d, VolumeConcentrationUnit.DeciliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.DeciliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-1d, VolumeConcentrationUnit.DeciliterPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerLiter) => new VolumeConcentration(_value, VolumeConcentrationUnit.LiterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.LiterPerMilliliter) => new VolumeConcentration(_value * 1e-3, VolumeConcentrationUnit.LiterPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerLiter) => new VolumeConcentration((_value) / 1e-6d, VolumeConcentrationUnit.MicroliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MicroliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-6d, VolumeConcentrationUnit.MicroliterPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerLiter) => new VolumeConcentration((_value) / 1e-3d, VolumeConcentrationUnit.MilliliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.MilliliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-3d, VolumeConcentrationUnit.MilliliterPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerLiter) => new VolumeConcentration((_value) / 1e-9d, VolumeConcentrationUnit.NanoliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanoliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-9d, VolumeConcentrationUnit.NanoliterPerMilliliter), (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerBillion) => new VolumeConcentration(_value * 1e9, VolumeConcentrationUnit.PartPerBillion), (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerMillion) => new VolumeConcentration(_value * 1e6, VolumeConcentrationUnit.PartPerMillion), (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerThousand) => new VolumeConcentration(_value * 1e3, VolumeConcentrationUnit.PartPerThousand), (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PartPerTrillion) => new VolumeConcentration(_value * 1e12, VolumeConcentrationUnit.PartPerTrillion), (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.Percent) => new VolumeConcentration(_value * 1e2, VolumeConcentrationUnit.Percent), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerLiter) => new VolumeConcentration((_value) / 1e-12d, VolumeConcentrationUnit.PicolitersPerLiter), - (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-12d, VolumeConcentrationUnit.PicolitersPerMilliliter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerLiter) => new VolumeConcentration((_value) / 1e-12d, VolumeConcentrationUnit.PicoliterPerLiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicoliterPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-12d, VolumeConcentrationUnit.PicoliterPerMilliliter), _ => null }; diff --git a/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs index 283715f8af..5624e121d1 100644 --- a/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs @@ -25,26 +25,26 @@ namespace UnitsNet.Units public enum VolumeConcentrationUnit { - CentilitersPerLiter = 1, - CentilitersPerMilliliter = 2, - DecilitersPerLiter = 3, - DecilitersPerMilliliter = 4, + CentiliterPerLiter = 1, + CentiliterPerMilliliter = 2, + DeciliterPerLiter = 3, + DeciliterPerMilliliter = 4, DecimalFraction = 5, - LitersPerLiter = 6, - LitersPerMilliliter = 7, - MicrolitersPerLiter = 8, - MicrolitersPerMilliliter = 9, - MillilitersPerLiter = 10, - MillilitersPerMilliliter = 11, - NanolitersPerLiter = 12, - NanolitersPerMilliliter = 13, + LiterPerLiter = 6, + LiterPerMilliliter = 7, + MicroliterPerLiter = 8, + MicroliterPerMilliliter = 9, + MilliliterPerLiter = 10, + MilliliterPerMilliliter = 11, + NanoliterPerLiter = 12, + NanoliterPerMilliliter = 13, PartPerBillion = 14, PartPerMillion = 15, PartPerThousand = 16, PartPerTrillion = 17, Percent = 18, - PicolitersPerLiter = 19, - PicolitersPerMilliliter = 20, + PicoliterPerLiter = 19, + PicoliterPerMilliliter = 20, } #pragma warning restore 1591