diff --git a/Common/UnitDefinitions/FluidResistance.json b/Common/UnitDefinitions/FluidResistance.json
new file mode 100644
index 0000000000..130d0f86cd
--- /dev/null
+++ b/Common/UnitDefinitions/FluidResistance.json
@@ -0,0 +1,415 @@
+{
+ "Name": "FluidResistance",
+ "BaseUnit": "PascalSecondPerCubicMeter",
+ "XmlDocSummary": "Fluid Resistance is a force acting opposite to the relative motion of any object moving with respect to a surrounding fluid. Fluid Resistance is sometimes referred to as drag or fluid friction.",
+ "XmlDocRemarks": "https://en.wikipedia.org/wiki/Friction#Fluid",
+ "BaseDimensions": {
+ "M": 1,
+ "L": -4,
+ "T": -1
+ },
+ "Units": [
+ {
+ "SingularName": "PascalSecondPerLiter",
+ "PluralName": "PascalSecondsPerLiter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1e3",
+ "FromBaseToUnitFunc": "{x} / 1e3",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·s/l" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·с/л" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalMinutePerLiter",
+ "PluralName": "PascalMinutesPerLiter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 6e4",
+ "FromBaseToUnitFunc": "{x} / 6e4",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·min/l" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·мин/л" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalSecondPerMilliliter",
+ "PluralName": "PascalSecondsPerMilliliter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1e6",
+ "FromBaseToUnitFunc": "{x} / 1e6",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·s/ml" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·с/мл" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalMinutePerMilliliter",
+ "PluralName": "PascalMinutesPerMilliliter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 6e7",
+ "FromBaseToUnitFunc": "{x} / 6e7",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·min/ml" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·мин/мл" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalSecondPerCubicMeter",
+ "PluralName": "PascalSecondsPerCubicMeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x}",
+ "FromBaseToUnitFunc": "{x}",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·s/m³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·с/м³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalMinutePerCubicMeter",
+ "PluralName": "PascalMinutesPerCubicMeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 60",
+ "FromBaseToUnitFunc": "{x} / 60",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·min/m³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·мин/м³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalSecondPerCubicCentimeter",
+ "PluralName": "PascalSecondsPerCubicCentimeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1e6",
+ "FromBaseToUnitFunc": "{x} / 1e6",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·s/cm³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·с/см³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "PascalMinutePerCubicCentimeter",
+ "PluralName": "PascalMinutesPerCubicCentimeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 6e7",
+ "FromBaseToUnitFunc": "{x} / 6e7",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "Pa·min/cm³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "Па·мин/см³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MegapascalSecondPerCubicMeter",
+ "PluralName": "MegapascalSecondsPerCubicMeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1e6",
+ "FromBaseToUnitFunc": "{x} / 1e6",
+ "XmlDocRemarks": "https://en.wikipedia.org/wiki/Vascular_resistance",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "MPa·s/m³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "МПа·с/м³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "DyneSecondPerCentimeterToTheFifth",
+ "PluralName": "DyneSecondsPerCentimeterToTheFifth",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1e-5",
+ "FromBaseToUnitFunc": "{x} / 1e-5",
+ "XmlDocRemarks": "https://en.wikipedia.org/wiki/Vascular_resistance",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "dyn·s/cm⁵", "dyn·s·cm⁻⁵" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "дин·с/см⁵", "дин·с·см⁻⁵" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercurySecondPerLiter",
+ "PluralName": "MillimeterMercurySecondsPerLiter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1.33322368e5",
+ "FromBaseToUnitFunc": "{x} / 1.33322368e5",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·s/l" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·с/л" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercuryMinutePerLiter",
+ "PluralName": "MillimeterMercuryMinutesPerLiter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 7.99934208e6",
+ "FromBaseToUnitFunc": "{x} / 7.99934208e6",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·min/l" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·мин/л" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercurySecondPerMilliliter",
+ "PluralName": "MillimeterMercurySecondsPerMilliliter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1.33322368e8",
+ "FromBaseToUnitFunc": "{x} / 1.33322368e8",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·s/ml" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·с/мл" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercuryMinutePerMilliliter",
+ "PluralName": "MillimeterMercuryMinutesPerMilliliter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 7.99934208e9",
+ "FromBaseToUnitFunc": "{x} / 7.99934208e9",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·min/ml" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·мин/мл" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercurySecondPerCubicCentimeter",
+ "PluralName": "MillimeterMercurySecondsPerCubicCentimeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 1.33322368e8",
+ "FromBaseToUnitFunc": "{x} / 1.33322368e8",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·s/cm³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·с/см³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercuryMinutePerCubicCentimeter",
+ "PluralName": "MillimeterMercuryMinutesPerCubicCentimeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 7.99934208e9",
+ "FromBaseToUnitFunc": "{x} / 7.99934208e9",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·min/cm³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·мин/см³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercurySecondPerCubicMeter",
+ "PluralName": "MillimeterMercurySecondsPerCubicMeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 133.322368",
+ "FromBaseToUnitFunc": "{x} / 133.322368",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·s/m³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·с/м³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "MillimeterMercuryMinutePerCubicMeter",
+ "PluralName": "MillimeterMercuryMinutesPerCubicMeter",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 7.99934208e3",
+ "FromBaseToUnitFunc": "{x} / 7.99934208e3",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "mmHg·min/m³" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "мм рт.ст·мин/м³" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "WoodUnit",
+ "PluralName": "WoodUnits",
+ "BaseUnits": {
+ "M": "Kilogram",
+ "L": "Meter",
+ "T": "Second"
+ },
+ "FromUnitToBaseFunc": "{x} * 7.99934208e6",
+ "FromBaseToUnitFunc": "{x} / 7.99934208e6",
+ "XmlDocRemarks": "https://en.wikipedia.org/wiki/Vascular_resistance",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "WU", "HRU" ]
+ },
+ {
+ "Culture": "ru-RU",
+ "Abbreviations": [ "ЕВ", "ЕГС" ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json
index 59a164a718..61e715b277 100644
--- a/Common/UnitEnumValues.g.json
+++ b/Common/UnitEnumValues.g.json
@@ -1928,6 +1928,27 @@
"MilligraySquareMeter": 11,
"MilligraySquareMillimeter": 12
},
+ "FluidResistance": {
+ "DyneSecondPerCentimeterToTheFifth": 6,
+ "MegapascalSecondPerCubicMeter": 7,
+ "MillimeterMercuryMinutePerCubicCentimeter": 3,
+ "MillimeterMercuryMinutePerCubicMeter": 5,
+ "MillimeterMercuryMinutePerLiter": 2,
+ "MillimeterMercuryMinutePerMilliliter": 9,
+ "MillimeterMercurySecondPerCubicCentimeter": 8,
+ "MillimeterMercurySecondPerCubicMeter": 10,
+ "MillimeterMercurySecondPerLiter": 4,
+ "MillimeterMercurySecondPerMilliliter": 1,
+ "PascalMinutePerCubicCentimeter": 19,
+ "PascalMinutePerCubicMeter": 16,
+ "PascalMinutePerLiter": 15,
+ "PascalMinutePerMilliliter": 12,
+ "PascalSecondPerCubicCentimeter": 18,
+ "PascalSecondPerCubicMeter": 13,
+ "PascalSecondPerLiter": 11,
+ "PascalSecondPerMilliliter": 20,
+ "WoodUnit": 17
+ },
"ElectricApparentEnergy": {
"KilovoltampereHour": 7,
"MegavoltampereHour": 3,
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj
new file mode 100644
index 0000000000..6fae96c9b0
--- /dev/null
+++ b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/FluidResistance.nfproj
@@ -0,0 +1,42 @@
+
+
+
+ $(MSBuildExtensionsPath)\nanoFramework\v1.0\
+
+
+
+ Debug
+ AnyCPU
+ {11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
+ {d19281dc-72f6-62a9-18d5-b845d6fd8d99}
+ Library
+ Properties
+ 512
+ UnitsNet
+ UnitsNet.FluidResistance
+ v1.0
+ bin\$(Configuration)\$(AssemblyName).xml
+
+
+
+
+
+
+
+
+
+ ..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll
+ True
+ True
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec
new file mode 100644
index 0000000000..24b3811816
--- /dev/null
+++ b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/UnitsNet.NanoFramework.FluidResistance.nuspec
@@ -0,0 +1,26 @@
+
+
+
+ UnitsNet.nanoFramework.FluidResistance
+ 5.64.0
+ Units.NET FluidResistance - nanoFramework
+ Andreas Gullberg Larsen,nanoframework
+ UnitsNet
+ MIT-0
+ https://github.com/angularsen/UnitsNet
+ false
+ Adds FluidResistance units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead.
+ https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png
+
+
+ Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).
+ en-US
+ nanoframework fluidresistance unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable
+
+
+
+
+
+
+
+
diff --git a/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config
new file mode 100644
index 0000000000..313a8dccdf
--- /dev/null
+++ b/UnitsNet.NanoFramework/GeneratedCode/FluidResistance/packages.config
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs
new file mode 100644
index 0000000000..d813a38a4a
--- /dev/null
+++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FluidResistance.g.cs
@@ -0,0 +1,396 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+ ///
+ ///
+ /// Fluid Resistance is a force acting opposite to the relative motion of any object moving with respect to a surrounding fluid. Fluid Resistance is sometimes referred to as drag or fluid friction.
+ ///
+ ///
+ /// https://en.wikipedia.org/wiki/Friction#Fluid
+ ///
+ public struct FluidResistance
+ {
+ ///
+ /// The numeric value this quantity was constructed with.
+ ///
+ private readonly double _value;
+
+ ///
+ /// The unit this quantity was constructed with.
+ ///
+ private readonly FluidResistanceUnit _unit;
+
+ ///
+ /// The numeric value this quantity was constructed with.
+ ///
+ public double Value => _value;
+
+ ///
+ public FluidResistanceUnit Unit => _unit;
+
+ ///
+ /// Creates the quantity with the given numeric value and unit.
+ ///
+ /// The numeric value to construct this quantity with.
+ /// The unit representation to construct this quantity with.
+ /// If value is NaN or Infinity.
+ public FluidResistance(double value, FluidResistanceUnit unit)
+ {
+ _value = value;
+ _unit = unit;
+ }
+
+ ///
+ /// The base unit of FluidResistance, which is Second. All conversions go via this value.
+ ///
+ public static FluidResistanceUnit BaseUnit { get; } = FluidResistanceUnit.PascalSecondPerCubicMeter;
+
+ ///
+ /// Represents the largest possible value of FluidResistance.
+ ///
+ public static FluidResistance MaxValue { get; } = new FluidResistance(double.MaxValue, BaseUnit);
+
+ ///
+ /// Represents the smallest possible value of FluidResistance.
+ ///
+ public static FluidResistance MinValue { get; } = new FluidResistance(double.MinValue, BaseUnit);
+
+ ///
+ /// Gets an instance of this quantity with a value of 0 in the base unit Second.
+ ///
+ public static FluidResistance Zero { get; } = new FluidResistance(0, BaseUnit);
+ #region Conversion Properties
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double DyneSecondsPerCentimeterToTheFifth => As(FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MegapascalSecondsPerCubicMeter => As(FluidResistanceUnit.MegapascalSecondPerCubicMeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercuryMinutesPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercuryMinutesPerCubicMeter => As(FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercuryMinutesPerLiter => As(FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercuryMinutesPerMilliliter => As(FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercurySecondsPerCubicCentimeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercurySecondsPerCubicMeter => As(FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercurySecondsPerLiter => As(FluidResistanceUnit.MillimeterMercurySecondPerLiter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double MillimeterMercurySecondsPerMilliliter => As(FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalMinutesPerCubicCentimeter => As(FluidResistanceUnit.PascalMinutePerCubicCentimeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalMinutesPerCubicMeter => As(FluidResistanceUnit.PascalMinutePerCubicMeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalMinutesPerLiter => As(FluidResistanceUnit.PascalMinutePerLiter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalMinutesPerMilliliter => As(FluidResistanceUnit.PascalMinutePerMilliliter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalSecondsPerCubicCentimeter => As(FluidResistanceUnit.PascalSecondPerCubicCentimeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalSecondsPerCubicMeter => As(FluidResistanceUnit.PascalSecondPerCubicMeter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalSecondsPerLiter => As(FluidResistanceUnit.PascalSecondPerLiter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double PascalSecondsPerMilliliter => As(FluidResistanceUnit.PascalSecondPerMilliliter);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double WoodUnits => As(FluidResistanceUnit.WoodUnit);
+
+ #endregion
+
+ #region Static Factory Methods
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromDyneSecondsPerCentimeterToTheFifth(double dynesecondspercentimetertothefifth) => new FluidResistance(dynesecondspercentimetertothefifth, FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMegapascalSecondsPerCubicMeter(double megapascalsecondspercubicmeter) => new FluidResistance(megapascalsecondspercubicmeter, FluidResistanceUnit.MegapascalSecondPerCubicMeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercuryMinutesPerCubicCentimeter(double millimetermercuryminutespercubiccentimeter) => new FluidResistance(millimetermercuryminutespercubiccentimeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercuryMinutesPerCubicMeter(double millimetermercuryminutespercubicmeter) => new FluidResistance(millimetermercuryminutespercubicmeter, FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercuryMinutesPerLiter(double millimetermercuryminutesperliter) => new FluidResistance(millimetermercuryminutesperliter, FluidResistanceUnit.MillimeterMercuryMinutePerLiter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercuryMinutesPerMilliliter(double millimetermercuryminutespermilliliter) => new FluidResistance(millimetermercuryminutespermilliliter, FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercurySecondsPerCubicCentimeter(double millimetermercurysecondspercubiccentimeter) => new FluidResistance(millimetermercurysecondspercubiccentimeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercurySecondsPerCubicMeter(double millimetermercurysecondspercubicmeter) => new FluidResistance(millimetermercurysecondspercubicmeter, FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercurySecondsPerLiter(double millimetermercurysecondsperliter) => new FluidResistance(millimetermercurysecondsperliter, FluidResistanceUnit.MillimeterMercurySecondPerLiter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromMillimeterMercurySecondsPerMilliliter(double millimetermercurysecondspermilliliter) => new FluidResistance(millimetermercurysecondspermilliliter, FluidResistanceUnit.MillimeterMercurySecondPerMilliliter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalMinutesPerCubicCentimeter(double pascalminutespercubiccentimeter) => new FluidResistance(pascalminutespercubiccentimeter, FluidResistanceUnit.PascalMinutePerCubicCentimeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalMinutesPerCubicMeter(double pascalminutespercubicmeter) => new FluidResistance(pascalminutespercubicmeter, FluidResistanceUnit.PascalMinutePerCubicMeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalMinutesPerLiter(double pascalminutesperliter) => new FluidResistance(pascalminutesperliter, FluidResistanceUnit.PascalMinutePerLiter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalMinutesPerMilliliter(double pascalminutespermilliliter) => new FluidResistance(pascalminutespermilliliter, FluidResistanceUnit.PascalMinutePerMilliliter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalSecondsPerCubicCentimeter(double pascalsecondspercubiccentimeter) => new FluidResistance(pascalsecondspercubiccentimeter, FluidResistanceUnit.PascalSecondPerCubicCentimeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalSecondsPerCubicMeter(double pascalsecondspercubicmeter) => new FluidResistance(pascalsecondspercubicmeter, FluidResistanceUnit.PascalSecondPerCubicMeter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalSecondsPerLiter(double pascalsecondsperliter) => new FluidResistance(pascalsecondsperliter, FluidResistanceUnit.PascalSecondPerLiter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromPascalSecondsPerMilliliter(double pascalsecondspermilliliter) => new FluidResistance(pascalsecondspermilliliter, FluidResistanceUnit.PascalSecondPerMilliliter);
+
+ ///
+ /// Creates a from .
+ ///
+ /// If value is NaN or Infinity.
+ public static FluidResistance FromWoodUnits(double woodunits) => new FluidResistance(woodunits, FluidResistanceUnit.WoodUnit);
+
+ ///
+ /// Dynamically convert from value and unit enum to .
+ ///
+ /// Value to convert from.
+ /// Unit to convert from.
+ /// FluidResistance unit value.
+ public static FluidResistance From(double value, FluidResistanceUnit fromUnit)
+ {
+ return new FluidResistance(value, fromUnit);
+ }
+
+ #endregion
+
+ #region Conversion Methods
+
+ ///
+ /// Convert to the unit representation .
+ ///
+ /// Value converted to the specified unit.
+ public double As(FluidResistanceUnit unit) => GetValueAs(unit);
+
+ ///
+ /// Converts this FluidResistance to another FluidResistance with the unit representation .
+ ///
+ /// A FluidResistance with the specified unit.
+ public FluidResistance ToUnit(FluidResistanceUnit unit)
+ {
+ var convertedValue = GetValueAs(unit);
+ return new FluidResistance(convertedValue, unit);
+ }
+
+ ///
+ /// Converts the current value + unit to the base unit.
+ /// This is typically the first step in converting from one unit to another.
+ ///
+ /// The value in the base unit representation.
+ private double GetValueInBaseUnit()
+ {
+ return Unit switch
+ {
+ FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth => _value * 1e-5,
+ FluidResistanceUnit.MegapascalSecondPerCubicMeter => _value * 1e6,
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter => _value * 7.99934208e9,
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter => _value * 7.99934208e3,
+ FluidResistanceUnit.MillimeterMercuryMinutePerLiter => _value * 7.99934208e6,
+ FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter => _value * 7.99934208e9,
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter => _value * 1.33322368e8,
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter => _value * 133.322368,
+ FluidResistanceUnit.MillimeterMercurySecondPerLiter => _value * 1.33322368e5,
+ FluidResistanceUnit.MillimeterMercurySecondPerMilliliter => _value * 1.33322368e8,
+ FluidResistanceUnit.PascalMinutePerCubicCentimeter => _value * 6e7,
+ FluidResistanceUnit.PascalMinutePerCubicMeter => _value * 60,
+ FluidResistanceUnit.PascalMinutePerLiter => _value * 6e4,
+ FluidResistanceUnit.PascalMinutePerMilliliter => _value * 6e7,
+ FluidResistanceUnit.PascalSecondPerCubicCentimeter => _value * 1e6,
+ FluidResistanceUnit.PascalSecondPerCubicMeter => _value,
+ FluidResistanceUnit.PascalSecondPerLiter => _value * 1e3,
+ FluidResistanceUnit.PascalSecondPerMilliliter => _value * 1e6,
+ FluidResistanceUnit.WoodUnit => _value * 7.99934208e6,
+ _ => throw new NotImplementedException($"Can not convert {Unit} to base units.")
+ };
+ }
+
+ private double GetValueAs(FluidResistanceUnit unit)
+ {
+ if (Unit == unit)
+ return _value;
+
+ var baseUnitValue = GetValueInBaseUnit();
+
+ return unit switch
+ {
+ FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth => baseUnitValue / 1e-5,
+ FluidResistanceUnit.MegapascalSecondPerCubicMeter => baseUnitValue / 1e6,
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter => baseUnitValue / 7.99934208e9,
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter => baseUnitValue / 7.99934208e3,
+ FluidResistanceUnit.MillimeterMercuryMinutePerLiter => baseUnitValue / 7.99934208e6,
+ FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter => baseUnitValue / 7.99934208e9,
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter => baseUnitValue / 1.33322368e8,
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter => baseUnitValue / 133.322368,
+ FluidResistanceUnit.MillimeterMercurySecondPerLiter => baseUnitValue / 1.33322368e5,
+ FluidResistanceUnit.MillimeterMercurySecondPerMilliliter => baseUnitValue / 1.33322368e8,
+ FluidResistanceUnit.PascalMinutePerCubicCentimeter => baseUnitValue / 6e7,
+ FluidResistanceUnit.PascalMinutePerCubicMeter => baseUnitValue / 60,
+ FluidResistanceUnit.PascalMinutePerLiter => baseUnitValue / 6e4,
+ FluidResistanceUnit.PascalMinutePerMilliliter => baseUnitValue / 6e7,
+ FluidResistanceUnit.PascalSecondPerCubicCentimeter => baseUnitValue / 1e6,
+ FluidResistanceUnit.PascalSecondPerCubicMeter => baseUnitValue,
+ FluidResistanceUnit.PascalSecondPerLiter => baseUnitValue / 1e3,
+ FluidResistanceUnit.PascalSecondPerMilliliter => baseUnitValue / 1e6,
+ FluidResistanceUnit.WoodUnit => baseUnitValue / 7.99934208e6,
+ _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.")
+ };
+ }
+
+ #endregion
+ }
+}
+
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs
new file mode 100644
index 0000000000..a32cb873c5
--- /dev/null
+++ b/UnitsNet.NanoFramework/GeneratedCode/Units/FluidResistanceUnit.g.cs
@@ -0,0 +1,53 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Units
+{
+ // Disable missing XML comment warnings for the generated unit enums.
+ #pragma warning disable 1591
+
+ public enum FluidResistanceUnit
+ {
+ /// https://en.wikipedia.org/wiki/Vascular_resistance
+ DyneSecondPerCentimeterToTheFifth = 6,
+ /// https://en.wikipedia.org/wiki/Vascular_resistance
+ MegapascalSecondPerCubicMeter = 7,
+ MillimeterMercuryMinutePerCubicCentimeter = 3,
+ MillimeterMercuryMinutePerCubicMeter = 5,
+ MillimeterMercuryMinutePerLiter = 2,
+ MillimeterMercuryMinutePerMilliliter = 9,
+ MillimeterMercurySecondPerCubicCentimeter = 8,
+ MillimeterMercurySecondPerCubicMeter = 10,
+ MillimeterMercurySecondPerLiter = 4,
+ MillimeterMercurySecondPerMilliliter = 1,
+ PascalMinutePerCubicCentimeter = 19,
+ PascalMinutePerCubicMeter = 16,
+ PascalMinutePerLiter = 15,
+ PascalMinutePerMilliliter = 12,
+ PascalSecondPerCubicCentimeter = 18,
+ PascalSecondPerCubicMeter = 13,
+ PascalSecondPerLiter = 11,
+ PascalSecondPerMilliliter = 20,
+ /// https://en.wikipedia.org/wiki/Vascular_resistance
+ WoodUnit = 17,
+ }
+
+ #pragma warning restore 1591
+}
diff --git a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln
index 686fcf0b76..ce0f3e87d9 100644
--- a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln
+++ b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln
@@ -96,6 +96,8 @@ Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "EnergyDensity", "EnergyDens
EndProject
Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Entropy", "Entropy\Entropy.nfproj", "{816884bb-a5f6-5c07-967b-bb8f21d724b7}"
EndProject
+Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "FluidResistance", "FluidResistance\FluidResistance.nfproj", "{d19281dc-72f6-62a9-18d5-b845d6fd8d99}"
+EndProject
Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Force", "Force\Force.nfproj", "{5517dacf-b1ff-6515-e5b6-b5081f92f407}"
EndProject
Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ForceChangeRate", "ForceChangeRate\ForceChangeRate.nfproj", "{97ad732d-4ce5-2027-aabc-844002d29c23}"
@@ -558,6 +560,12 @@ Global
{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.ActiveCfg = Release|Any CPU
{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.Build.0 = Release|Any CPU
{816884bb-a5f6-5c07-967b-bb8f21d724b7}.Release|Any CPU.Deploy.0 = Release|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.Build.0 = Debug|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.ActiveCfg = Release|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.Build.0 = Release|Any CPU
+{d19281dc-72f6-62a9-18d5-b845d6fd8d99}.Release|Any CPU.Deploy.0 = Release|Any CPU
{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5517dacf-b1ff-6515-e5b6-b5081f92f407}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..900684db11
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs
@@ -0,0 +1,104 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToFluidResistance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+ public class NumberToFluidResistanceExtensionsTests
+ {
+ [Fact]
+ public void NumberToDyneSecondsPerCentimeterToTheFifthTest() =>
+ Assert.Equal(FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(2), 2.DyneSecondsPerCentimeterToTheFifth());
+
+ [Fact]
+ public void NumberToMegapascalSecondsPerCubicMeterTest() =>
+ Assert.Equal(FluidResistance.FromMegapascalSecondsPerCubicMeter(2), 2.MegapascalSecondsPerCubicMeter());
+
+ [Fact]
+ public void NumberToMillimeterMercuryMinutesPerCubicCentimeterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(2), 2.MillimeterMercuryMinutesPerCubicCentimeter());
+
+ [Fact]
+ public void NumberToMillimeterMercuryMinutesPerCubicMeterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(2), 2.MillimeterMercuryMinutesPerCubicMeter());
+
+ [Fact]
+ public void NumberToMillimeterMercuryMinutesPerLiterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerLiter(2), 2.MillimeterMercuryMinutesPerLiter());
+
+ [Fact]
+ public void NumberToMillimeterMercuryMinutesPerMilliliterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(2), 2.MillimeterMercuryMinutesPerMilliliter());
+
+ [Fact]
+ public void NumberToMillimeterMercurySecondsPerCubicCentimeterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(2), 2.MillimeterMercurySecondsPerCubicCentimeter());
+
+ [Fact]
+ public void NumberToMillimeterMercurySecondsPerCubicMeterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(2), 2.MillimeterMercurySecondsPerCubicMeter());
+
+ [Fact]
+ public void NumberToMillimeterMercurySecondsPerLiterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerLiter(2), 2.MillimeterMercurySecondsPerLiter());
+
+ [Fact]
+ public void NumberToMillimeterMercurySecondsPerMilliliterTest() =>
+ Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerMilliliter(2), 2.MillimeterMercurySecondsPerMilliliter());
+
+ [Fact]
+ public void NumberToPascalMinutesPerCubicCentimeterTest() =>
+ Assert.Equal(FluidResistance.FromPascalMinutesPerCubicCentimeter(2), 2.PascalMinutesPerCubicCentimeter());
+
+ [Fact]
+ public void NumberToPascalMinutesPerCubicMeterTest() =>
+ Assert.Equal(FluidResistance.FromPascalMinutesPerCubicMeter(2), 2.PascalMinutesPerCubicMeter());
+
+ [Fact]
+ public void NumberToPascalMinutesPerLiterTest() =>
+ Assert.Equal(FluidResistance.FromPascalMinutesPerLiter(2), 2.PascalMinutesPerLiter());
+
+ [Fact]
+ public void NumberToPascalMinutesPerMilliliterTest() =>
+ Assert.Equal(FluidResistance.FromPascalMinutesPerMilliliter(2), 2.PascalMinutesPerMilliliter());
+
+ [Fact]
+ public void NumberToPascalSecondsPerCubicCentimeterTest() =>
+ Assert.Equal(FluidResistance.FromPascalSecondsPerCubicCentimeter(2), 2.PascalSecondsPerCubicCentimeter());
+
+ [Fact]
+ public void NumberToPascalSecondsPerCubicMeterTest() =>
+ Assert.Equal(FluidResistance.FromPascalSecondsPerCubicMeter(2), 2.PascalSecondsPerCubicMeter());
+
+ [Fact]
+ public void NumberToPascalSecondsPerLiterTest() =>
+ Assert.Equal(FluidResistance.FromPascalSecondsPerLiter(2), 2.PascalSecondsPerLiter());
+
+ [Fact]
+ public void NumberToPascalSecondsPerMilliliterTest() =>
+ Assert.Equal(FluidResistance.FromPascalSecondsPerMilliliter(2), 2.PascalSecondsPerMilliliter());
+
+ [Fact]
+ public void NumberToWoodUnitsTest() =>
+ Assert.Equal(FluidResistance.FromWoodUnits(2), 2.WoodUnits());
+
+ }
+}
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
new file mode 100644
index 0000000000..6b8d4a08db
--- /dev/null
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluidResistanceExtensions.g.cs
@@ -0,0 +1,188 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+#if NET7_0_OR_GREATER
+using System.Numerics;
+#endif
+
+#nullable enable
+
+namespace UnitsNet.NumberExtensions.NumberToFluidResistance
+{
+ ///
+ /// A number to FluidResistance Extensions
+ ///
+ public static class NumberToFluidResistanceExtensions
+ {
+ ///
+ public static FluidResistance DyneSecondsPerCentimeterToTheFifth(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MegapascalSecondsPerCubicMeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMegapascalSecondsPerCubicMeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercuryMinutesPerCubicCentimeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercuryMinutesPerCubicMeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercuryMinutesPerLiter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercuryMinutesPerLiter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercuryMinutesPerMilliliter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercurySecondsPerCubicCentimeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercurySecondsPerCubicMeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercurySecondsPerLiter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercurySecondsPerLiter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance MillimeterMercurySecondsPerMilliliter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalMinutesPerCubicCentimeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalMinutesPerCubicCentimeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalMinutesPerCubicMeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalMinutesPerCubicMeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalMinutesPerLiter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalMinutesPerLiter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalMinutesPerMilliliter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalMinutesPerMilliliter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalSecondsPerCubicCentimeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalSecondsPerCubicCentimeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalSecondsPerCubicMeter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalSecondsPerCubicMeter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalSecondsPerLiter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalSecondsPerLiter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance PascalSecondsPerMilliliter(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromPascalSecondsPerMilliliter(Convert.ToDouble(value));
+
+ ///
+ public static FluidResistance WoodUnits(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+#endif
+ => FluidResistance.FromWoodUnits(Convert.ToDouble(value));
+
+ }
+}
diff --git a/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs b/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs
new file mode 100644
index 0000000000..c0521d9c2e
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/FluidResistanceTests.cs
@@ -0,0 +1,49 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+
+namespace UnitsNet.Tests.CustomCode
+{
+ public class FluidResistanceTests : FluidResistanceTestsBase
+ {
+ // https://www.vcalc.com/wiki/Fluid-Resistance-Unit-Conversion
+
+ protected override bool SupportsSIUnitSystem => false;
+ protected override double DyneSecondsPerCentimeterToTheFifthInOnePascalSecondPerCubicMeter => 1e5; // dyn·s/cm⁵
+ protected override double MegapascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter => 1e-6; // MPa·s/m³
+ protected override double MillimeterMercuryMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter => 1.25010625903202e-10; // mmHg·min/cm³
+ protected override double MillimeterMercuryMinutesPerCubicMeterInOnePascalSecondPerCubicMeter => 1.25010625903202e-4; // mmHg·min/m³
+ protected override double MillimeterMercuryMinutesPerLiterInOnePascalSecondPerCubicMeter => 1.25010625903202e-7; // mmHg·min/l
+ protected override double MillimeterMercuryMinutesPerMilliliterInOnePascalSecondPerCubicMeter => 1.25010625903202e-10; // mmHg·min/ml
+ protected override double MillimeterMercurySecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter => 7.5006375541921e-9; // mmHg·s/cm³
+ protected override double MillimeterMercurySecondsPerCubicMeterInOnePascalSecondPerCubicMeter => 7.50063755419211e-3; // mmHg·s/m³
+ protected override double MillimeterMercurySecondsPerLiterInOnePascalSecondPerCubicMeter => 7.50063755419211e-6; // mmHg·s/l
+ protected override double MillimeterMercurySecondsPerMilliliterInOnePascalSecondPerCubicMeter => 7.5006375541921e-9; // mmHg·s/ml
+ protected override double PascalMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter => 1.66666666666667e-8; // Pa·min/cm³
+ protected override double PascalMinutesPerCubicMeterInOnePascalSecondPerCubicMeter => 1.66666666666667e-2; // Pa·min/m³
+ protected override double PascalMinutesPerLiterInOnePascalSecondPerCubicMeter => 1.66666666666667e-5; // Pa·min/l
+ protected override double PascalMinutesPerMilliliterInOnePascalSecondPerCubicMeter => 1.66666666666667e-8; // Pa·min/ml
+ protected override double PascalSecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter => 1e-6; // Pa·s/cm³
+ protected override double PascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter => 1; // Pa·s/m³
+ protected override double PascalSecondsPerLiterInOnePascalSecondPerCubicMeter => 1e-3; // Pa·s/l
+ protected override double PascalSecondsPerMilliliterInOnePascalSecondPerCubicMeter => 1e-6; // Pa·s/ml
+ protected override double WoodUnitsInOnePascalSecondPerCubicMeter => 1.25010625903202e-7; // WU
+ }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
index 0966041166..36f623126d 100644
--- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
@@ -81,6 +81,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
Assertion(3, EnergyUnit.WattHour, Quantity.From(3, EnergyUnit.WattHour));
Assertion(3, EnergyDensityUnit.WattHourPerCubicMeter, Quantity.From(3, EnergyDensityUnit.WattHourPerCubicMeter));
Assertion(3, EntropyUnit.MegajoulePerKelvin, Quantity.From(3, EntropyUnit.MegajoulePerKelvin));
+ Assertion(3, FluidResistanceUnit.WoodUnit, Quantity.From(3, FluidResistanceUnit.WoodUnit));
Assertion(3, ForceUnit.TonneForce, Quantity.From(3, ForceUnit.TonneForce));
Assertion(3, ForceChangeRateUnit.PoundForcePerSecond, Quantity.From(3, ForceChangeRateUnit.PoundForcePerSecond));
Assertion(3, ForcePerLengthUnit.TonneForcePerMillimeter, Quantity.From(3, ForcePerLengthUnit.TonneForcePerMillimeter));
@@ -222,6 +223,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty()
Assertion(Energy.Info, Energy.Zero);
Assertion(EnergyDensity.Info, EnergyDensity.Zero);
Assertion(Entropy.Info, Entropy.Zero);
+ Assertion(FluidResistance.Info, FluidResistance.Zero);
Assertion(Force.Info, Force.Zero);
Assertion(ForceChangeRate.Info, ForceChangeRate.Zero);
Assertion(ForcePerLength.Info, ForcePerLength.Zero);
@@ -363,6 +365,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions()
Assertion(Energy.BaseDimensions, Energy.Zero);
Assertion(EnergyDensity.BaseDimensions, EnergyDensity.Zero);
Assertion(Entropy.BaseDimensions, Entropy.Zero);
+ Assertion(FluidResistance.BaseDimensions, FluidResistance.Zero);
Assertion(Force.BaseDimensions, Force.Zero);
Assertion(ForceChangeRate.BaseDimensions, ForceChangeRate.Zero);
Assertion(ForcePerLength.BaseDimensions, ForcePerLength.Zero);
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs
new file mode 100644
index 0000000000..fb270794fb
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FluidResistanceTestsBase.g.cs
@@ -0,0 +1,1851 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by \generate-code.bat.
+//
+// Changes to this file will be lost when the code is regenerated.
+// The build server regenerates the code before each build and a pre-build
+// step will regenerate the code on each local build.
+//
+// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+//
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using UnitsNet.Tests.TestsBase;
+using UnitsNet.Units;
+using Xunit;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+ ///
+ /// Test of FluidResistance.
+ ///
+// ReSharper disable once PartialTypeWithSinglePart
+ public abstract partial class FluidResistanceTestsBase : QuantityTestsBase
+ {
+ protected abstract double DyneSecondsPerCentimeterToTheFifthInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MegapascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercuryMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercuryMinutesPerCubicMeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercuryMinutesPerLiterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercuryMinutesPerMilliliterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercurySecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercurySecondsPerCubicMeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercurySecondsPerLiterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double MillimeterMercurySecondsPerMilliliterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalMinutesPerCubicMeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalMinutesPerLiterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalMinutesPerMilliliterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalSecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalSecondsPerLiterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double PascalSecondsPerMilliliterInOnePascalSecondPerCubicMeter { get; }
+ protected abstract double WoodUnitsInOnePascalSecondPerCubicMeter { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+ protected virtual double DyneSecondsPerCentimeterToTheFifthTolerance { get { return 1e-5; } }
+ protected virtual double MegapascalSecondsPerCubicMeterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercuryMinutesPerCubicCentimeterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercuryMinutesPerCubicMeterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercuryMinutesPerLiterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercuryMinutesPerMilliliterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercurySecondsPerCubicCentimeterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercurySecondsPerCubicMeterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercurySecondsPerLiterTolerance { get { return 1e-5; } }
+ protected virtual double MillimeterMercurySecondsPerMilliliterTolerance { get { return 1e-5; } }
+ protected virtual double PascalMinutesPerCubicCentimeterTolerance { get { return 1e-5; } }
+ protected virtual double PascalMinutesPerCubicMeterTolerance { get { return 1e-5; } }
+ protected virtual double PascalMinutesPerLiterTolerance { get { return 1e-5; } }
+ protected virtual double PascalMinutesPerMilliliterTolerance { get { return 1e-5; } }
+ protected virtual double PascalSecondsPerCubicCentimeterTolerance { get { return 1e-5; } }
+ protected virtual double PascalSecondsPerCubicMeterTolerance { get { return 1e-5; } }
+ protected virtual double PascalSecondsPerLiterTolerance { get { return 1e-5; } }
+ protected virtual double PascalSecondsPerMilliliterTolerance { get { return 1e-5; } }
+ protected virtual double WoodUnitsTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+ protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(FluidResistanceUnit unit)
+ {
+ return unit switch
+ {
+ FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth => (DyneSecondsPerCentimeterToTheFifthInOnePascalSecondPerCubicMeter, DyneSecondsPerCentimeterToTheFifthTolerance),
+ FluidResistanceUnit.MegapascalSecondPerCubicMeter => (MegapascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter, MegapascalSecondsPerCubicMeterTolerance),
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter => (MillimeterMercuryMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter, MillimeterMercuryMinutesPerCubicCentimeterTolerance),
+ FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter => (MillimeterMercuryMinutesPerCubicMeterInOnePascalSecondPerCubicMeter, MillimeterMercuryMinutesPerCubicMeterTolerance),
+ FluidResistanceUnit.MillimeterMercuryMinutePerLiter => (MillimeterMercuryMinutesPerLiterInOnePascalSecondPerCubicMeter, MillimeterMercuryMinutesPerLiterTolerance),
+ FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter => (MillimeterMercuryMinutesPerMilliliterInOnePascalSecondPerCubicMeter, MillimeterMercuryMinutesPerMilliliterTolerance),
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter => (MillimeterMercurySecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter, MillimeterMercurySecondsPerCubicCentimeterTolerance),
+ FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter => (MillimeterMercurySecondsPerCubicMeterInOnePascalSecondPerCubicMeter, MillimeterMercurySecondsPerCubicMeterTolerance),
+ FluidResistanceUnit.MillimeterMercurySecondPerLiter => (MillimeterMercurySecondsPerLiterInOnePascalSecondPerCubicMeter, MillimeterMercurySecondsPerLiterTolerance),
+ FluidResistanceUnit.MillimeterMercurySecondPerMilliliter => (MillimeterMercurySecondsPerMilliliterInOnePascalSecondPerCubicMeter, MillimeterMercurySecondsPerMilliliterTolerance),
+ FluidResistanceUnit.PascalMinutePerCubicCentimeter => (PascalMinutesPerCubicCentimeterInOnePascalSecondPerCubicMeter, PascalMinutesPerCubicCentimeterTolerance),
+ FluidResistanceUnit.PascalMinutePerCubicMeter => (PascalMinutesPerCubicMeterInOnePascalSecondPerCubicMeter, PascalMinutesPerCubicMeterTolerance),
+ FluidResistanceUnit.PascalMinutePerLiter => (PascalMinutesPerLiterInOnePascalSecondPerCubicMeter, PascalMinutesPerLiterTolerance),
+ FluidResistanceUnit.PascalMinutePerMilliliter => (PascalMinutesPerMilliliterInOnePascalSecondPerCubicMeter, PascalMinutesPerMilliliterTolerance),
+ FluidResistanceUnit.PascalSecondPerCubicCentimeter => (PascalSecondsPerCubicCentimeterInOnePascalSecondPerCubicMeter, PascalSecondsPerCubicCentimeterTolerance),
+ FluidResistanceUnit.PascalSecondPerCubicMeter => (PascalSecondsPerCubicMeterInOnePascalSecondPerCubicMeter, PascalSecondsPerCubicMeterTolerance),
+ FluidResistanceUnit.PascalSecondPerLiter => (PascalSecondsPerLiterInOnePascalSecondPerCubicMeter, PascalSecondsPerLiterTolerance),
+ FluidResistanceUnit.PascalSecondPerMilliliter => (PascalSecondsPerMilliliterInOnePascalSecondPerCubicMeter, PascalSecondsPerMilliliterTolerance),
+ FluidResistanceUnit.WoodUnit => (WoodUnitsInOnePascalSecondPerCubicMeter, WoodUnitsTolerance),
+ _ => throw new NotSupportedException()
+ };
+ }
+
+ public static IEnumerable UnitTypes = new List
+ {
+ new object[] { FluidResistanceUnit.DyneSecondPerCentimeterToTheFifth },
+ new object[] { FluidResistanceUnit.MegapascalSecondPerCubicMeter },
+ new object[] { FluidResistanceUnit.MillimeterMercuryMinutePerCubicCentimeter },
+ new object[] { FluidResistanceUnit.MillimeterMercuryMinutePerCubicMeter },
+ new object[] { FluidResistanceUnit.MillimeterMercuryMinutePerLiter },
+ new object[] { FluidResistanceUnit.MillimeterMercuryMinutePerMilliliter },
+ new object[] { FluidResistanceUnit.MillimeterMercurySecondPerCubicCentimeter },
+ new object[] { FluidResistanceUnit.MillimeterMercurySecondPerCubicMeter },
+ new object[] { FluidResistanceUnit.MillimeterMercurySecondPerLiter },
+ new object[] { FluidResistanceUnit.MillimeterMercurySecondPerMilliliter },
+ new object[] { FluidResistanceUnit.PascalMinutePerCubicCentimeter },
+ new object[] { FluidResistanceUnit.PascalMinutePerCubicMeter },
+ new object[] { FluidResistanceUnit.PascalMinutePerLiter },
+ new object[] { FluidResistanceUnit.PascalMinutePerMilliliter },
+ new object[] { FluidResistanceUnit.PascalSecondPerCubicCentimeter },
+ new object[] { FluidResistanceUnit.PascalSecondPerCubicMeter },
+ new object[] { FluidResistanceUnit.PascalSecondPerLiter },
+ new object[] { FluidResistanceUnit.PascalSecondPerMilliliter },
+ new object[] { FluidResistanceUnit.WoodUnit },
+ };
+
+ [Fact]
+ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
+ {
+ var quantity = new FluidResistance();
+ Assert.Equal(0, quantity.Value);
+ Assert.Equal(FluidResistanceUnit.PascalSecondPerCubicMeter, quantity.Unit);
+ }
+
+ [Fact]
+ public void Ctor_WithInfinityValue_ThrowsArgumentException()
+ {
+ Assert.Throws(() => new FluidResistance(double.PositiveInfinity, FluidResistanceUnit.PascalSecondPerCubicMeter));
+ Assert.Throws(() => new FluidResistance(double.NegativeInfinity, FluidResistanceUnit.PascalSecondPerCubicMeter));
+ }
+
+ [Fact]
+ public void Ctor_WithNaNValue_ThrowsArgumentException()
+ {
+ Assert.Throws(() => new FluidResistance(double.NaN, FluidResistanceUnit.PascalSecondPerCubicMeter));
+ }
+
+ [Fact]
+ public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException()
+ {
+ Assert.Throws(() => new FluidResistance(value: 1, unitSystem: null));
+ }
+
+ //[Fact]
+ //public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
+ //{
+ // Func