From d980ec1eb56255eb01d9c042884380828a96db4b Mon Sep 17 00:00:00 2001 From: Andre Rodi <89607119+andrerodi@users.noreply.github.com> Date: Wed, 14 Feb 2024 07:35:01 +0100 Subject: [PATCH] Add VolumeFlow prefixes Deca, Hecto (#1362) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #1253 Added the prefixes 'deca' and 'hecto', since, at least for the 'hecto' prefix, it's a very common unit used in the brewing industry. Added the 'deca' prefix while I was at it. --------- Co-authored-by: André Rodi --- Common/UnitDefinitions/VolumeFlow.json | 8 +- Common/UnitEnumValues.g.json | 10 +- .../GeneratedCode/Quantities/VolumeFlow.g.cs | 104 ++ .../GeneratedCode/Units/VolumeFlowUnit.g.cs | 8 + .../NumberToVolumeFlowExtensionsTest.g.cs | 32 + .../NumberToVolumeFlowExtensions.g.cs | 64 ++ UnitsNet.Tests/CustomCode/VolumeFlowTests.cs | 16 + .../TestsBase/VolumeFlowTestsBase.g.cs | 950 +++++++++++++++--- .../GeneratedCode/Quantities/VolumeFlow.g.cs | 160 +++ .../Resources/VolumeFlow.restext | 8 + .../Resources/VolumeFlow.ru-RU.restext | 6 + .../GeneratedCode/Units/VolumeFlowUnit.g.cs | 8 + 12 files changed, 1234 insertions(+), 140 deletions(-) diff --git a/Common/UnitDefinitions/VolumeFlow.json b/Common/UnitDefinitions/VolumeFlow.json index 22e3229124..e824e590f4 100644 --- a/Common/UnitDefinitions/VolumeFlow.json +++ b/Common/UnitDefinitions/VolumeFlow.json @@ -181,7 +181,7 @@ "PluralName": "LitersPerSecond", "FromUnitToBaseFunc": "{x} / 1000", "FromBaseToUnitFunc": "{x} * 1000", - "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -198,7 +198,7 @@ "PluralName": "LitersPerMinute", "FromUnitToBaseFunc": "{x} / 60000.00000", "FromBaseToUnitFunc": "{x} * 60000.00000", - "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -215,7 +215,7 @@ "PluralName": "LitersPerHour", "FromUnitToBaseFunc": "{x} / 3600000.000", "FromBaseToUnitFunc": "{x} * 3600000.000", - "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", @@ -232,7 +232,7 @@ "PluralName": "LitersPerDay", "FromUnitToBaseFunc": "{x} / 86400000", "FromBaseToUnitFunc": "{x} * 86400000", - "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo", "Mega" ], "Localization": [ { "Culture": "en-US", diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index 4d909db5bb..33a2c2cc8c 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -1676,7 +1676,15 @@ "MegaliterPerMinute": 64, "MegaliterPerSecond": 65, "MegaukGallonPerDay": 73, - "MegausGallonPerDay": 77 + "MegausGallonPerDay": 77, + "DecaliterPerDay": 71, + "DecaliterPerHour": 78, + "DecaliterPerMinute": 67, + "DecaliterPerSecond": 70, + "HectoliterPerDay": 74, + "HectoliterPerHour": 72, + "HectoliterPerMinute": 75, + "HectoliterPerSecond": 69 }, "VolumeFlowPerArea": { "CubicFootPerMinutePerSquareFoot": 1, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs index daffaf77a2..2a717a8799 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -189,6 +189,26 @@ public VolumeFlow(double value, VolumeFlowUnit unit) /// public double CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerDay => As(VolumeFlowUnit.DecaliterPerDay); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerHour => As(VolumeFlowUnit.DecaliterPerHour); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerMinute => As(VolumeFlowUnit.DecaliterPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerSecond => As(VolumeFlowUnit.DecaliterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -209,6 +229,26 @@ public VolumeFlow(double value, VolumeFlowUnit unit) /// public double DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerDay => As(VolumeFlowUnit.HectoliterPerDay); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerHour => As(VolumeFlowUnit.HectoliterPerHour); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerMinute => As(VolumeFlowUnit.HectoliterPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerSecond => As(VolumeFlowUnit.HectoliterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -550,6 +590,30 @@ public VolumeFlow(double value, VolumeFlowUnit unit) /// If value is NaN or Infinity. public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond) => new VolumeFlow(cubicyardspersecond, VolumeFlowUnit.CubicYardPerSecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerDay(double decalitersperday) => new VolumeFlow(decalitersperday, VolumeFlowUnit.DecaliterPerDay); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerHour(double decalitersperhour) => new VolumeFlow(decalitersperhour, VolumeFlowUnit.DecaliterPerHour); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerMinute(double decalitersperminute) => new VolumeFlow(decalitersperminute, VolumeFlowUnit.DecaliterPerMinute); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerSecond(double decaliterspersecond) => new VolumeFlow(decaliterspersecond, VolumeFlowUnit.DecaliterPerSecond); + /// /// Creates a from . /// @@ -574,6 +638,30 @@ public VolumeFlow(double value, VolumeFlowUnit unit) /// If value is NaN or Infinity. public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond) => new VolumeFlow(deciliterspersecond, VolumeFlowUnit.DeciliterPerSecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerDay(double hectolitersperday) => new VolumeFlow(hectolitersperday, VolumeFlowUnit.HectoliterPerDay); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerHour(double hectolitersperhour) => new VolumeFlow(hectolitersperhour, VolumeFlowUnit.HectoliterPerHour); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerMinute(double hectolitersperminute) => new VolumeFlow(hectolitersperminute, VolumeFlowUnit.HectoliterPerMinute); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerSecond(double hectoliterspersecond) => new VolumeFlow(hectoliterspersecond, VolumeFlowUnit.HectoliterPerSecond); + /// /// Creates a from . /// @@ -882,10 +970,18 @@ private double GetValueInBaseUnit() VolumeFlowUnit.CubicYardPerHour => _value * 2.1237634944E-4, VolumeFlowUnit.CubicYardPerMinute => _value * 0.0127425809664, VolumeFlowUnit.CubicYardPerSecond => _value * 0.764554857984, + VolumeFlowUnit.DecaliterPerDay => (_value / 86400000) * 1e1d, + VolumeFlowUnit.DecaliterPerHour => (_value / 3600000.000) * 1e1d, + VolumeFlowUnit.DecaliterPerMinute => (_value / 60000.00000) * 1e1d, + VolumeFlowUnit.DecaliterPerSecond => (_value / 1000) * 1e1d, VolumeFlowUnit.DeciliterPerDay => (_value / 86400000) * 1e-1d, VolumeFlowUnit.DeciliterPerHour => (_value / 3600000.000) * 1e-1d, VolumeFlowUnit.DeciliterPerMinute => (_value / 60000.00000) * 1e-1d, VolumeFlowUnit.DeciliterPerSecond => (_value / 1000) * 1e-1d, + VolumeFlowUnit.HectoliterPerDay => (_value / 86400000) * 1e2d, + VolumeFlowUnit.HectoliterPerHour => (_value / 3600000.000) * 1e2d, + VolumeFlowUnit.HectoliterPerMinute => (_value / 60000.00000) * 1e2d, + VolumeFlowUnit.HectoliterPerSecond => (_value / 1000) * 1e2d, VolumeFlowUnit.KiloliterPerDay => (_value / 86400000) * 1e3d, VolumeFlowUnit.KiloliterPerHour => (_value / 3600000.000) * 1e3d, VolumeFlowUnit.KiloliterPerMinute => (_value / 60000.00000) * 1e3d, @@ -962,10 +1058,18 @@ private double GetValueAs(VolumeFlowUnit unit) VolumeFlowUnit.CubicYardPerHour => baseUnitValue / 2.1237634944E-4, VolumeFlowUnit.CubicYardPerMinute => baseUnitValue / 0.0127425809664, VolumeFlowUnit.CubicYardPerSecond => baseUnitValue / 0.764554857984, + VolumeFlowUnit.DecaliterPerDay => (baseUnitValue * 86400000) / 1e1d, + VolumeFlowUnit.DecaliterPerHour => (baseUnitValue * 3600000.000) / 1e1d, + VolumeFlowUnit.DecaliterPerMinute => (baseUnitValue * 60000.00000) / 1e1d, + VolumeFlowUnit.DecaliterPerSecond => (baseUnitValue * 1000) / 1e1d, VolumeFlowUnit.DeciliterPerDay => (baseUnitValue * 86400000) / 1e-1d, VolumeFlowUnit.DeciliterPerHour => (baseUnitValue * 3600000.000) / 1e-1d, VolumeFlowUnit.DeciliterPerMinute => (baseUnitValue * 60000.00000) / 1e-1d, VolumeFlowUnit.DeciliterPerSecond => (baseUnitValue * 1000) / 1e-1d, + VolumeFlowUnit.HectoliterPerDay => (baseUnitValue * 86400000) / 1e2d, + VolumeFlowUnit.HectoliterPerHour => (baseUnitValue * 3600000.000) / 1e2d, + VolumeFlowUnit.HectoliterPerMinute => (baseUnitValue * 60000.00000) / 1e2d, + VolumeFlowUnit.HectoliterPerSecond => (baseUnitValue * 1000) / 1e2d, VolumeFlowUnit.KiloliterPerDay => (baseUnitValue * 86400000) / 1e3d, VolumeFlowUnit.KiloliterPerHour => (baseUnitValue * 3600000.000) / 1e3d, VolumeFlowUnit.KiloliterPerMinute => (baseUnitValue * 60000.00000) / 1e3d, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs index ab8b2bca49..6c14bc7b98 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/VolumeFlowUnit.g.cs @@ -47,10 +47,18 @@ public enum VolumeFlowUnit CubicYardPerHour = 20, CubicYardPerMinute = 21, CubicYardPerSecond = 22, + DecaliterPerDay = 71, + DecaliterPerHour = 78, + DecaliterPerMinute = 67, + DecaliterPerSecond = 70, DeciliterPerDay = 23, DeciliterPerHour = 24, DeciliterPerMinute = 25, DeciliterPerSecond = 26, + HectoliterPerDay = 74, + HectoliterPerHour = 72, + HectoliterPerMinute = 75, + HectoliterPerSecond = 69, KiloliterPerDay = 27, KiloliterPerHour = 28, KiloliterPerMinute = 29, diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs index 13d1660359..028a366069 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs @@ -112,6 +112,22 @@ public void NumberToCubicYardsPerMinuteTest() => public void NumberToCubicYardsPerSecondTest() => Assert.Equal(VolumeFlow.FromCubicYardsPerSecond(2), 2.CubicYardsPerSecond()); + [Fact] + public void NumberToDecalitersPerDayTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerDay(2), 2.DecalitersPerDay()); + + [Fact] + public void NumberToDecalitersPerHourTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerHour(2), 2.DecalitersPerHour()); + + [Fact] + public void NumberToDecalitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerMinute(2), 2.DecalitersPerMinute()); + + [Fact] + public void NumberToDecalitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerSecond(2), 2.DecalitersPerSecond()); + [Fact] public void NumberToDecilitersPerDayTest() => Assert.Equal(VolumeFlow.FromDecilitersPerDay(2), 2.DecilitersPerDay()); @@ -128,6 +144,22 @@ public void NumberToDecilitersPerMinuteTest() => public void NumberToDecilitersPerSecondTest() => Assert.Equal(VolumeFlow.FromDecilitersPerSecond(2), 2.DecilitersPerSecond()); + [Fact] + public void NumberToHectolitersPerDayTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerDay(2), 2.HectolitersPerDay()); + + [Fact] + public void NumberToHectolitersPerHourTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerHour(2), 2.HectolitersPerHour()); + + [Fact] + public void NumberToHectolitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerMinute(2), 2.HectolitersPerMinute()); + + [Fact] + public void NumberToHectolitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerSecond(2), 2.HectolitersPerSecond()); + [Fact] public void NumberToKilolitersPerDayTest() => Assert.Equal(VolumeFlow.FromKilolitersPerDay(2), 2.KilolitersPerDay()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs index 4542ca2890..1c2e7282e6 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs @@ -208,6 +208,38 @@ public static VolumeFlow CubicYardsPerSecond(this T value) #endif => VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value)); + /// + public static VolumeFlow DecalitersPerDay(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromDecalitersPerDay(Convert.ToDouble(value)); + + /// + public static VolumeFlow DecalitersPerHour(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromDecalitersPerHour(Convert.ToDouble(value)); + + /// + public static VolumeFlow DecalitersPerMinute(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromDecalitersPerMinute(Convert.ToDouble(value)); + + /// + public static VolumeFlow DecalitersPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromDecalitersPerSecond(Convert.ToDouble(value)); + /// public static VolumeFlow DecilitersPerDay(this T value) where T : notnull @@ -240,6 +272,38 @@ public static VolumeFlow DecilitersPerSecond(this T value) #endif => VolumeFlow.FromDecilitersPerSecond(Convert.ToDouble(value)); + /// + public static VolumeFlow HectolitersPerDay(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromHectolitersPerDay(Convert.ToDouble(value)); + + /// + public static VolumeFlow HectolitersPerHour(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromHectolitersPerHour(Convert.ToDouble(value)); + + /// + public static VolumeFlow HectolitersPerMinute(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromHectolitersPerMinute(Convert.ToDouble(value)); + + /// + public static VolumeFlow HectolitersPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#endif + => VolumeFlow.FromHectolitersPerSecond(Convert.ToDouble(value)); + /// public static VolumeFlow KilolitersPerDay(this T value) where T : notnull diff --git a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs index e5914c43d5..4313473ce8 100644 --- a/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeFlowTests.cs @@ -165,6 +165,22 @@ public class VolumeFlowTests : VolumeFlowTestsBase protected override double UsGallonsPerSecondInOneCubicMeterPerSecond => 2.64172052358148E2; + protected override double DecalitersPerDayInOneCubicMeterPerSecond => 8.64E6; + + protected override double DecalitersPerHourInOneCubicMeterPerSecond => 360_000; + + protected override double DecalitersPerMinuteInOneCubicMeterPerSecond => 6_000; + + protected override double DecalitersPerSecondInOneCubicMeterPerSecond => 100; + + protected override double HectolitersPerDayInOneCubicMeterPerSecond => 864_000; + + protected override double HectolitersPerHourInOneCubicMeterPerSecond => 36_000; + + protected override double HectolitersPerMinuteInOneCubicMeterPerSecond => 600; + + protected override double HectolitersPerSecondInOneCubicMeterPerSecond => 10; + [Theory] [InlineData(20, 2, 40)] [InlineData(20, 62, 1240)] diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs index 04592a2148..7d1ecb2770 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/VolumeFlowTestsBase.g.cs @@ -60,10 +60,18 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase protected abstract double CubicYardsPerHourInOneCubicMeterPerSecond { get; } protected abstract double CubicYardsPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double CubicYardsPerSecondInOneCubicMeterPerSecond { get; } + protected abstract double DecalitersPerDayInOneCubicMeterPerSecond { get; } + protected abstract double DecalitersPerHourInOneCubicMeterPerSecond { get; } + protected abstract double DecalitersPerMinuteInOneCubicMeterPerSecond { get; } + protected abstract double DecalitersPerSecondInOneCubicMeterPerSecond { get; } protected abstract double DecilitersPerDayInOneCubicMeterPerSecond { get; } protected abstract double DecilitersPerHourInOneCubicMeterPerSecond { get; } protected abstract double DecilitersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double DecilitersPerSecondInOneCubicMeterPerSecond { get; } + protected abstract double HectolitersPerDayInOneCubicMeterPerSecond { get; } + protected abstract double HectolitersPerHourInOneCubicMeterPerSecond { get; } + protected abstract double HectolitersPerMinuteInOneCubicMeterPerSecond { get; } + protected abstract double HectolitersPerSecondInOneCubicMeterPerSecond { get; } protected abstract double KilolitersPerDayInOneCubicMeterPerSecond { get; } protected abstract double KilolitersPerHourInOneCubicMeterPerSecond { get; } protected abstract double KilolitersPerMinuteInOneCubicMeterPerSecond { get; } @@ -129,10 +137,18 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase protected virtual double CubicYardsPerHourTolerance { get { return 1e-5; } } protected virtual double CubicYardsPerMinuteTolerance { get { return 1e-5; } } protected virtual double CubicYardsPerSecondTolerance { get { return 1e-5; } } + protected virtual double DecalitersPerDayTolerance { get { return 1e-5; } } + protected virtual double DecalitersPerHourTolerance { get { return 1e-5; } } + protected virtual double DecalitersPerMinuteTolerance { get { return 1e-5; } } + protected virtual double DecalitersPerSecondTolerance { get { return 1e-5; } } protected virtual double DecilitersPerDayTolerance { get { return 1e-5; } } protected virtual double DecilitersPerHourTolerance { get { return 1e-5; } } protected virtual double DecilitersPerMinuteTolerance { get { return 1e-5; } } protected virtual double DecilitersPerSecondTolerance { get { return 1e-5; } } + protected virtual double HectolitersPerDayTolerance { get { return 1e-5; } } + protected virtual double HectolitersPerHourTolerance { get { return 1e-5; } } + protected virtual double HectolitersPerMinuteTolerance { get { return 1e-5; } } + protected virtual double HectolitersPerSecondTolerance { get { return 1e-5; } } protected virtual double KilolitersPerDayTolerance { get { return 1e-5; } } protected virtual double KilolitersPerHourTolerance { get { return 1e-5; } } protected virtual double KilolitersPerMinuteTolerance { get { return 1e-5; } } @@ -202,10 +218,18 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase VolumeFlowUnit.CubicYardPerHour => (CubicYardsPerHourInOneCubicMeterPerSecond, CubicYardsPerHourTolerance), VolumeFlowUnit.CubicYardPerMinute => (CubicYardsPerMinuteInOneCubicMeterPerSecond, CubicYardsPerMinuteTolerance), VolumeFlowUnit.CubicYardPerSecond => (CubicYardsPerSecondInOneCubicMeterPerSecond, CubicYardsPerSecondTolerance), + VolumeFlowUnit.DecaliterPerDay => (DecalitersPerDayInOneCubicMeterPerSecond, DecalitersPerDayTolerance), + VolumeFlowUnit.DecaliterPerHour => (DecalitersPerHourInOneCubicMeterPerSecond, DecalitersPerHourTolerance), + VolumeFlowUnit.DecaliterPerMinute => (DecalitersPerMinuteInOneCubicMeterPerSecond, DecalitersPerMinuteTolerance), + VolumeFlowUnit.DecaliterPerSecond => (DecalitersPerSecondInOneCubicMeterPerSecond, DecalitersPerSecondTolerance), VolumeFlowUnit.DeciliterPerDay => (DecilitersPerDayInOneCubicMeterPerSecond, DecilitersPerDayTolerance), VolumeFlowUnit.DeciliterPerHour => (DecilitersPerHourInOneCubicMeterPerSecond, DecilitersPerHourTolerance), VolumeFlowUnit.DeciliterPerMinute => (DecilitersPerMinuteInOneCubicMeterPerSecond, DecilitersPerMinuteTolerance), VolumeFlowUnit.DeciliterPerSecond => (DecilitersPerSecondInOneCubicMeterPerSecond, DecilitersPerSecondTolerance), + VolumeFlowUnit.HectoliterPerDay => (HectolitersPerDayInOneCubicMeterPerSecond, HectolitersPerDayTolerance), + VolumeFlowUnit.HectoliterPerHour => (HectolitersPerHourInOneCubicMeterPerSecond, HectolitersPerHourTolerance), + VolumeFlowUnit.HectoliterPerMinute => (HectolitersPerMinuteInOneCubicMeterPerSecond, HectolitersPerMinuteTolerance), + VolumeFlowUnit.HectoliterPerSecond => (HectolitersPerSecondInOneCubicMeterPerSecond, HectolitersPerSecondTolerance), VolumeFlowUnit.KiloliterPerDay => (KilolitersPerDayInOneCubicMeterPerSecond, KilolitersPerDayTolerance), VolumeFlowUnit.KiloliterPerHour => (KilolitersPerHourInOneCubicMeterPerSecond, KilolitersPerHourTolerance), VolumeFlowUnit.KiloliterPerMinute => (KilolitersPerMinuteInOneCubicMeterPerSecond, KilolitersPerMinuteTolerance), @@ -275,10 +299,18 @@ public abstract partial class VolumeFlowTestsBase : QuantityTestsBase new object[] { VolumeFlowUnit.CubicYardPerHour }, new object[] { VolumeFlowUnit.CubicYardPerMinute }, new object[] { VolumeFlowUnit.CubicYardPerSecond }, + new object[] { VolumeFlowUnit.DecaliterPerDay }, + new object[] { VolumeFlowUnit.DecaliterPerHour }, + new object[] { VolumeFlowUnit.DecaliterPerMinute }, + new object[] { VolumeFlowUnit.DecaliterPerSecond }, new object[] { VolumeFlowUnit.DeciliterPerDay }, new object[] { VolumeFlowUnit.DeciliterPerHour }, new object[] { VolumeFlowUnit.DeciliterPerMinute }, new object[] { VolumeFlowUnit.DeciliterPerSecond }, + new object[] { VolumeFlowUnit.HectoliterPerDay }, + new object[] { VolumeFlowUnit.HectoliterPerHour }, + new object[] { VolumeFlowUnit.HectoliterPerMinute }, + new object[] { VolumeFlowUnit.HectoliterPerSecond }, new object[] { VolumeFlowUnit.KiloliterPerDay }, new object[] { VolumeFlowUnit.KiloliterPerHour }, new object[] { VolumeFlowUnit.KiloliterPerMinute }, @@ -404,10 +436,18 @@ public void CubicMeterPerSecondToVolumeFlowUnits() AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerHour, CubicYardsPerHourTolerance); AssertEx.EqualTolerance(CubicYardsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerMinute, CubicYardsPerMinuteTolerance); AssertEx.EqualTolerance(CubicYardsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerSecond, CubicYardsPerSecondTolerance); + AssertEx.EqualTolerance(DecalitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.DecalitersPerDay, DecalitersPerDayTolerance); + AssertEx.EqualTolerance(DecalitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.DecalitersPerHour, DecalitersPerHourTolerance); + AssertEx.EqualTolerance(DecalitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.DecalitersPerMinute, DecalitersPerMinuteTolerance); + AssertEx.EqualTolerance(DecalitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.DecalitersPerSecond, DecalitersPerSecondTolerance); AssertEx.EqualTolerance(DecilitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.DecilitersPerDay, DecilitersPerDayTolerance); AssertEx.EqualTolerance(DecilitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.DecilitersPerHour, DecilitersPerHourTolerance); AssertEx.EqualTolerance(DecilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.DecilitersPerMinute, DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(DecilitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.DecilitersPerSecond, DecilitersPerSecondTolerance); + AssertEx.EqualTolerance(HectolitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.HectolitersPerDay, HectolitersPerDayTolerance); + AssertEx.EqualTolerance(HectolitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.HectolitersPerHour, HectolitersPerHourTolerance); + AssertEx.EqualTolerance(HectolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.HectolitersPerMinute, HectolitersPerMinuteTolerance); + AssertEx.EqualTolerance(HectolitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.HectolitersPerSecond, HectolitersPerSecondTolerance); AssertEx.EqualTolerance(KilolitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.KilolitersPerDay, KilolitersPerDayTolerance); AssertEx.EqualTolerance(KilolitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.KilolitersPerHour, KilolitersPerHourTolerance); AssertEx.EqualTolerance(KilolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.KilolitersPerMinute, KilolitersPerMinuteTolerance); @@ -542,185 +582,217 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity21.CubicYardsPerSecond, CubicYardsPerSecondTolerance); Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, quantity21.Unit); - var quantity22 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerDay); - AssertEx.EqualTolerance(1, quantity22.DecilitersPerDay, DecilitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.DeciliterPerDay, quantity22.Unit); + var quantity22 = VolumeFlow.From(1, VolumeFlowUnit.DecaliterPerDay); + AssertEx.EqualTolerance(1, quantity22.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, quantity22.Unit); - var quantity23 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerHour); - AssertEx.EqualTolerance(1, quantity23.DecilitersPerHour, DecilitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.DeciliterPerHour, quantity23.Unit); + var quantity23 = VolumeFlow.From(1, VolumeFlowUnit.DecaliterPerHour); + AssertEx.EqualTolerance(1, quantity23.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, quantity23.Unit); - var quantity24 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerMinute); - AssertEx.EqualTolerance(1, quantity24.DecilitersPerMinute, DecilitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.DeciliterPerMinute, quantity24.Unit); + var quantity24 = VolumeFlow.From(1, VolumeFlowUnit.DecaliterPerMinute); + AssertEx.EqualTolerance(1, quantity24.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, quantity24.Unit); - var quantity25 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerSecond); - AssertEx.EqualTolerance(1, quantity25.DecilitersPerSecond, DecilitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, quantity25.Unit); + var quantity25 = VolumeFlow.From(1, VolumeFlowUnit.DecaliterPerSecond); + AssertEx.EqualTolerance(1, quantity25.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, quantity25.Unit); - var quantity26 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerDay); - AssertEx.EqualTolerance(1, quantity26.KilolitersPerDay, KilolitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.KiloliterPerDay, quantity26.Unit); + var quantity26 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerDay); + AssertEx.EqualTolerance(1, quantity26.DecilitersPerDay, DecilitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DeciliterPerDay, quantity26.Unit); - var quantity27 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerHour); - AssertEx.EqualTolerance(1, quantity27.KilolitersPerHour, KilolitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.KiloliterPerHour, quantity27.Unit); + var quantity27 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerHour); + AssertEx.EqualTolerance(1, quantity27.DecilitersPerHour, DecilitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DeciliterPerHour, quantity27.Unit); - var quantity28 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerMinute); - AssertEx.EqualTolerance(1, quantity28.KilolitersPerMinute, KilolitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.KiloliterPerMinute, quantity28.Unit); + var quantity28 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerMinute); + AssertEx.EqualTolerance(1, quantity28.DecilitersPerMinute, DecilitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DeciliterPerMinute, quantity28.Unit); - var quantity29 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerSecond); - AssertEx.EqualTolerance(1, quantity29.KilolitersPerSecond, KilolitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.KiloliterPerSecond, quantity29.Unit); + var quantity29 = VolumeFlow.From(1, VolumeFlowUnit.DeciliterPerSecond); + AssertEx.EqualTolerance(1, quantity29.DecilitersPerSecond, DecilitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, quantity29.Unit); - var quantity30 = VolumeFlow.From(1, VolumeFlowUnit.KilousGallonPerMinute); - AssertEx.EqualTolerance(1, quantity30.KilousGallonsPerMinute, KilousGallonsPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.KilousGallonPerMinute, quantity30.Unit); + var quantity30 = VolumeFlow.From(1, VolumeFlowUnit.HectoliterPerDay); + AssertEx.EqualTolerance(1, quantity30.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, quantity30.Unit); - var quantity31 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerDay); - AssertEx.EqualTolerance(1, quantity31.LitersPerDay, LitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.LiterPerDay, quantity31.Unit); + var quantity31 = VolumeFlow.From(1, VolumeFlowUnit.HectoliterPerHour); + AssertEx.EqualTolerance(1, quantity31.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, quantity31.Unit); - var quantity32 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerHour); - AssertEx.EqualTolerance(1, quantity32.LitersPerHour, LitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.LiterPerHour, quantity32.Unit); + var quantity32 = VolumeFlow.From(1, VolumeFlowUnit.HectoliterPerMinute); + AssertEx.EqualTolerance(1, quantity32.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, quantity32.Unit); - var quantity33 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerMinute); - AssertEx.EqualTolerance(1, quantity33.LitersPerMinute, LitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.LiterPerMinute, quantity33.Unit); + var quantity33 = VolumeFlow.From(1, VolumeFlowUnit.HectoliterPerSecond); + AssertEx.EqualTolerance(1, quantity33.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, quantity33.Unit); - var quantity34 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerSecond); - AssertEx.EqualTolerance(1, quantity34.LitersPerSecond, LitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.LiterPerSecond, quantity34.Unit); + var quantity34 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerDay); + AssertEx.EqualTolerance(1, quantity34.KilolitersPerDay, KilolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.KiloliterPerDay, quantity34.Unit); - var quantity35 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerDay); - AssertEx.EqualTolerance(1, quantity35.MegalitersPerDay, MegalitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MegaliterPerDay, quantity35.Unit); + var quantity35 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerHour); + AssertEx.EqualTolerance(1, quantity35.KilolitersPerHour, KilolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.KiloliterPerHour, quantity35.Unit); - var quantity36 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerHour); - AssertEx.EqualTolerance(1, quantity36.MegalitersPerHour, MegalitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.MegaliterPerHour, quantity36.Unit); + var quantity36 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerMinute); + AssertEx.EqualTolerance(1, quantity36.KilolitersPerMinute, KilolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.KiloliterPerMinute, quantity36.Unit); - var quantity37 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerMinute); - AssertEx.EqualTolerance(1, quantity37.MegalitersPerMinute, MegalitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.MegaliterPerMinute, quantity37.Unit); + var quantity37 = VolumeFlow.From(1, VolumeFlowUnit.KiloliterPerSecond); + AssertEx.EqualTolerance(1, quantity37.KilolitersPerSecond, KilolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.KiloliterPerSecond, quantity37.Unit); - var quantity38 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerSecond); - AssertEx.EqualTolerance(1, quantity38.MegalitersPerSecond, MegalitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.MegaliterPerSecond, quantity38.Unit); + var quantity38 = VolumeFlow.From(1, VolumeFlowUnit.KilousGallonPerMinute); + AssertEx.EqualTolerance(1, quantity38.KilousGallonsPerMinute, KilousGallonsPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.KilousGallonPerMinute, quantity38.Unit); - var quantity39 = VolumeFlow.From(1, VolumeFlowUnit.MegaukGallonPerDay); - AssertEx.EqualTolerance(1, quantity39.MegaukGallonsPerDay, MegaukGallonsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MegaukGallonPerDay, quantity39.Unit); + var quantity39 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerDay); + AssertEx.EqualTolerance(1, quantity39.LitersPerDay, LitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.LiterPerDay, quantity39.Unit); - var quantity40 = VolumeFlow.From(1, VolumeFlowUnit.MegaukGallonPerSecond); - AssertEx.EqualTolerance(1, quantity40.MegaukGallonsPerSecond, MegaukGallonsPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.MegaukGallonPerSecond, quantity40.Unit); + var quantity40 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerHour); + AssertEx.EqualTolerance(1, quantity40.LitersPerHour, LitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.LiterPerHour, quantity40.Unit); - var quantity41 = VolumeFlow.From(1, VolumeFlowUnit.MegausGallonPerDay); - AssertEx.EqualTolerance(1, quantity41.MegausGallonsPerDay, MegausGallonsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MegausGallonPerDay, quantity41.Unit); + var quantity41 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerMinute); + AssertEx.EqualTolerance(1, quantity41.LitersPerMinute, LitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.LiterPerMinute, quantity41.Unit); - var quantity42 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerDay); - AssertEx.EqualTolerance(1, quantity42.MicrolitersPerDay, MicrolitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MicroliterPerDay, quantity42.Unit); + var quantity42 = VolumeFlow.From(1, VolumeFlowUnit.LiterPerSecond); + AssertEx.EqualTolerance(1, quantity42.LitersPerSecond, LitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.LiterPerSecond, quantity42.Unit); - var quantity43 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerHour); - AssertEx.EqualTolerance(1, quantity43.MicrolitersPerHour, MicrolitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.MicroliterPerHour, quantity43.Unit); + var quantity43 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerDay); + AssertEx.EqualTolerance(1, quantity43.MegalitersPerDay, MegalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MegaliterPerDay, quantity43.Unit); - var quantity44 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerMinute); - AssertEx.EqualTolerance(1, quantity44.MicrolitersPerMinute, MicrolitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.MicroliterPerMinute, quantity44.Unit); + var quantity44 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerHour); + AssertEx.EqualTolerance(1, quantity44.MegalitersPerHour, MegalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.MegaliterPerHour, quantity44.Unit); - var quantity45 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerSecond); - AssertEx.EqualTolerance(1, quantity45.MicrolitersPerSecond, MicrolitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.MicroliterPerSecond, quantity45.Unit); + var quantity45 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerMinute); + AssertEx.EqualTolerance(1, quantity45.MegalitersPerMinute, MegalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.MegaliterPerMinute, quantity45.Unit); - var quantity46 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerDay); - AssertEx.EqualTolerance(1, quantity46.MillilitersPerDay, MillilitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MilliliterPerDay, quantity46.Unit); + var quantity46 = VolumeFlow.From(1, VolumeFlowUnit.MegaliterPerSecond); + AssertEx.EqualTolerance(1, quantity46.MegalitersPerSecond, MegalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.MegaliterPerSecond, quantity46.Unit); - var quantity47 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerHour); - AssertEx.EqualTolerance(1, quantity47.MillilitersPerHour, MillilitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.MilliliterPerHour, quantity47.Unit); + var quantity47 = VolumeFlow.From(1, VolumeFlowUnit.MegaukGallonPerDay); + AssertEx.EqualTolerance(1, quantity47.MegaukGallonsPerDay, MegaukGallonsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MegaukGallonPerDay, quantity47.Unit); - var quantity48 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerMinute); - AssertEx.EqualTolerance(1, quantity48.MillilitersPerMinute, MillilitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.MilliliterPerMinute, quantity48.Unit); + var quantity48 = VolumeFlow.From(1, VolumeFlowUnit.MegaukGallonPerSecond); + AssertEx.EqualTolerance(1, quantity48.MegaukGallonsPerSecond, MegaukGallonsPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.MegaukGallonPerSecond, quantity48.Unit); - var quantity49 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerSecond); - AssertEx.EqualTolerance(1, quantity49.MillilitersPerSecond, MillilitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.MilliliterPerSecond, quantity49.Unit); + var quantity49 = VolumeFlow.From(1, VolumeFlowUnit.MegausGallonPerDay); + AssertEx.EqualTolerance(1, quantity49.MegausGallonsPerDay, MegausGallonsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MegausGallonPerDay, quantity49.Unit); - var quantity50 = VolumeFlow.From(1, VolumeFlowUnit.MillionUsGallonPerDay); - AssertEx.EqualTolerance(1, quantity50.MillionUsGallonsPerDay, MillionUsGallonsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.MillionUsGallonPerDay, quantity50.Unit); + var quantity50 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerDay); + AssertEx.EqualTolerance(1, quantity50.MicrolitersPerDay, MicrolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MicroliterPerDay, quantity50.Unit); - var quantity51 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerDay); - AssertEx.EqualTolerance(1, quantity51.NanolitersPerDay, NanolitersPerDayTolerance); - Assert.Equal(VolumeFlowUnit.NanoliterPerDay, quantity51.Unit); + var quantity51 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerHour); + AssertEx.EqualTolerance(1, quantity51.MicrolitersPerHour, MicrolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.MicroliterPerHour, quantity51.Unit); - var quantity52 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerHour); - AssertEx.EqualTolerance(1, quantity52.NanolitersPerHour, NanolitersPerHourTolerance); - Assert.Equal(VolumeFlowUnit.NanoliterPerHour, quantity52.Unit); + var quantity52 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerMinute); + AssertEx.EqualTolerance(1, quantity52.MicrolitersPerMinute, MicrolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.MicroliterPerMinute, quantity52.Unit); - var quantity53 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerMinute); - AssertEx.EqualTolerance(1, quantity53.NanolitersPerMinute, NanolitersPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.NanoliterPerMinute, quantity53.Unit); + var quantity53 = VolumeFlow.From(1, VolumeFlowUnit.MicroliterPerSecond); + AssertEx.EqualTolerance(1, quantity53.MicrolitersPerSecond, MicrolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.MicroliterPerSecond, quantity53.Unit); - var quantity54 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerSecond); - AssertEx.EqualTolerance(1, quantity54.NanolitersPerSecond, NanolitersPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.NanoliterPerSecond, quantity54.Unit); + var quantity54 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerDay); + AssertEx.EqualTolerance(1, quantity54.MillilitersPerDay, MillilitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MilliliterPerDay, quantity54.Unit); - var quantity55 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerDay); - AssertEx.EqualTolerance(1, quantity55.OilBarrelsPerDay, OilBarrelsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.OilBarrelPerDay, quantity55.Unit); + var quantity55 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerHour); + AssertEx.EqualTolerance(1, quantity55.MillilitersPerHour, MillilitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.MilliliterPerHour, quantity55.Unit); - var quantity56 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerHour); - AssertEx.EqualTolerance(1, quantity56.OilBarrelsPerHour, OilBarrelsPerHourTolerance); - Assert.Equal(VolumeFlowUnit.OilBarrelPerHour, quantity56.Unit); + var quantity56 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerMinute); + AssertEx.EqualTolerance(1, quantity56.MillilitersPerMinute, MillilitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.MilliliterPerMinute, quantity56.Unit); - var quantity57 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerMinute); - AssertEx.EqualTolerance(1, quantity57.OilBarrelsPerMinute, OilBarrelsPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.OilBarrelPerMinute, quantity57.Unit); + var quantity57 = VolumeFlow.From(1, VolumeFlowUnit.MilliliterPerSecond); + AssertEx.EqualTolerance(1, quantity57.MillilitersPerSecond, MillilitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.MilliliterPerSecond, quantity57.Unit); - var quantity58 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerSecond); - AssertEx.EqualTolerance(1, quantity58.OilBarrelsPerSecond, OilBarrelsPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.OilBarrelPerSecond, quantity58.Unit); + var quantity58 = VolumeFlow.From(1, VolumeFlowUnit.MillionUsGallonPerDay); + AssertEx.EqualTolerance(1, quantity58.MillionUsGallonsPerDay, MillionUsGallonsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.MillionUsGallonPerDay, quantity58.Unit); - var quantity59 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerDay); - AssertEx.EqualTolerance(1, quantity59.UkGallonsPerDay, UkGallonsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.UkGallonPerDay, quantity59.Unit); + var quantity59 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerDay); + AssertEx.EqualTolerance(1, quantity59.NanolitersPerDay, NanolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.NanoliterPerDay, quantity59.Unit); - var quantity60 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerHour); - AssertEx.EqualTolerance(1, quantity60.UkGallonsPerHour, UkGallonsPerHourTolerance); - Assert.Equal(VolumeFlowUnit.UkGallonPerHour, quantity60.Unit); + var quantity60 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerHour); + AssertEx.EqualTolerance(1, quantity60.NanolitersPerHour, NanolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.NanoliterPerHour, quantity60.Unit); - var quantity61 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerMinute); - AssertEx.EqualTolerance(1, quantity61.UkGallonsPerMinute, UkGallonsPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.UkGallonPerMinute, quantity61.Unit); + var quantity61 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerMinute); + AssertEx.EqualTolerance(1, quantity61.NanolitersPerMinute, NanolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.NanoliterPerMinute, quantity61.Unit); - var quantity62 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerSecond); - AssertEx.EqualTolerance(1, quantity62.UkGallonsPerSecond, UkGallonsPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.UkGallonPerSecond, quantity62.Unit); + var quantity62 = VolumeFlow.From(1, VolumeFlowUnit.NanoliterPerSecond); + AssertEx.EqualTolerance(1, quantity62.NanolitersPerSecond, NanolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.NanoliterPerSecond, quantity62.Unit); - var quantity63 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerDay); - AssertEx.EqualTolerance(1, quantity63.UsGallonsPerDay, UsGallonsPerDayTolerance); - Assert.Equal(VolumeFlowUnit.UsGallonPerDay, quantity63.Unit); + var quantity63 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerDay); + AssertEx.EqualTolerance(1, quantity63.OilBarrelsPerDay, OilBarrelsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.OilBarrelPerDay, quantity63.Unit); - var quantity64 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerHour); - AssertEx.EqualTolerance(1, quantity64.UsGallonsPerHour, UsGallonsPerHourTolerance); - Assert.Equal(VolumeFlowUnit.UsGallonPerHour, quantity64.Unit); + var quantity64 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerHour); + AssertEx.EqualTolerance(1, quantity64.OilBarrelsPerHour, OilBarrelsPerHourTolerance); + Assert.Equal(VolumeFlowUnit.OilBarrelPerHour, quantity64.Unit); - var quantity65 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerMinute); - AssertEx.EqualTolerance(1, quantity65.UsGallonsPerMinute, UsGallonsPerMinuteTolerance); - Assert.Equal(VolumeFlowUnit.UsGallonPerMinute, quantity65.Unit); + var quantity65 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerMinute); + AssertEx.EqualTolerance(1, quantity65.OilBarrelsPerMinute, OilBarrelsPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.OilBarrelPerMinute, quantity65.Unit); - var quantity66 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerSecond); - AssertEx.EqualTolerance(1, quantity66.UsGallonsPerSecond, UsGallonsPerSecondTolerance); - Assert.Equal(VolumeFlowUnit.UsGallonPerSecond, quantity66.Unit); + var quantity66 = VolumeFlow.From(1, VolumeFlowUnit.OilBarrelPerSecond); + AssertEx.EqualTolerance(1, quantity66.OilBarrelsPerSecond, OilBarrelsPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.OilBarrelPerSecond, quantity66.Unit); + + var quantity67 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerDay); + AssertEx.EqualTolerance(1, quantity67.UkGallonsPerDay, UkGallonsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.UkGallonPerDay, quantity67.Unit); + + var quantity68 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerHour); + AssertEx.EqualTolerance(1, quantity68.UkGallonsPerHour, UkGallonsPerHourTolerance); + Assert.Equal(VolumeFlowUnit.UkGallonPerHour, quantity68.Unit); + + var quantity69 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerMinute); + AssertEx.EqualTolerance(1, quantity69.UkGallonsPerMinute, UkGallonsPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.UkGallonPerMinute, quantity69.Unit); + + var quantity70 = VolumeFlow.From(1, VolumeFlowUnit.UkGallonPerSecond); + AssertEx.EqualTolerance(1, quantity70.UkGallonsPerSecond, UkGallonsPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.UkGallonPerSecond, quantity70.Unit); + + var quantity71 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerDay); + AssertEx.EqualTolerance(1, quantity71.UsGallonsPerDay, UsGallonsPerDayTolerance); + Assert.Equal(VolumeFlowUnit.UsGallonPerDay, quantity71.Unit); + + var quantity72 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerHour); + AssertEx.EqualTolerance(1, quantity72.UsGallonsPerHour, UsGallonsPerHourTolerance); + Assert.Equal(VolumeFlowUnit.UsGallonPerHour, quantity72.Unit); + + var quantity73 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerMinute); + AssertEx.EqualTolerance(1, quantity73.UsGallonsPerMinute, UsGallonsPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.UsGallonPerMinute, quantity73.Unit); + + var quantity74 = VolumeFlow.From(1, VolumeFlowUnit.UsGallonPerSecond); + AssertEx.EqualTolerance(1, quantity74.UsGallonsPerSecond, UsGallonsPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.UsGallonPerSecond, quantity74.Unit); } @@ -763,10 +835,18 @@ public void As() AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicYardPerHour), CubicYardsPerHourTolerance); AssertEx.EqualTolerance(CubicYardsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicYardPerMinute), CubicYardsPerMinuteTolerance); AssertEx.EqualTolerance(CubicYardsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.CubicYardPerSecond), CubicYardsPerSecondTolerance); + AssertEx.EqualTolerance(DecalitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DecaliterPerDay), DecalitersPerDayTolerance); + AssertEx.EqualTolerance(DecalitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DecaliterPerHour), DecalitersPerHourTolerance); + AssertEx.EqualTolerance(DecalitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DecaliterPerMinute), DecalitersPerMinuteTolerance); + AssertEx.EqualTolerance(DecalitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DecaliterPerSecond), DecalitersPerSecondTolerance); AssertEx.EqualTolerance(DecilitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DeciliterPerDay), DecilitersPerDayTolerance); AssertEx.EqualTolerance(DecilitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DeciliterPerHour), DecilitersPerHourTolerance); AssertEx.EqualTolerance(DecilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DeciliterPerMinute), DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(DecilitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.DeciliterPerSecond), DecilitersPerSecondTolerance); + AssertEx.EqualTolerance(HectolitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.HectoliterPerDay), HectolitersPerDayTolerance); + AssertEx.EqualTolerance(HectolitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.HectoliterPerHour), HectolitersPerHourTolerance); + AssertEx.EqualTolerance(HectolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.HectoliterPerMinute), HectolitersPerMinuteTolerance); + AssertEx.EqualTolerance(HectolitersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.HectoliterPerSecond), HectolitersPerSecondTolerance); AssertEx.EqualTolerance(KilolitersPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.KiloliterPerDay), KilolitersPerDayTolerance); AssertEx.EqualTolerance(KilolitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.KiloliterPerHour), KilolitersPerHourTolerance); AssertEx.EqualTolerance(KilolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(VolumeFlowUnit.KiloliterPerMinute), KilolitersPerMinuteTolerance); @@ -1096,6 +1176,90 @@ public void Parse() Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = VolumeFlow.Parse("1 dal/day", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daL/d", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daLPD", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daL/h", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daLPH", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 дал/ч", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daL/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daLPM", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 дал/мин", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daL/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 daLPS", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 дал/c", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = VolumeFlow.Parse("1 dl/day", CultureInfo.GetCultureInfo("en-US")); @@ -1180,6 +1344,90 @@ public void Parse() Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = VolumeFlow.Parse("1 hl/day", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hL/d", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hLPD", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hL/h", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hLPH", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 гл/ч", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hL/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hLPM", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 гл/мин", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hL/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 hLPS", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = VolumeFlow.Parse("1 гл/c", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = VolumeFlow.Parse("1 kl/day", CultureInfo.GetCultureInfo("en-US")); @@ -2085,6 +2333,78 @@ public void TryParse() Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, parsed.Unit); } + { + Assert.True(VolumeFlow.TryParse("1 dal/day", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daL/d", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daLPD", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerDay, DecalitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daL/h", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daLPH", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 дал/ч", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerHour, DecalitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daL/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daLPM", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 дал/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerMinute, DecalitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daL/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 daLPS", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 дал/c", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.DecalitersPerSecond, DecalitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsed.Unit); + } + { Assert.True(VolumeFlow.TryParse("1 dl/day", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.DecilitersPerDay, DecilitersPerDayTolerance); @@ -2157,6 +2477,78 @@ public void TryParse() Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, parsed.Unit); } + { + Assert.True(VolumeFlow.TryParse("1 hl/day", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hL/d", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hLPD", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerDay, HectolitersPerDayTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hL/h", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hLPH", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 гл/ч", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerHour, HectolitersPerHourTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hL/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hLPM", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 гл/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerMinute, HectolitersPerMinuteTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hL/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 hLPS", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } + + { + Assert.True(VolumeFlow.TryParse("1 гл/c", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.HectolitersPerSecond, HectolitersPerSecondTolerance); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsed.Unit); + } + { Assert.True(VolumeFlow.TryParse("1 kl/day", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.KilolitersPerDay, KilolitersPerDayTolerance); @@ -2822,6 +3214,78 @@ public void ParseUnit() Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = VolumeFlow.ParseUnit("dal/day", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daL/d", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daLPD", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daL/h", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daLPH", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("дал/ч", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daL/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daLPM", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("дал/мин", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daL/s", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("daLPS", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("дал/c", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsedUnit = VolumeFlow.ParseUnit("dl/day", CultureInfo.GetCultureInfo("en-US")); @@ -2894,6 +3358,78 @@ public void ParseUnit() Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = VolumeFlow.ParseUnit("hl/day", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hL/d", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hLPD", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hL/h", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hLPH", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("гл/ч", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hL/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hLPM", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("гл/мин", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hL/s", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("hLPS", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = VolumeFlow.ParseUnit("гл/c", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsedUnit = VolumeFlow.ParseUnit("kl/day", CultureInfo.GetCultureInfo("en-US")); @@ -3665,6 +4201,66 @@ public void TryParseUnit() Assert.Equal(VolumeFlowUnit.CubicYardPerSecond, parsedUnit); } + { + Assert.True(VolumeFlow.TryParseUnit("dal/day", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daL/d", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daLPD", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daL/h", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daLPH", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("дал/ч", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daL/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daLPM", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("дал/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daL/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("daLPS", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("дал/c", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.DecaliterPerSecond, parsedUnit); + } + { Assert.True(VolumeFlow.TryParseUnit("dl/day", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); Assert.Equal(VolumeFlowUnit.DeciliterPerDay, parsedUnit); @@ -3725,6 +4321,66 @@ public void TryParseUnit() Assert.Equal(VolumeFlowUnit.DeciliterPerSecond, parsedUnit); } + { + Assert.True(VolumeFlow.TryParseUnit("hl/day", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hL/d", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hLPD", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerDay, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hL/h", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hLPH", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("гл/ч", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerHour, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hL/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hLPM", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("гл/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerMinute, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hL/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("hLPS", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } + + { + Assert.True(VolumeFlow.TryParseUnit("гл/c", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(VolumeFlowUnit.HectoliterPerSecond, parsedUnit); + } + { Assert.True(VolumeFlow.TryParseUnit("kl/day", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); Assert.Equal(VolumeFlowUnit.KiloliterPerDay, parsedUnit); @@ -4155,10 +4811,18 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond, CubicYardsPerHourTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond, CubicYardsPerMinuteTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond, CubicYardsPerSecondTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerDay(cubicmeterpersecond.DecalitersPerDay).CubicMetersPerSecond, DecalitersPerDayTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerHour(cubicmeterpersecond.DecalitersPerHour).CubicMetersPerSecond, DecalitersPerHourTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerMinute(cubicmeterpersecond.DecalitersPerMinute).CubicMetersPerSecond, DecalitersPerMinuteTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromDecalitersPerSecond(cubicmeterpersecond.DecalitersPerSecond).CubicMetersPerSecond, DecalitersPerSecondTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerDay(cubicmeterpersecond.DecilitersPerDay).CubicMetersPerSecond, DecilitersPerDayTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerHour(cubicmeterpersecond.DecilitersPerHour).CubicMetersPerSecond, DecilitersPerHourTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond, DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromDecilitersPerSecond(cubicmeterpersecond.DecilitersPerSecond).CubicMetersPerSecond, DecilitersPerSecondTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerDay(cubicmeterpersecond.HectolitersPerDay).CubicMetersPerSecond, HectolitersPerDayTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerHour(cubicmeterpersecond.HectolitersPerHour).CubicMetersPerSecond, HectolitersPerHourTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerMinute(cubicmeterpersecond.HectolitersPerMinute).CubicMetersPerSecond, HectolitersPerMinuteTolerance); + AssertEx.EqualTolerance(1, VolumeFlow.FromHectolitersPerSecond(cubicmeterpersecond.HectolitersPerSecond).CubicMetersPerSecond, HectolitersPerSecondTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerDay(cubicmeterpersecond.KilolitersPerDay).CubicMetersPerSecond, KilolitersPerDayTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerHour(cubicmeterpersecond.KilolitersPerHour).CubicMetersPerSecond, KilolitersPerHourTolerance); AssertEx.EqualTolerance(1, VolumeFlow.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond, KilolitersPerMinuteTolerance); @@ -4369,10 +5033,18 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 yd³/h", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerHour).ToString()); Assert.Equal("1 yd³/min", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerMinute).ToString()); Assert.Equal("1 yd³/s", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerSecond).ToString()); + Assert.Equal("1 dal/day", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerDay).ToString()); + Assert.Equal("1 daL/h", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerHour).ToString()); + Assert.Equal("1 daL/min", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerMinute).ToString()); + Assert.Equal("1 daL/s", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerSecond).ToString()); Assert.Equal("1 dl/day", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerDay).ToString()); Assert.Equal("1 dL/h", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerHour).ToString()); Assert.Equal("1 dL/min", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerMinute).ToString()); Assert.Equal("1 dL/s", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerSecond).ToString()); + Assert.Equal("1 hl/day", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerDay).ToString()); + Assert.Equal("1 hL/h", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerHour).ToString()); + Assert.Equal("1 hL/min", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerMinute).ToString()); + Assert.Equal("1 hL/s", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerSecond).ToString()); Assert.Equal("1 kl/day", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerDay).ToString()); Assert.Equal("1 kL/h", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerHour).ToString()); Assert.Equal("1 kL/min", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerMinute).ToString()); @@ -4449,10 +5121,18 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 yd³/h", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerHour).ToString(swedishCulture)); Assert.Equal("1 yd³/min", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerMinute).ToString(swedishCulture)); Assert.Equal("1 yd³/s", new VolumeFlow(1, VolumeFlowUnit.CubicYardPerSecond).ToString(swedishCulture)); + Assert.Equal("1 dal/day", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerDay).ToString(swedishCulture)); + Assert.Equal("1 daL/h", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerHour).ToString(swedishCulture)); + Assert.Equal("1 daL/min", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerMinute).ToString(swedishCulture)); + Assert.Equal("1 daL/s", new VolumeFlow(1, VolumeFlowUnit.DecaliterPerSecond).ToString(swedishCulture)); Assert.Equal("1 dl/day", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerDay).ToString(swedishCulture)); Assert.Equal("1 dL/h", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerHour).ToString(swedishCulture)); Assert.Equal("1 dL/min", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerMinute).ToString(swedishCulture)); Assert.Equal("1 dL/s", new VolumeFlow(1, VolumeFlowUnit.DeciliterPerSecond).ToString(swedishCulture)); + Assert.Equal("1 hl/day", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerDay).ToString(swedishCulture)); + Assert.Equal("1 hL/h", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerHour).ToString(swedishCulture)); + Assert.Equal("1 hL/min", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerMinute).ToString(swedishCulture)); + Assert.Equal("1 hL/s", new VolumeFlow(1, VolumeFlowUnit.HectoliterPerSecond).ToString(swedishCulture)); Assert.Equal("1 kl/day", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerDay).ToString(swedishCulture)); Assert.Equal("1 kL/h", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerHour).ToString(swedishCulture)); Assert.Equal("1 kL/min", new VolumeFlow(1, VolumeFlowUnit.KiloliterPerMinute).ToString(swedishCulture)); diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs index 4c161a99b2..90b810bbf9 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -87,10 +87,18 @@ static VolumeFlow() new UnitInfo(VolumeFlowUnit.CubicYardPerHour, "CubicYardsPerHour", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.CubicYardPerMinute, "CubicYardsPerMinute", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.CubicYardPerSecond, "CubicYardsPerSecond", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.DecaliterPerDay, "DecalitersPerDay", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.DecaliterPerHour, "DecalitersPerHour", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.DecaliterPerMinute, "DecalitersPerMinute", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.DecaliterPerSecond, "DecalitersPerSecond", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.DeciliterPerDay, "DecilitersPerDay", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.DeciliterPerHour, "DecilitersPerHour", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.DeciliterPerMinute, "DecilitersPerMinute", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.DeciliterPerSecond, "DecilitersPerSecond", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.HectoliterPerDay, "HectolitersPerDay", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.HectoliterPerHour, "HectolitersPerHour", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.HectoliterPerMinute, "HectolitersPerMinute", BaseUnits.Undefined, "VolumeFlow"), + new UnitInfo(VolumeFlowUnit.HectoliterPerSecond, "HectolitersPerSecond", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.KiloliterPerDay, "KilolitersPerDay", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.KiloliterPerHour, "KilolitersPerHour", BaseUnits.Undefined, "VolumeFlow"), new UnitInfo(VolumeFlowUnit.KiloliterPerMinute, "KilolitersPerMinute", BaseUnits.Undefined, "VolumeFlow"), @@ -345,6 +353,26 @@ public VolumeFlow(double value, UnitSystem unitSystem) /// public double CubicYardsPerSecond => As(VolumeFlowUnit.CubicYardPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerDay => As(VolumeFlowUnit.DecaliterPerDay); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerHour => As(VolumeFlowUnit.DecaliterPerHour); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerMinute => As(VolumeFlowUnit.DecaliterPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double DecalitersPerSecond => As(VolumeFlowUnit.DecaliterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -365,6 +393,26 @@ public VolumeFlow(double value, UnitSystem unitSystem) /// public double DecilitersPerSecond => As(VolumeFlowUnit.DeciliterPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerDay => As(VolumeFlowUnit.HectoliterPerDay); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerHour => As(VolumeFlowUnit.HectoliterPerHour); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerMinute => As(VolumeFlowUnit.HectoliterPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double HectolitersPerSecond => As(VolumeFlowUnit.HectoliterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -602,10 +650,18 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicYardPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DecaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DecaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DecaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.DecaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.DeciliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.HectoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.HectoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.HectoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.HectoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerDay, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerHour, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.KiloliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicMeterPerSecond)); @@ -673,10 +729,18 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerHour)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerMinute)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.CubicYardPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.DecaliterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerDay)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerHour)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerMinute)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.DeciliterPerSecond)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerDay)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerHour)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerMinute)); + unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerSecond, quantity => quantity.ToUnit(VolumeFlowUnit.HectoliterPerSecond)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerDay, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerDay)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerHour, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerHour)); unitConverter.SetConversionFunction(VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerMinute, quantity => quantity.ToUnit(VolumeFlowUnit.KiloliterPerMinute)); @@ -965,6 +1029,46 @@ public static VolumeFlow FromCubicYardsPerSecond(QuantityValue cubicyardsperseco return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerDay(QuantityValue decalitersperday) + { + double value = (double) decalitersperday; + return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerDay); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerHour(QuantityValue decalitersperhour) + { + double value = (double) decalitersperhour; + return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerHour); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerMinute(QuantityValue decalitersperminute) + { + double value = (double) decalitersperminute; + return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerMinute); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromDecalitersPerSecond(QuantityValue decaliterspersecond) + { + double value = (double) decaliterspersecond; + return new VolumeFlow(value, VolumeFlowUnit.DecaliterPerSecond); + } + /// /// Creates a from . /// @@ -1005,6 +1109,46 @@ public static VolumeFlow FromDecilitersPerSecond(QuantityValue decilitersperseco return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerDay(QuantityValue hectolitersperday) + { + double value = (double) hectolitersperday; + return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerDay); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerHour(QuantityValue hectolitersperhour) + { + double value = (double) hectolitersperhour; + return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerHour); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerMinute(QuantityValue hectolitersperminute) + { + double value = (double) hectolitersperminute; + return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerMinute); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static VolumeFlow FromHectolitersPerSecond(QuantityValue hectoliterspersecond) + { + double value = (double) hectoliterspersecond; + return new VolumeFlow(value, VolumeFlowUnit.HectoliterPerSecond); + } + /// /// Creates a from . /// @@ -1929,10 +2073,18 @@ private bool TryToUnit(VolumeFlowUnit unit, [NotNullWhen(true)] out VolumeFlow? (VolumeFlowUnit.CubicYardPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 2.1237634944E-4, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.CubicYardPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.0127425809664, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.CubicYardPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow(_value * 0.764554857984, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.DecaliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 86400000) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.DecaliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 3600000.000) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.DecaliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 60000.00000) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.DecaliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e1d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.DeciliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 86400000) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.DeciliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 3600000.000) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.DeciliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 60000.00000) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.DeciliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e-1d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.HectoliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 86400000) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.HectoliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 3600000.000) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.HectoliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 60000.00000) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond), + (VolumeFlowUnit.HectoliterPerSecond, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 1000) * 1e2d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.KiloliterPerDay, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 86400000) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.KiloliterPerHour, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 3600000.000) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond), (VolumeFlowUnit.KiloliterPerMinute, VolumeFlowUnit.CubicMeterPerSecond) => new VolumeFlow((_value / 60000.00000) * 1e3d, VolumeFlowUnit.CubicMeterPerSecond), @@ -1997,10 +2149,18 @@ private bool TryToUnit(VolumeFlowUnit unit, [NotNullWhen(true)] out VolumeFlow? (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerHour) => new VolumeFlow(_value / 2.1237634944E-4, VolumeFlowUnit.CubicYardPerHour), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerMinute) => new VolumeFlow(_value / 0.0127425809664, VolumeFlowUnit.CubicYardPerMinute), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.CubicYardPerSecond) => new VolumeFlow(_value / 0.764554857984, VolumeFlowUnit.CubicYardPerSecond), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerDay) => new VolumeFlow((_value * 86400000) / 1e1d, VolumeFlowUnit.DecaliterPerDay), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerHour) => new VolumeFlow((_value * 3600000.000) / 1e1d, VolumeFlowUnit.DecaliterPerHour), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerMinute) => new VolumeFlow((_value * 60000.00000) / 1e1d, VolumeFlowUnit.DecaliterPerMinute), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DecaliterPerSecond) => new VolumeFlow((_value * 1000) / 1e1d, VolumeFlowUnit.DecaliterPerSecond), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerDay) => new VolumeFlow((_value * 86400000) / 1e-1d, VolumeFlowUnit.DeciliterPerDay), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerHour) => new VolumeFlow((_value * 3600000.000) / 1e-1d, VolumeFlowUnit.DeciliterPerHour), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerMinute) => new VolumeFlow((_value * 60000.00000) / 1e-1d, VolumeFlowUnit.DeciliterPerMinute), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.DeciliterPerSecond) => new VolumeFlow((_value * 1000) / 1e-1d, VolumeFlowUnit.DeciliterPerSecond), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerDay) => new VolumeFlow((_value * 86400000) / 1e2d, VolumeFlowUnit.HectoliterPerDay), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerHour) => new VolumeFlow((_value * 3600000.000) / 1e2d, VolumeFlowUnit.HectoliterPerHour), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerMinute) => new VolumeFlow((_value * 60000.00000) / 1e2d, VolumeFlowUnit.HectoliterPerMinute), + (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.HectoliterPerSecond) => new VolumeFlow((_value * 1000) / 1e2d, VolumeFlowUnit.HectoliterPerSecond), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerDay) => new VolumeFlow((_value * 86400000) / 1e3d, VolumeFlowUnit.KiloliterPerDay), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerHour) => new VolumeFlow((_value * 3600000.000) / 1e3d, VolumeFlowUnit.KiloliterPerHour), (VolumeFlowUnit.CubicMeterPerSecond, VolumeFlowUnit.KiloliterPerMinute) => new VolumeFlow((_value * 60000.00000) / 1e3d, VolumeFlowUnit.KiloliterPerMinute), diff --git a/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext b/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext index 73c8bc54e0..b071b56273 100644 --- a/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext +++ b/UnitsNet/GeneratedCode/Resources/VolumeFlow.restext @@ -20,10 +20,18 @@ CubicYardsPerDay=cy/day CubicYardsPerHour=yd³/h CubicYardsPerMinute=yd³/min CubicYardsPerSecond=yd³/s +DecalitersPerDay=dal/day,daL/d,daLPD +DecalitersPerHour=daL/h,daLPH +DecalitersPerMinute=daL/min,daLPM +DecalitersPerSecond=daL/s,daLPS DecilitersPerDay=dl/day,dL/d,dLPD DecilitersPerHour=dL/h,dLPH DecilitersPerMinute=dL/min,dLPM DecilitersPerSecond=dL/s,dLPS +HectolitersPerDay=hl/day,hL/d,hLPD +HectolitersPerHour=hL/h,hLPH +HectolitersPerMinute=hL/min,hLPM +HectolitersPerSecond=hL/s,hLPS KilolitersPerDay=kl/day,kL/d,kLPD KilolitersPerHour=kL/h,kLPH KilolitersPerMinute=kL/min,kLPM diff --git a/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext index 6e5a483b50..289ed120cc 100644 --- a/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext +++ b/UnitsNet/GeneratedCode/Resources/VolumeFlow.ru-RU.restext @@ -7,9 +7,15 @@ CubicMetersPerHour=м³/ч CubicMetersPerMinute=м³/мин CubicMetersPerSecond=м³/с CubicMillimetersPerSecond=мм³/с +DecalitersPerHour=дал/ч +DecalitersPerMinute=дал/мин +DecalitersPerSecond=дал/c DecilitersPerHour=дл/ч DecilitersPerMinute=дл/мин DecilitersPerSecond=дл/c +HectolitersPerHour=гл/ч +HectolitersPerMinute=гл/мин +HectolitersPerSecond=гл/c KilolitersPerHour=кл/ч KilolitersPerMinute=кл/мин KilolitersPerSecond=кл/c diff --git a/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs index ab8b2bca49..6c14bc7b98 100644 --- a/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/VolumeFlowUnit.g.cs @@ -47,10 +47,18 @@ public enum VolumeFlowUnit CubicYardPerHour = 20, CubicYardPerMinute = 21, CubicYardPerSecond = 22, + DecaliterPerDay = 71, + DecaliterPerHour = 78, + DecaliterPerMinute = 67, + DecaliterPerSecond = 70, DeciliterPerDay = 23, DeciliterPerHour = 24, DeciliterPerMinute = 25, DeciliterPerSecond = 26, + HectoliterPerDay = 74, + HectoliterPerHour = 72, + HectoliterPerMinute = 75, + HectoliterPerSecond = 69, KiloliterPerDay = 27, KiloliterPerHour = 28, KiloliterPerMinute = 29,