diff --git a/Common/UnitDefinitions/VolumeConcentration.json b/Common/UnitDefinitions/VolumeConcentration.json index f6bb6ba684..170d9f22b5 100644 --- a/Common/UnitDefinitions/VolumeConcentration.json +++ b/Common/UnitDefinitions/VolumeConcentration.json @@ -30,8 +30,8 @@ ] }, { - "SingularName": "LitersPerMililiter", - "PluralName": "LitersPerMililiter", + "SingularName": "LitersPerMilliliter", + "PluralName": "LitersPerMilliliter", "FromUnitToBaseFunc": "{x} / 1e-3", "FromBaseToUnitFunc": "{x} * 1e-3", "Prefixes": [ "Pico", "Nano", "Micro", "Milli", "Centi", "Deci" ], diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index 19ab8982d4..82ae7db2ed 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -1580,25 +1580,25 @@ }, "VolumeConcentration": { "CentilitersPerLiter": 1, - "CentilitersPerMililiter": 2, + "CentilitersPerMilliliter": 2, "DecilitersPerLiter": 3, - "DecilitersPerMililiter": 4, + "DecilitersPerMilliliter": 4, "DecimalFraction": 5, "LitersPerLiter": 6, - "LitersPerMililiter": 7, + "LitersPerMilliliter": 7, "MicrolitersPerLiter": 8, - "MicrolitersPerMililiter": 9, + "MicrolitersPerMilliliter": 9, "MillilitersPerLiter": 10, - "MillilitersPerMililiter": 11, + "MillilitersPerMilliliter": 11, "NanolitersPerLiter": 12, - "NanolitersPerMililiter": 13, + "NanolitersPerMilliliter": 13, "PartPerBillion": 14, "PartPerMillion": 15, "PartPerThousand": 16, "PartPerTrillion": 17, "Percent": 18, "PicolitersPerLiter": 19, - "PicolitersPerMililiter": 20 + "PicolitersPerMilliliter": 20 }, "VolumeFlow": { "AcreFootPerDay": 1, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs index dac0096644..a58548a834 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -87,9 +87,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerMililiter => As(VolumeConcentrationUnit.CentilitersPerMililiter); + public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -97,9 +97,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerMililiter => As(VolumeConcentrationUnit.DecilitersPerMililiter); + public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DecilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -112,9 +112,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerMililiter => As(VolumeConcentrationUnit.LitersPerMililiter); + public double LitersPerMilliliter => As(VolumeConcentrationUnit.LitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -122,9 +122,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerMililiter => As(VolumeConcentrationUnit.MicrolitersPerMililiter); + public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicrolitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -132,9 +132,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerMililiter => As(VolumeConcentrationUnit.MillilitersPerMililiter); + public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MillilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -142,9 +142,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerMililiter => As(VolumeConcentrationUnit.NanolitersPerMililiter); + public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanolitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -177,9 +177,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerMililiter => As(VolumeConcentrationUnit.PicolitersPerMililiter); + public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicolitersPerMilliliter); #endregion @@ -191,9 +191,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter) => new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentilitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromCentilitersPerMililiter(double centiliterspermililiter) => new VolumeConcentration(centiliterspermililiter, VolumeConcentrationUnit.CentilitersPerMililiter); + public static VolumeConcentration FromCentilitersPerMilliliter(double centiliterspermilliliter) => new VolumeConcentration(centiliterspermilliliter, VolumeConcentrationUnit.CentilitersPerMilliliter); /// /// Creates a from . @@ -201,9 +201,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter) => new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DecilitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromDecilitersPerMililiter(double deciliterspermililiter) => new VolumeConcentration(deciliterspermililiter, VolumeConcentrationUnit.DecilitersPerMililiter); + public static VolumeConcentration FromDecilitersPerMilliliter(double deciliterspermilliliter) => new VolumeConcentration(deciliterspermilliliter, VolumeConcentrationUnit.DecilitersPerMilliliter); /// /// Creates a from . @@ -216,9 +216,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromLitersPerLiter(double litersperliter) => new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromLitersPerMililiter(double literspermililiter) => new VolumeConcentration(literspermililiter, VolumeConcentrationUnit.LitersPerMililiter); + public static VolumeConcentration FromLitersPerMilliliter(double literspermilliliter) => new VolumeConcentration(literspermilliliter, VolumeConcentrationUnit.LitersPerMilliliter); /// /// Creates a from . @@ -226,9 +226,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter) => new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicrolitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMicrolitersPerMililiter(double microliterspermililiter) => new VolumeConcentration(microliterspermililiter, VolumeConcentrationUnit.MicrolitersPerMililiter); + public static VolumeConcentration FromMicrolitersPerMilliliter(double microliterspermilliliter) => new VolumeConcentration(microliterspermilliliter, VolumeConcentrationUnit.MicrolitersPerMilliliter); /// /// Creates a from . @@ -236,9 +236,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter) => new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MillilitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMillilitersPerMililiter(double milliliterspermililiter) => new VolumeConcentration(milliliterspermililiter, VolumeConcentrationUnit.MillilitersPerMililiter); + public static VolumeConcentration FromMillilitersPerMilliliter(double milliliterspermilliliter) => new VolumeConcentration(milliliterspermilliliter, VolumeConcentrationUnit.MillilitersPerMilliliter); /// /// Creates a from . @@ -246,9 +246,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter) => new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanolitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromNanolitersPerMililiter(double nanoliterspermililiter) => new VolumeConcentration(nanoliterspermililiter, VolumeConcentrationUnit.NanolitersPerMililiter); + public static VolumeConcentration FromNanolitersPerMilliliter(double nanoliterspermilliliter) => new VolumeConcentration(nanoliterspermilliliter, VolumeConcentrationUnit.NanolitersPerMilliliter); /// /// Creates a from . @@ -281,9 +281,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter) => new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicolitersPerLiter); /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromPicolitersPerMililiter(double picoliterspermililiter) => new VolumeConcentration(picoliterspermililiter, VolumeConcentrationUnit.PicolitersPerMililiter); + public static VolumeConcentration FromPicolitersPerMilliliter(double picoliterspermilliliter) => new VolumeConcentration(picoliterspermilliliter, VolumeConcentrationUnit.PicolitersPerMilliliter); /// /// Dynamically convert from value and unit enum to . @@ -326,25 +326,25 @@ private double GetValueInBaseUnit() return Unit switch { VolumeConcentrationUnit.CentilitersPerLiter => (_value) * 1e-2d, - VolumeConcentrationUnit.CentilitersPerMililiter => (_value / 1e-3) * 1e-2d, + VolumeConcentrationUnit.CentilitersPerMilliliter => (_value / 1e-3) * 1e-2d, VolumeConcentrationUnit.DecilitersPerLiter => (_value) * 1e-1d, - VolumeConcentrationUnit.DecilitersPerMililiter => (_value / 1e-3) * 1e-1d, + VolumeConcentrationUnit.DecilitersPerMilliliter => (_value / 1e-3) * 1e-1d, VolumeConcentrationUnit.DecimalFraction => _value, VolumeConcentrationUnit.LitersPerLiter => _value, - VolumeConcentrationUnit.LitersPerMililiter => _value / 1e-3, + VolumeConcentrationUnit.LitersPerMilliliter => _value / 1e-3, VolumeConcentrationUnit.MicrolitersPerLiter => (_value) * 1e-6d, - VolumeConcentrationUnit.MicrolitersPerMililiter => (_value / 1e-3) * 1e-6d, + VolumeConcentrationUnit.MicrolitersPerMilliliter => (_value / 1e-3) * 1e-6d, VolumeConcentrationUnit.MillilitersPerLiter => (_value) * 1e-3d, - VolumeConcentrationUnit.MillilitersPerMililiter => (_value / 1e-3) * 1e-3d, + VolumeConcentrationUnit.MillilitersPerMilliliter => (_value / 1e-3) * 1e-3d, VolumeConcentrationUnit.NanolitersPerLiter => (_value) * 1e-9d, - VolumeConcentrationUnit.NanolitersPerMililiter => (_value / 1e-3) * 1e-9d, + VolumeConcentrationUnit.NanolitersPerMilliliter => (_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.PicolitersPerMililiter => (_value / 1e-3) * 1e-12d, + VolumeConcentrationUnit.PicolitersPerMilliliter => (_value / 1e-3) * 1e-12d, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -359,25 +359,25 @@ private double GetValueAs(VolumeConcentrationUnit unit) return unit switch { VolumeConcentrationUnit.CentilitersPerLiter => (baseUnitValue) / 1e-2d, - VolumeConcentrationUnit.CentilitersPerMililiter => (baseUnitValue * 1e-3) / 1e-2d, + VolumeConcentrationUnit.CentilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-2d, VolumeConcentrationUnit.DecilitersPerLiter => (baseUnitValue) / 1e-1d, - VolumeConcentrationUnit.DecilitersPerMililiter => (baseUnitValue * 1e-3) / 1e-1d, + VolumeConcentrationUnit.DecilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-1d, VolumeConcentrationUnit.DecimalFraction => baseUnitValue, VolumeConcentrationUnit.LitersPerLiter => baseUnitValue, - VolumeConcentrationUnit.LitersPerMililiter => baseUnitValue * 1e-3, + VolumeConcentrationUnit.LitersPerMilliliter => baseUnitValue * 1e-3, VolumeConcentrationUnit.MicrolitersPerLiter => (baseUnitValue) / 1e-6d, - VolumeConcentrationUnit.MicrolitersPerMililiter => (baseUnitValue * 1e-3) / 1e-6d, + VolumeConcentrationUnit.MicrolitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-6d, VolumeConcentrationUnit.MillilitersPerLiter => (baseUnitValue) / 1e-3d, - VolumeConcentrationUnit.MillilitersPerMililiter => (baseUnitValue * 1e-3) / 1e-3d, + VolumeConcentrationUnit.MillilitersPerMilliliter => (baseUnitValue * 1e-3) / 1e-3d, VolumeConcentrationUnit.NanolitersPerLiter => (baseUnitValue) / 1e-9d, - VolumeConcentrationUnit.NanolitersPerMililiter => (baseUnitValue * 1e-3) / 1e-9d, + VolumeConcentrationUnit.NanolitersPerMilliliter => (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.PicolitersPerMililiter => (baseUnitValue * 1e-3) / 1e-12d, + VolumeConcentrationUnit.PicolitersPerMilliliter => (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 b60c944f4a..283715f8af 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeConcentrationUnit.g.cs @@ -26,25 +26,25 @@ namespace UnitsNet.Units public enum VolumeConcentrationUnit { CentilitersPerLiter = 1, - CentilitersPerMililiter = 2, + CentilitersPerMilliliter = 2, DecilitersPerLiter = 3, - DecilitersPerMililiter = 4, + DecilitersPerMilliliter = 4, DecimalFraction = 5, LitersPerLiter = 6, - LitersPerMililiter = 7, + LitersPerMilliliter = 7, MicrolitersPerLiter = 8, - MicrolitersPerMililiter = 9, + MicrolitersPerMilliliter = 9, MillilitersPerLiter = 10, - MillilitersPerMililiter = 11, + MillilitersPerMilliliter = 11, NanolitersPerLiter = 12, - NanolitersPerMililiter = 13, + NanolitersPerMilliliter = 13, PartPerBillion = 14, PartPerMillion = 15, PartPerThousand = 16, PartPerTrillion = 17, Percent = 18, PicolitersPerLiter = 19, - PicolitersPerMililiter = 20, + PicolitersPerMilliliter = 20, } #pragma warning restore 1591 diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs index fdd956a598..8c447de03a 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs @@ -29,16 +29,16 @@ public void NumberToCentilitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromCentilitersPerLiter(2), 2.CentilitersPerLiter()); [Fact] - public void NumberToCentilitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromCentilitersPerMililiter(2), 2.CentilitersPerMililiter()); + public void NumberToCentilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromCentilitersPerMilliliter(2), 2.CentilitersPerMilliliter()); [Fact] public void NumberToDecilitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromDecilitersPerLiter(2), 2.DecilitersPerLiter()); [Fact] - public void NumberToDecilitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromDecilitersPerMililiter(2), 2.DecilitersPerMililiter()); + public void NumberToDecilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromDecilitersPerMilliliter(2), 2.DecilitersPerMilliliter()); [Fact] public void NumberToDecimalFractionsTest() => @@ -49,32 +49,32 @@ public void NumberToLitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromLitersPerLiter(2), 2.LitersPerLiter()); [Fact] - public void NumberToLitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromLitersPerMililiter(2), 2.LitersPerMililiter()); + public void NumberToLitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromLitersPerMilliliter(2), 2.LitersPerMilliliter()); [Fact] public void NumberToMicrolitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromMicrolitersPerLiter(2), 2.MicrolitersPerLiter()); [Fact] - public void NumberToMicrolitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromMicrolitersPerMililiter(2), 2.MicrolitersPerMililiter()); + public void NumberToMicrolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromMicrolitersPerMilliliter(2), 2.MicrolitersPerMilliliter()); [Fact] public void NumberToMillilitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromMillilitersPerLiter(2), 2.MillilitersPerLiter()); [Fact] - public void NumberToMillilitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromMillilitersPerMililiter(2), 2.MillilitersPerMililiter()); + public void NumberToMillilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromMillilitersPerMilliliter(2), 2.MillilitersPerMilliliter()); [Fact] public void NumberToNanolitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromNanolitersPerLiter(2), 2.NanolitersPerLiter()); [Fact] - public void NumberToNanolitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromNanolitersPerMililiter(2), 2.NanolitersPerMililiter()); + public void NumberToNanolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromNanolitersPerMilliliter(2), 2.NanolitersPerMilliliter()); [Fact] public void NumberToPartsPerBillionTest() => @@ -101,8 +101,8 @@ public void NumberToPicolitersPerLiterTest() => Assert.Equal(VolumeConcentration.FromPicolitersPerLiter(2), 2.PicolitersPerLiter()); [Fact] - public void NumberToPicolitersPerMililiterTest() => - Assert.Equal(VolumeConcentration.FromPicolitersPerMililiter(2), 2.PicolitersPerMililiter()); + public void NumberToPicolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromPicolitersPerMilliliter(2), 2.PicolitersPerMilliliter()); } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs index d3faaab660..c22d7f6ee7 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs @@ -40,13 +40,13 @@ public static VolumeConcentration CentilitersPerLiter(this T value) #endif => VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration CentilitersPerMililiter(this T value) + /// + public static VolumeConcentration CentilitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromCentilitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration DecilitersPerLiter(this T value) @@ -56,13 +56,13 @@ public static VolumeConcentration DecilitersPerLiter(this T value) #endif => VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration DecilitersPerMililiter(this T value) + /// + public static VolumeConcentration DecilitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromDecilitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration DecimalFractions(this T value) @@ -80,13 +80,13 @@ public static VolumeConcentration LitersPerLiter(this T value) #endif => VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration LitersPerMililiter(this T value) + /// + public static VolumeConcentration LitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromLitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration MicrolitersPerLiter(this T value) @@ -96,13 +96,13 @@ public static VolumeConcentration MicrolitersPerLiter(this T value) #endif => VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration MicrolitersPerMililiter(this T value) + /// + public static VolumeConcentration MicrolitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromMicrolitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration MillilitersPerLiter(this T value) @@ -112,13 +112,13 @@ public static VolumeConcentration MillilitersPerLiter(this T value) #endif => VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration MillilitersPerMililiter(this T value) + /// + public static VolumeConcentration MillilitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromMillilitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration NanolitersPerLiter(this T value) @@ -128,13 +128,13 @@ public static VolumeConcentration NanolitersPerLiter(this T value) #endif => VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration NanolitersPerMililiter(this T value) + /// + public static VolumeConcentration NanolitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromNanolitersPerMilliliter(Convert.ToDouble(value)); /// public static VolumeConcentration PartsPerBillion(this T value) @@ -184,13 +184,13 @@ public static VolumeConcentration PicolitersPerLiter(this T value) #endif => VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value)); - /// - public static VolumeConcentration PicolitersPerMililiter(this T value) + /// + public static VolumeConcentration PicolitersPerMilliliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => VolumeConcentration.FromPicolitersPerMililiter(Convert.ToDouble(value)); + => VolumeConcentration.FromPicolitersPerMilliliter(Convert.ToDouble(value)); } } diff --git a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs index 38871cea73..7a80012573 100644 --- a/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeConcentrationTests.cs @@ -31,13 +31,13 @@ public class VolumeConcentrationTests : VolumeConcentrationTestsBase protected override bool SupportsSIUnitSystem => false; #region Unit Conversion Coefficients - protected override double LitersPerMililiterInOneDecimalFraction => 1E-3; - protected override double DecilitersPerMililiterInOneDecimalFraction => 1E-2; - protected override double CentilitersPerMililiterInOneDecimalFraction => 1E-1; - protected override double MillilitersPerMililiterInOneDecimalFraction => 1; - protected override double MicrolitersPerMililiterInOneDecimalFraction => 1E3; - protected override double NanolitersPerMililiterInOneDecimalFraction => 1E6; - protected override double PicolitersPerMililiterInOneDecimalFraction => 1E9; + protected override double LitersPerMilliliterInOneDecimalFraction => 1E-3; + protected override double DecilitersPerMilliliterInOneDecimalFraction => 1E-2; + protected override double CentilitersPerMilliliterInOneDecimalFraction => 1E-1; + protected override double MillilitersPerMilliliterInOneDecimalFraction => 1; + protected override double MicrolitersPerMilliliterInOneDecimalFraction => 1E3; + protected override double NanolitersPerMilliliterInOneDecimalFraction => 1E6; + protected override double PicolitersPerMilliliterInOneDecimalFraction => 1E9; protected override double LitersPerLiterInOneDecimalFraction => 1; protected override double DecilitersPerLiterInOneDecimalFraction => 10; diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index ae41b54f20..b76b821b63 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.PicolitersPerMililiter, Quantity.From(3, VolumeConcentrationUnit.PicolitersPerMililiter)); + Assertion(3, VolumeConcentrationUnit.PicolitersPerMilliliter, Quantity.From(3, VolumeConcentrationUnit.PicolitersPerMilliliter)); 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 9f7b750d99..618934d8f7 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeConcentrationTestsBase.g.cs @@ -40,47 +40,47 @@ namespace UnitsNet.Tests public abstract partial class VolumeConcentrationTestsBase : QuantityTestsBase { protected abstract double CentilitersPerLiterInOneDecimalFraction { get; } - protected abstract double CentilitersPerMililiterInOneDecimalFraction { get; } + protected abstract double CentilitersPerMilliliterInOneDecimalFraction { get; } protected abstract double DecilitersPerLiterInOneDecimalFraction { get; } - protected abstract double DecilitersPerMililiterInOneDecimalFraction { get; } + protected abstract double DecilitersPerMilliliterInOneDecimalFraction { get; } protected abstract double DecimalFractionsInOneDecimalFraction { get; } protected abstract double LitersPerLiterInOneDecimalFraction { get; } - protected abstract double LitersPerMililiterInOneDecimalFraction { get; } + protected abstract double LitersPerMilliliterInOneDecimalFraction { get; } protected abstract double MicrolitersPerLiterInOneDecimalFraction { get; } - protected abstract double MicrolitersPerMililiterInOneDecimalFraction { get; } + protected abstract double MicrolitersPerMilliliterInOneDecimalFraction { get; } protected abstract double MillilitersPerLiterInOneDecimalFraction { get; } - protected abstract double MillilitersPerMililiterInOneDecimalFraction { get; } + protected abstract double MillilitersPerMilliliterInOneDecimalFraction { get; } protected abstract double NanolitersPerLiterInOneDecimalFraction { get; } - protected abstract double NanolitersPerMililiterInOneDecimalFraction { get; } + protected abstract double NanolitersPerMilliliterInOneDecimalFraction { get; } protected abstract double PartsPerBillionInOneDecimalFraction { get; } protected abstract double PartsPerMillionInOneDecimalFraction { get; } protected abstract double PartsPerThousandInOneDecimalFraction { get; } protected abstract double PartsPerTrillionInOneDecimalFraction { get; } protected abstract double PercentInOneDecimalFraction { get; } protected abstract double PicolitersPerLiterInOneDecimalFraction { get; } - protected abstract double PicolitersPerMililiterInOneDecimalFraction { get; } + protected abstract double PicolitersPerMilliliterInOneDecimalFraction { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentilitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double CentilitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double CentilitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double DecilitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double DecilitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double DecilitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double DecimalFractionsTolerance { get { return 1e-5; } } protected virtual double LitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double LitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double LitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double MicrolitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double MicrolitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double MicrolitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double MillilitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double MillilitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double MillilitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double NanolitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double NanolitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double NanolitersPerMilliliterTolerance { get { return 1e-5; } } protected virtual double PartsPerBillionTolerance { get { return 1e-5; } } protected virtual double PartsPerMillionTolerance { get { return 1e-5; } } protected virtual double PartsPerThousandTolerance { get { return 1e-5; } } protected virtual double PartsPerTrillionTolerance { get { return 1e-5; } } protected virtual double PercentTolerance { get { return 1e-5; } } protected virtual double PicolitersPerLiterTolerance { get { return 1e-5; } } - protected virtual double PicolitersPerMililiterTolerance { get { return 1e-5; } } + protected virtual double PicolitersPerMilliliterTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(VolumeConcentrationUnit unit) @@ -88,25 +88,25 @@ public abstract partial class VolumeConcentrationTestsBase : QuantityTestsBase return unit switch { VolumeConcentrationUnit.CentilitersPerLiter => (CentilitersPerLiterInOneDecimalFraction, CentilitersPerLiterTolerance), - VolumeConcentrationUnit.CentilitersPerMililiter => (CentilitersPerMililiterInOneDecimalFraction, CentilitersPerMililiterTolerance), + VolumeConcentrationUnit.CentilitersPerMilliliter => (CentilitersPerMilliliterInOneDecimalFraction, CentilitersPerMilliliterTolerance), VolumeConcentrationUnit.DecilitersPerLiter => (DecilitersPerLiterInOneDecimalFraction, DecilitersPerLiterTolerance), - VolumeConcentrationUnit.DecilitersPerMililiter => (DecilitersPerMililiterInOneDecimalFraction, DecilitersPerMililiterTolerance), + VolumeConcentrationUnit.DecilitersPerMilliliter => (DecilitersPerMilliliterInOneDecimalFraction, DecilitersPerMilliliterTolerance), VolumeConcentrationUnit.DecimalFraction => (DecimalFractionsInOneDecimalFraction, DecimalFractionsTolerance), VolumeConcentrationUnit.LitersPerLiter => (LitersPerLiterInOneDecimalFraction, LitersPerLiterTolerance), - VolumeConcentrationUnit.LitersPerMililiter => (LitersPerMililiterInOneDecimalFraction, LitersPerMililiterTolerance), + VolumeConcentrationUnit.LitersPerMilliliter => (LitersPerMilliliterInOneDecimalFraction, LitersPerMilliliterTolerance), VolumeConcentrationUnit.MicrolitersPerLiter => (MicrolitersPerLiterInOneDecimalFraction, MicrolitersPerLiterTolerance), - VolumeConcentrationUnit.MicrolitersPerMililiter => (MicrolitersPerMililiterInOneDecimalFraction, MicrolitersPerMililiterTolerance), + VolumeConcentrationUnit.MicrolitersPerMilliliter => (MicrolitersPerMilliliterInOneDecimalFraction, MicrolitersPerMilliliterTolerance), VolumeConcentrationUnit.MillilitersPerLiter => (MillilitersPerLiterInOneDecimalFraction, MillilitersPerLiterTolerance), - VolumeConcentrationUnit.MillilitersPerMililiter => (MillilitersPerMililiterInOneDecimalFraction, MillilitersPerMililiterTolerance), + VolumeConcentrationUnit.MillilitersPerMilliliter => (MillilitersPerMilliliterInOneDecimalFraction, MillilitersPerMilliliterTolerance), VolumeConcentrationUnit.NanolitersPerLiter => (NanolitersPerLiterInOneDecimalFraction, NanolitersPerLiterTolerance), - VolumeConcentrationUnit.NanolitersPerMililiter => (NanolitersPerMililiterInOneDecimalFraction, NanolitersPerMililiterTolerance), + VolumeConcentrationUnit.NanolitersPerMilliliter => (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.PicolitersPerMililiter => (PicolitersPerMililiterInOneDecimalFraction, PicolitersPerMililiterTolerance), + VolumeConcentrationUnit.PicolitersPerMilliliter => (PicolitersPerMilliliterInOneDecimalFraction, PicolitersPerMilliliterTolerance), _ => throw new NotSupportedException() }; } @@ -114,25 +114,25 @@ public abstract partial class VolumeConcentrationTestsBase : QuantityTestsBase public static IEnumerable UnitTypes = new List { new object[] { VolumeConcentrationUnit.CentilitersPerLiter }, - new object[] { VolumeConcentrationUnit.CentilitersPerMililiter }, + new object[] { VolumeConcentrationUnit.CentilitersPerMilliliter }, new object[] { VolumeConcentrationUnit.DecilitersPerLiter }, - new object[] { VolumeConcentrationUnit.DecilitersPerMililiter }, + new object[] { VolumeConcentrationUnit.DecilitersPerMilliliter }, new object[] { VolumeConcentrationUnit.DecimalFraction }, new object[] { VolumeConcentrationUnit.LitersPerLiter }, - new object[] { VolumeConcentrationUnit.LitersPerMililiter }, + new object[] { VolumeConcentrationUnit.LitersPerMilliliter }, new object[] { VolumeConcentrationUnit.MicrolitersPerLiter }, - new object[] { VolumeConcentrationUnit.MicrolitersPerMililiter }, + new object[] { VolumeConcentrationUnit.MicrolitersPerMilliliter }, new object[] { VolumeConcentrationUnit.MillilitersPerLiter }, - new object[] { VolumeConcentrationUnit.MillilitersPerMililiter }, + new object[] { VolumeConcentrationUnit.MillilitersPerMilliliter }, new object[] { VolumeConcentrationUnit.NanolitersPerLiter }, - new object[] { VolumeConcentrationUnit.NanolitersPerMililiter }, + new object[] { VolumeConcentrationUnit.NanolitersPerMilliliter }, 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.PicolitersPerMililiter }, + new object[] { VolumeConcentrationUnit.PicolitersPerMilliliter }, }; [Fact] @@ -180,25 +180,25 @@ public void DecimalFractionToVolumeConcentrationUnits() { VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1); AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.CentilitersPerLiter, CentilitersPerLiterTolerance); - AssertEx.EqualTolerance(CentilitersPerMililiterInOneDecimalFraction, decimalfraction.CentilitersPerMililiter, CentilitersPerMililiterTolerance); + AssertEx.EqualTolerance(CentilitersPerMilliliterInOneDecimalFraction, decimalfraction.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.DecilitersPerLiter, DecilitersPerLiterTolerance); - AssertEx.EqualTolerance(DecilitersPerMililiterInOneDecimalFraction, decimalfraction.DecilitersPerMililiter, DecilitersPerMililiterTolerance); + AssertEx.EqualTolerance(DecilitersPerMilliliterInOneDecimalFraction, decimalfraction.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.DecimalFractions, DecimalFractionsTolerance); AssertEx.EqualTolerance(LitersPerLiterInOneDecimalFraction, decimalfraction.LitersPerLiter, LitersPerLiterTolerance); - AssertEx.EqualTolerance(LitersPerMililiterInOneDecimalFraction, decimalfraction.LitersPerMililiter, LitersPerMililiterTolerance); + AssertEx.EqualTolerance(LitersPerMilliliterInOneDecimalFraction, decimalfraction.LitersPerMilliliter, LitersPerMilliliterTolerance); AssertEx.EqualTolerance(MicrolitersPerLiterInOneDecimalFraction, decimalfraction.MicrolitersPerLiter, MicrolitersPerLiterTolerance); - AssertEx.EqualTolerance(MicrolitersPerMililiterInOneDecimalFraction, decimalfraction.MicrolitersPerMililiter, MicrolitersPerMililiterTolerance); + AssertEx.EqualTolerance(MicrolitersPerMilliliterInOneDecimalFraction, decimalfraction.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); AssertEx.EqualTolerance(MillilitersPerLiterInOneDecimalFraction, decimalfraction.MillilitersPerLiter, MillilitersPerLiterTolerance); - AssertEx.EqualTolerance(MillilitersPerMililiterInOneDecimalFraction, decimalfraction.MillilitersPerMililiter, MillilitersPerMililiterTolerance); + AssertEx.EqualTolerance(MillilitersPerMilliliterInOneDecimalFraction, decimalfraction.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); AssertEx.EqualTolerance(NanolitersPerLiterInOneDecimalFraction, decimalfraction.NanolitersPerLiter, NanolitersPerLiterTolerance); - AssertEx.EqualTolerance(NanolitersPerMililiterInOneDecimalFraction, decimalfraction.NanolitersPerMililiter, NanolitersPerMililiterTolerance); + AssertEx.EqualTolerance(NanolitersPerMilliliterInOneDecimalFraction, decimalfraction.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.PartsPerBillion, PartsPerBillionTolerance); AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.PartsPerMillion, PartsPerMillionTolerance); AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.PartsPerThousand, PartsPerThousandTolerance); AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.PartsPerTrillion, PartsPerTrillionTolerance); AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.Percent, PercentTolerance); AssertEx.EqualTolerance(PicolitersPerLiterInOneDecimalFraction, decimalfraction.PicolitersPerLiter, PicolitersPerLiterTolerance); - AssertEx.EqualTolerance(PicolitersPerMililiterInOneDecimalFraction, decimalfraction.PicolitersPerMililiter, PicolitersPerMililiterTolerance); + AssertEx.EqualTolerance(PicolitersPerMilliliterInOneDecimalFraction, decimalfraction.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); } [Fact] @@ -208,17 +208,17 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity00.CentilitersPerLiter, CentilitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.CentilitersPerLiter, quantity00.Unit); - var quantity01 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerMililiter); - AssertEx.EqualTolerance(1, quantity01.CentilitersPerMililiter, CentilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMililiter, quantity01.Unit); + var quantity01 = VolumeConcentration.From(1, VolumeConcentrationUnit.CentilitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity01.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, quantity01.Unit); var quantity02 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerLiter); AssertEx.EqualTolerance(1, quantity02.DecilitersPerLiter, DecilitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.DecilitersPerLiter, quantity02.Unit); - var quantity03 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerMililiter); - AssertEx.EqualTolerance(1, quantity03.DecilitersPerMililiter, DecilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMililiter, quantity03.Unit); + var quantity03 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecilitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity03.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, quantity03.Unit); var quantity04 = VolumeConcentration.From(1, VolumeConcentrationUnit.DecimalFraction); AssertEx.EqualTolerance(1, quantity04.DecimalFractions, DecimalFractionsTolerance); @@ -228,33 +228,33 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity05.LitersPerLiter, LitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.LitersPerLiter, quantity05.Unit); - var quantity06 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerMililiter); - AssertEx.EqualTolerance(1, quantity06.LitersPerMililiter, LitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMililiter, quantity06.Unit); + var quantity06 = VolumeConcentration.From(1, VolumeConcentrationUnit.LitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity06.LitersPerMilliliter, LitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, quantity06.Unit); var quantity07 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerLiter); AssertEx.EqualTolerance(1, quantity07.MicrolitersPerLiter, MicrolitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.MicrolitersPerLiter, quantity07.Unit); - var quantity08 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerMililiter); - AssertEx.EqualTolerance(1, quantity08.MicrolitersPerMililiter, MicrolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMililiter, quantity08.Unit); + var quantity08 = VolumeConcentration.From(1, VolumeConcentrationUnit.MicrolitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity08.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, quantity08.Unit); var quantity09 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerLiter); AssertEx.EqualTolerance(1, quantity09.MillilitersPerLiter, MillilitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.MillilitersPerLiter, quantity09.Unit); - var quantity10 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerMililiter); - AssertEx.EqualTolerance(1, quantity10.MillilitersPerMililiter, MillilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMililiter, quantity10.Unit); + var quantity10 = VolumeConcentration.From(1, VolumeConcentrationUnit.MillilitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity10.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, quantity10.Unit); var quantity11 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerLiter); AssertEx.EqualTolerance(1, quantity11.NanolitersPerLiter, NanolitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.NanolitersPerLiter, quantity11.Unit); - var quantity12 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerMililiter); - AssertEx.EqualTolerance(1, quantity12.NanolitersPerMililiter, NanolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMililiter, quantity12.Unit); + var quantity12 = VolumeConcentration.From(1, VolumeConcentrationUnit.NanolitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity12.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, quantity12.Unit); var quantity13 = VolumeConcentration.From(1, VolumeConcentrationUnit.PartPerBillion); AssertEx.EqualTolerance(1, quantity13.PartsPerBillion, PartsPerBillionTolerance); @@ -280,9 +280,9 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity18.PicolitersPerLiter, PicolitersPerLiterTolerance); Assert.Equal(VolumeConcentrationUnit.PicolitersPerLiter, quantity18.Unit); - var quantity19 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerMililiter); - AssertEx.EqualTolerance(1, quantity19.PicolitersPerMililiter, PicolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMililiter, quantity19.Unit); + var quantity19 = VolumeConcentration.From(1, VolumeConcentrationUnit.PicolitersPerMilliliter); + AssertEx.EqualTolerance(1, quantity19.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, quantity19.Unit); } @@ -309,25 +309,25 @@ public void As() { var decimalfraction = VolumeConcentration.FromDecimalFractions(1); AssertEx.EqualTolerance(CentilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerLiter), CentilitersPerLiterTolerance); - AssertEx.EqualTolerance(CentilitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerMililiter), CentilitersPerMililiterTolerance); + AssertEx.EqualTolerance(CentilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.CentilitersPerMilliliter), CentilitersPerMilliliterTolerance); AssertEx.EqualTolerance(DecilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerLiter), DecilitersPerLiterTolerance); - AssertEx.EqualTolerance(DecilitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerMililiter), DecilitersPerMililiterTolerance); + AssertEx.EqualTolerance(DecilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecilitersPerMilliliter), DecilitersPerMilliliterTolerance); AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.DecimalFraction), DecimalFractionsTolerance); AssertEx.EqualTolerance(LitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LitersPerLiter), LitersPerLiterTolerance); - AssertEx.EqualTolerance(LitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LitersPerMililiter), LitersPerMililiterTolerance); + AssertEx.EqualTolerance(LitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.LitersPerMilliliter), LitersPerMilliliterTolerance); AssertEx.EqualTolerance(MicrolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicrolitersPerLiter), MicrolitersPerLiterTolerance); - AssertEx.EqualTolerance(MicrolitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicrolitersPerMililiter), MicrolitersPerMililiterTolerance); + AssertEx.EqualTolerance(MicrolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MicrolitersPerMilliliter), MicrolitersPerMilliliterTolerance); AssertEx.EqualTolerance(MillilitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MillilitersPerLiter), MillilitersPerLiterTolerance); - AssertEx.EqualTolerance(MillilitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MillilitersPerMililiter), MillilitersPerMililiterTolerance); + AssertEx.EqualTolerance(MillilitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.MillilitersPerMilliliter), MillilitersPerMilliliterTolerance); AssertEx.EqualTolerance(NanolitersPerLiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanolitersPerLiter), NanolitersPerLiterTolerance); - AssertEx.EqualTolerance(NanolitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanolitersPerMililiter), NanolitersPerMililiterTolerance); + AssertEx.EqualTolerance(NanolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.NanolitersPerMilliliter), 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(PicolitersPerMililiterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicolitersPerMililiter), PicolitersPerMililiterTolerance); + AssertEx.EqualTolerance(PicolitersPerMilliliterInOneDecimalFraction, decimalfraction.As(VolumeConcentrationUnit.PicolitersPerMilliliter), PicolitersPerMilliliterTolerance); } [Fact] @@ -410,8 +410,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 cl/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.CentilitersPerMililiter, CentilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -424,8 +424,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 dl/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.DecilitersPerMililiter, DecilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -445,8 +445,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 l/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.LitersPerMililiter, LitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.LitersPerMilliliter, LitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -459,8 +459,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 µl/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrolitersPerMililiter, MicrolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -473,8 +473,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 ml/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillilitersPerMililiter, MillilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -487,8 +487,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 nl/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.NanolitersPerMililiter, NanolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try @@ -543,8 +543,8 @@ public void Parse() try { var parsed = VolumeConcentration.Parse("1 pl/ml", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.PicolitersPerMililiter, PicolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } } @@ -560,8 +560,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 cl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.CentilitersPerMililiter, CentilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.CentilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.CentilitersPerMilliliter, CentilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.CentilitersPerMilliliter, parsed.Unit); } { @@ -572,8 +572,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 dl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.DecilitersPerMililiter, DecilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.DecilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.DecilitersPerMilliliter, DecilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.DecilitersPerMilliliter, parsed.Unit); } { @@ -590,8 +590,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 l/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.LitersPerMililiter, LitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.LitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.LitersPerMilliliter, LitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.LitersPerMilliliter, parsed.Unit); } { @@ -602,8 +602,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 µl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrolitersPerMililiter, MicrolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.MicrolitersPerMilliliter, MicrolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MicrolitersPerMilliliter, parsed.Unit); } { @@ -614,8 +614,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 ml/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MillilitersPerMililiter, MillilitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.MillilitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.MillilitersPerMilliliter, MillilitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.MillilitersPerMilliliter, parsed.Unit); } { @@ -626,8 +626,8 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 nl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.NanolitersPerMililiter, NanolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.NanolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.NanolitersPerMilliliter, NanolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.NanolitersPerMilliliter, parsed.Unit); } { @@ -674,26 +674,26 @@ public void TryParse() { Assert.True(VolumeConcentration.TryParse("1 pl/ml", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.PicolitersPerMililiter, PicolitersPerMililiterTolerance); - Assert.Equal(VolumeConcentrationUnit.PicolitersPerMililiter, parsed.Unit); + AssertEx.EqualTolerance(1, parsed.PicolitersPerMilliliter, PicolitersPerMilliliterTolerance); + Assert.Equal(VolumeConcentrationUnit.PicolitersPerMilliliter, parsed.Unit); } } [Theory] [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] @@ -701,7 +701,7 @@ public void TryParse() [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMililiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -712,18 +712,18 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeCon [Theory] [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] @@ -731,7 +731,7 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeCon [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMililiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] 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. @@ -742,18 +742,18 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [Theory] [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] @@ -761,7 +761,7 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [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.PicolitersPerMililiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -771,18 +771,18 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo [Theory] [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] @@ -790,7 +790,7 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Vo [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.PicolitersPerMililiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { VolumeConcentrationUnit parsedUnit = VolumeConcentration.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)); @@ -799,18 +799,18 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeCon [Theory] [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] @@ -818,7 +818,7 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, VolumeCon [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMililiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, VolumeConcentrationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -829,18 +829,18 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume [Theory] [InlineData("cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("", VolumeConcentrationUnit.DecimalFraction)] [InlineData("l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("‰", VolumeConcentrationUnit.PartPerThousand)] @@ -848,7 +848,7 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Volume [InlineData("%", VolumeConcentrationUnit.Percent)] [InlineData("% (v/v)", VolumeConcentrationUnit.Percent)] [InlineData("pl/l", VolumeConcentrationUnit.PicolitersPerLiter)] - [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMililiter)] + [InlineData("pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] 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. @@ -859,18 +859,18 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [Theory] [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] @@ -878,7 +878,7 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [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.PicolitersPerMililiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -888,18 +888,18 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [Theory] [InlineData("en-US", "cl/l", VolumeConcentrationUnit.CentilitersPerLiter)] - [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMililiter)] + [InlineData("en-US", "cl/ml", VolumeConcentrationUnit.CentilitersPerMilliliter)] [InlineData("en-US", "dl/l", VolumeConcentrationUnit.DecilitersPerLiter)] - [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMililiter)] + [InlineData("en-US", "dl/ml", VolumeConcentrationUnit.DecilitersPerMilliliter)] [InlineData("en-US", "", VolumeConcentrationUnit.DecimalFraction)] [InlineData("en-US", "l/l", VolumeConcentrationUnit.LitersPerLiter)] - [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMililiter)] + [InlineData("en-US", "l/ml", VolumeConcentrationUnit.LitersPerMilliliter)] [InlineData("en-US", "µl/l", VolumeConcentrationUnit.MicrolitersPerLiter)] - [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMililiter)] + [InlineData("en-US", "µl/ml", VolumeConcentrationUnit.MicrolitersPerMilliliter)] [InlineData("en-US", "ml/l", VolumeConcentrationUnit.MillilitersPerLiter)] - [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMililiter)] + [InlineData("en-US", "ml/ml", VolumeConcentrationUnit.MillilitersPerMilliliter)] [InlineData("en-US", "nl/l", VolumeConcentrationUnit.NanolitersPerLiter)] - [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMililiter)] + [InlineData("en-US", "nl/ml", VolumeConcentrationUnit.NanolitersPerMilliliter)] [InlineData("en-US", "ppb", VolumeConcentrationUnit.PartPerBillion)] [InlineData("en-US", "ppm", VolumeConcentrationUnit.PartPerMillion)] [InlineData("en-US", "‰", VolumeConcentrationUnit.PartPerThousand)] @@ -907,7 +907,7 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [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.PicolitersPerMililiter)] + [InlineData("en-US", "pl/ml", VolumeConcentrationUnit.PicolitersPerMilliliter)] public void TryParseUnit_WithCulture(string culture, string abbreviation, VolumeConcentrationUnit expectedUnit) { Assert.True(VolumeConcentration.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out VolumeConcentrationUnit parsedUnit)); @@ -980,25 +980,25 @@ public void ConversionRoundTrip() { VolumeConcentration decimalfraction = VolumeConcentration.FromDecimalFractions(1); AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerLiter(decimalfraction.CentilitersPerLiter).DecimalFractions, CentilitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerMililiter(decimalfraction.CentilitersPerMililiter).DecimalFractions, CentilitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromCentilitersPerMilliliter(decimalfraction.CentilitersPerMilliliter).DecimalFractions, CentilitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerLiter(decimalfraction.DecilitersPerLiter).DecimalFractions, DecilitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerMililiter(decimalfraction.DecilitersPerMililiter).DecimalFractions, DecilitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromDecilitersPerMilliliter(decimalfraction.DecilitersPerMilliliter).DecimalFractions, DecilitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerLiter(decimalfraction.LitersPerLiter).DecimalFractions, LitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerMililiter(decimalfraction.LitersPerMililiter).DecimalFractions, LitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromLitersPerMilliliter(decimalfraction.LitersPerMilliliter).DecimalFractions, LitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerLiter(decimalfraction.MicrolitersPerLiter).DecimalFractions, MicrolitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerMililiter(decimalfraction.MicrolitersPerMililiter).DecimalFractions, MicrolitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromMicrolitersPerMilliliter(decimalfraction.MicrolitersPerMilliliter).DecimalFractions, MicrolitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerLiter(decimalfraction.MillilitersPerLiter).DecimalFractions, MillilitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerMililiter(decimalfraction.MillilitersPerMililiter).DecimalFractions, MillilitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromMillilitersPerMilliliter(decimalfraction.MillilitersPerMilliliter).DecimalFractions, MillilitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerLiter(decimalfraction.NanolitersPerLiter).DecimalFractions, NanolitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerMililiter(decimalfraction.NanolitersPerMililiter).DecimalFractions, NanolitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromNanolitersPerMilliliter(decimalfraction.NanolitersPerMilliliter).DecimalFractions, NanolitersPerMilliliterTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance); AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerLiter(decimalfraction.PicolitersPerLiter).DecimalFractions, PicolitersPerLiterTolerance); - AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerMililiter(decimalfraction.PicolitersPerMililiter).DecimalFractions, PicolitersPerMililiterTolerance); + AssertEx.EqualTolerance(1, VolumeConcentration.FromPicolitersPerMilliliter(decimalfraction.PicolitersPerMilliliter).DecimalFractions, PicolitersPerMilliliterTolerance); } [Fact] @@ -1147,25 +1147,25 @@ 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.CentilitersPerMililiter).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.DecilitersPerMililiter).ToString()); + Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerMilliliter).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.LitersPerMililiter).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.MicrolitersPerMililiter).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.MillilitersPerMililiter).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.NanolitersPerMililiter).ToString()); + Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerMilliliter).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.PicolitersPerMililiter).ToString()); + Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerMilliliter).ToString()); } [Fact] @@ -1175,25 +1175,25 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture 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.CentilitersPerMililiter).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.DecilitersPerMililiter).ToString(swedishCulture)); + Assert.Equal("1 dl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.DecilitersPerMilliliter).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.LitersPerMililiter).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.MicrolitersPerMililiter).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.MillilitersPerMililiter).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.NanolitersPerMililiter).ToString(swedishCulture)); + Assert.Equal("1 nl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.NanolitersPerMilliliter).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.PicolitersPerMililiter).ToString(swedishCulture)); + Assert.Equal("1 pl/ml", new VolumeConcentration(1, VolumeConcentrationUnit.PicolitersPerMilliliter).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs index 429116b6c8..90a6161a5b 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -81,25 +81,25 @@ static VolumeConcentration() new UnitInfo[] { new UnitInfo(VolumeConcentrationUnit.CentilitersPerLiter, "CentilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.CentilitersPerMililiter, "CentilitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.CentilitersPerMilliliter, "CentilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.DecilitersPerLiter, "DecilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.DecilitersPerMililiter, "DecilitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.DecilitersPerMilliliter, "DecilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.DecimalFraction, "DecimalFractions", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.LitersPerLiter, "LitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.LitersPerMililiter, "LitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.LitersPerMilliliter, "LitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.MicrolitersPerLiter, "MicrolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MicrolitersPerMililiter, "MicrolitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MicrolitersPerMilliliter, "MicrolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.MillilitersPerLiter, "MillilitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.MillilitersPerMililiter, "MillilitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.MillilitersPerMilliliter, "MillilitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), new UnitInfo(VolumeConcentrationUnit.NanolitersPerLiter, "NanolitersPerLiter", BaseUnits.Undefined, "VolumeConcentration"), - new UnitInfo(VolumeConcentrationUnit.NanolitersPerMililiter, "NanolitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.NanolitersPerMilliliter, "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.PicolitersPerMililiter, "PicolitersPerMililiter", BaseUnits.Undefined, "VolumeConcentration"), + new UnitInfo(VolumeConcentrationUnit.PicolitersPerMilliliter, "PicolitersPerMilliliter", BaseUnits.Undefined, "VolumeConcentration"), }, BaseUnit, Zero, BaseDimensions); @@ -189,9 +189,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double CentilitersPerLiter => As(VolumeConcentrationUnit.CentilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double CentilitersPerMililiter => As(VolumeConcentrationUnit.CentilitersPerMililiter); + public double CentilitersPerMilliliter => As(VolumeConcentrationUnit.CentilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -199,9 +199,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double DecilitersPerLiter => As(VolumeConcentrationUnit.DecilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double DecilitersPerMililiter => As(VolumeConcentrationUnit.DecilitersPerMililiter); + public double DecilitersPerMilliliter => As(VolumeConcentrationUnit.DecilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -214,9 +214,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double LitersPerLiter => As(VolumeConcentrationUnit.LitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double LitersPerMililiter => As(VolumeConcentrationUnit.LitersPerMililiter); + public double LitersPerMilliliter => As(VolumeConcentrationUnit.LitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -224,9 +224,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double MicrolitersPerLiter => As(VolumeConcentrationUnit.MicrolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MicrolitersPerMililiter => As(VolumeConcentrationUnit.MicrolitersPerMililiter); + public double MicrolitersPerMilliliter => As(VolumeConcentrationUnit.MicrolitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -234,9 +234,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double MillilitersPerLiter => As(VolumeConcentrationUnit.MillilitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double MillilitersPerMililiter => As(VolumeConcentrationUnit.MillilitersPerMililiter); + public double MillilitersPerMilliliter => As(VolumeConcentrationUnit.MillilitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -244,9 +244,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double NanolitersPerLiter => As(VolumeConcentrationUnit.NanolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double NanolitersPerMililiter => As(VolumeConcentrationUnit.NanolitersPerMililiter); + public double NanolitersPerMilliliter => As(VolumeConcentrationUnit.NanolitersPerMilliliter); /// /// Gets a value of this quantity converted into @@ -279,9 +279,9 @@ public VolumeConcentration(double value, VolumeConcentrationUnit unit) public double PicolitersPerLiter => As(VolumeConcentrationUnit.PicolitersPerLiter); /// - /// Gets a value of this quantity converted into + /// Gets a value of this quantity converted into /// - public double PicolitersPerMililiter => As(VolumeConcentrationUnit.PicolitersPerMililiter); + public double PicolitersPerMilliliter => As(VolumeConcentrationUnit.PicolitersPerMilliliter); #endregion @@ -295,48 +295,48 @@ 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.CentilitersPerMililiter, 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.DecilitersPerMililiter, 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.LitersPerMililiter, 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.MicrolitersPerMililiter, 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.MillilitersPerMililiter, 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.NanolitersPerMililiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.NanolitersPerMilliliter, 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.PicolitersPerMililiter, VolumeConcentrationUnit.DecimalFraction, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecimalFraction)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.PicolitersPerMilliliter, 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.CentilitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.CentilitersPerMililiter)); + 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.DecilitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.DecilitersPerMililiter)); + 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.LitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.LitersPerMililiter)); + 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.MicrolitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MicrolitersPerMililiter)); + 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.MillilitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.MillilitersPerMililiter)); + 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.NanolitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanolitersPerMililiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.NanolitersPerMilliliter)); 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.PicolitersPerMililiter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicolitersPerMililiter)); + unitConverter.SetConversionFunction(VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerMilliliter, quantity => quantity.ToUnit(VolumeConcentrationUnit.PicolitersPerMilliliter)); } /// @@ -373,11 +373,11 @@ public static VolumeConcentration FromCentilitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromCentilitersPerMililiter(double value) + public static VolumeConcentration FromCentilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMilliliter); } /// @@ -389,11 +389,11 @@ public static VolumeConcentration FromDecilitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromDecilitersPerMililiter(double value) + public static VolumeConcentration FromDecilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMilliliter); } /// @@ -413,11 +413,11 @@ public static VolumeConcentration FromLitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromLitersPerMililiter(double value) + public static VolumeConcentration FromLitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMilliliter); } /// @@ -429,11 +429,11 @@ public static VolumeConcentration FromMicrolitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMicrolitersPerMililiter(double value) + public static VolumeConcentration FromMicrolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMilliliter); } /// @@ -445,11 +445,11 @@ public static VolumeConcentration FromMillilitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromMillilitersPerMililiter(double value) + public static VolumeConcentration FromMillilitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMilliliter); } /// @@ -461,11 +461,11 @@ public static VolumeConcentration FromNanolitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromNanolitersPerMililiter(double value) + public static VolumeConcentration FromNanolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMilliliter); } /// @@ -517,11 +517,11 @@ public static VolumeConcentration FromPicolitersPerLiter(double value) } /// - /// Creates a from . + /// Creates a from . /// - public static VolumeConcentration FromPicolitersPerMililiter(double value) + public static VolumeConcentration FromPicolitersPerMilliliter(double value) { - return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter); + return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMilliliter); } /// @@ -1007,45 +1007,45 @@ private bool TryToUnit(VolumeConcentrationUnit unit, [NotNullWhen(true)] out Vol { // VolumeConcentrationUnit -> BaseUnit (VolumeConcentrationUnit.CentilitersPerLiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value) * 1e-2d, VolumeConcentrationUnit.DecimalFraction), - (VolumeConcentrationUnit.CentilitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 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.DecilitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 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.LitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration(_value / 1e-3, 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.MicrolitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 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.MillilitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 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.NanolitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-9d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.NanolitersPerMilliliter, 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.PicolitersPerMililiter, VolumeConcentrationUnit.DecimalFraction) => new VolumeConcentration((_value / 1e-3) * 1e-12d, VolumeConcentrationUnit.DecimalFraction), + (VolumeConcentrationUnit.PicolitersPerMilliliter, 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.CentilitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-2d, VolumeConcentrationUnit.CentilitersPerMililiter), + (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.DecilitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-1d, VolumeConcentrationUnit.DecilitersPerMililiter), + (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.LitersPerMililiter) => new VolumeConcentration(_value * 1e-3, VolumeConcentrationUnit.LitersPerMililiter), + (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.MicrolitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-6d, VolumeConcentrationUnit.MicrolitersPerMililiter), + (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.MillilitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-3d, VolumeConcentrationUnit.MillilitersPerMililiter), + (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.NanolitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-9d, VolumeConcentrationUnit.NanolitersPerMililiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.NanolitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-9d, VolumeConcentrationUnit.NanolitersPerMilliliter), (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.PicolitersPerMililiter) => new VolumeConcentration((_value * 1e-3) / 1e-12d, VolumeConcentrationUnit.PicolitersPerMililiter), + (VolumeConcentrationUnit.DecimalFraction, VolumeConcentrationUnit.PicolitersPerMilliliter) => new VolumeConcentration((_value * 1e-3) / 1e-12d, VolumeConcentrationUnit.PicolitersPerMilliliter), _ => null }; diff --git a/UnitsNet/GeneratedCode/Resources/VolumeConcentration.restext b/UnitsNet/GeneratedCode/Resources/VolumeConcentration.restext index fe80fbd983..ed4f32e530 100644 --- a/UnitsNet/GeneratedCode/Resources/VolumeConcentration.restext +++ b/UnitsNet/GeneratedCode/Resources/VolumeConcentration.restext @@ -1,20 +1,20 @@ CentilitersPerLiter=cl/l -CentilitersPerMililiter=cl/ml +CentilitersPerMilliliter=cl/ml DecilitersPerLiter=dl/l -DecilitersPerMililiter=dl/ml +DecilitersPerMilliliter=dl/ml DecimalFractions= LitersPerLiter=l/l -LitersPerMililiter=l/ml +LitersPerMilliliter=l/ml MicrolitersPerLiter=µl/l -MicrolitersPerMililiter=µl/ml +MicrolitersPerMilliliter=µl/ml MillilitersPerLiter=ml/l -MillilitersPerMililiter=ml/ml +MillilitersPerMilliliter=ml/ml NanolitersPerLiter=nl/l -NanolitersPerMililiter=nl/ml +NanolitersPerMilliliter=nl/ml PartsPerBillion=ppb PartsPerMillion=ppm PartsPerThousand=‰ PartsPerTrillion=ppt Percent=%,% (v/v) PicolitersPerLiter=pl/l -PicolitersPerMililiter=pl/ml +PicolitersPerMilliliter=pl/ml diff --git a/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs index b60c944f4a..283715f8af 100644 --- a/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/VolumeConcentrationUnit.g.cs @@ -26,25 +26,25 @@ namespace UnitsNet.Units public enum VolumeConcentrationUnit { CentilitersPerLiter = 1, - CentilitersPerMililiter = 2, + CentilitersPerMilliliter = 2, DecilitersPerLiter = 3, - DecilitersPerMililiter = 4, + DecilitersPerMilliliter = 4, DecimalFraction = 5, LitersPerLiter = 6, - LitersPerMililiter = 7, + LitersPerMilliliter = 7, MicrolitersPerLiter = 8, - MicrolitersPerMililiter = 9, + MicrolitersPerMilliliter = 9, MillilitersPerLiter = 10, - MillilitersPerMililiter = 11, + MillilitersPerMilliliter = 11, NanolitersPerLiter = 12, - NanolitersPerMililiter = 13, + NanolitersPerMilliliter = 13, PartPerBillion = 14, PartPerMillion = 15, PartPerThousand = 16, PartPerTrillion = 17, Percent = 18, PicolitersPerLiter = 19, - PicolitersPerMililiter = 20, + PicolitersPerMilliliter = 20, } #pragma warning restore 1591