diff --git a/Common/UnitDefinitions/Fluence.json b/Common/UnitDefinitions/Fluence.json new file mode 100644 index 0000000000..611d999243 --- /dev/null +++ b/Common/UnitDefinitions/Fluence.json @@ -0,0 +1,26 @@ +{ + "Name": "Fluence", + "BaseUnit": "NeutronPerSquareCentimeter", + "XmlDocSummary": "In nuclear physics, fluence is the time-integrated flux of particles (typically neutrons) passing through a unit area. It is commonly measured in neutrons per square centimeter (n/cm²) for reactor vessel wall exposure.", + "BaseDimensions": { + "L": -2 + }, + "Units": [ + { + "SingularName": "NeutronPerSquareCentimeter", + "PluralName": "NeutronsPerSquareCentimeter", + "BaseUnits": { + "L": "Centimeter" + }, + "XmlDocSummary": "The fluence of neutrons measured per square centimeter (n/cm²). Example: A reactor vessel may receive 6×10¹⁹ n/cm² over its lifetime.", + "FromUnitToBaseFunc": "{x}", + "FromBaseToUnitFunc": "{x}", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "n/cm²", "n·cm⁻²" ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Common/UnitDefinitions/Power.json b/Common/UnitDefinitions/Power.json index c850f494f2..a95844cc9c 100644 --- a/Common/UnitDefinitions/Power.json +++ b/Common/UnitDefinitions/Power.json @@ -26,6 +26,19 @@ } ] }, + { + "SingularName": "PascalCubicMeterPerSecond", + "PluralName": "PascalCubicMeterPerSecond", + "FromUnitToBaseFunc": "{x}", + "FromBaseToUnitFunc": "{x}", + "Prefixes": [ "Femto", "Pico", "Nano", "Micro", "Milli", "Deci", "Deca", "Kilo", "Mega", "Giga", "Tera", "Peta" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "Pa.m³/s" ] + } + ] + }, { "SingularName": "MechanicalHorsepower", "PluralName": "MechanicalHorsepower", diff --git a/Common/UnitDefinitions/Pressure.json b/Common/UnitDefinitions/Pressure.json index c5411d1cb9..3b750f2c71 100644 --- a/Common/UnitDefinitions/Pressure.json +++ b/Common/UnitDefinitions/Pressure.json @@ -30,6 +30,25 @@ } ] }, + { + "SingularName": "PascalG", + "PluralName": "PascalsG", + "XmlDocSummary": "The Pa(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 101325 Pa).", + "XmlDocRemarks": "https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure", + "FromUnitToBaseFunc": "{x} + 101325", + "FromBaseToUnitFunc": "{x} - 101325", + "Prefixes": [ "Micro", "Milli", "Deca", "Hecto", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "Pa(g)" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "Па(g)" ] + } + ] + }, { "SingularName": "Atmosphere", "PluralName": "Atmospheres", @@ -67,6 +86,25 @@ } ] }, + { + "SingularName": "BarG", + "PluralName": "BarsG", + "XmlDocSummary": "The bar(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 1.01325 bar).", + "XmlDocRemarks": "https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure", + "FromUnitToBaseFunc": "({x} * 1e5) + 101325", + "FromBaseToUnitFunc": "({x} - 101325) / 1e5", + "Prefixes": [ "Micro", "Milli", "Centi", "Deci", "Kilo", "Mega" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "bar(g)" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "бар(g)" ] + } + ] + }, { "SingularName": "KilogramForcePerSquareMeter", "PluralName": "KilogramsForcePerSquareMeter", diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index 3ebdc3d87d..8ce28c2ec0 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -1086,7 +1086,20 @@ "Picowatt": 24, "Terawatt": 25, "Watt": 26, - "TonOfRefrigeration": 29 + "TonOfRefrigeration": 29, + "DecapascalCubicMeterPerSecond": 35, + "DecipascalCubicMeterPerSecond": 36, + "FemtopascalCubicMeterPerSecond": 34, + "GigapascalCubicMeterPerSecond": 32, + "KilopascalCubicMeterPerSecond": 28, + "MegapascalCubicMeterPerSecond": 27, + "MicropascalCubicMeterPerSecond": 37, + "MillipascalCubicMeterPerSecond": 30, + "NanopascalCubicMeterPerSecond": 31, + "PascalCubicMeterPerSecond": 33, + "PetapascalCubicMeterPerSecond": 45, + "PicopascalCubicMeterPerSecond": 47, + "TerapascalCubicMeterPerSecond": 42 }, "PowerDensity": { "DecawattPerCubicFoot": 1, @@ -1188,7 +1201,22 @@ "Torr": 47, "MeterOfWaterColumn": 57, "CentimeterOfWaterColumn": 48, - "Millitorr": 52 + "Millitorr": 52, + "BarG": 53, + "CentibarG": 58, + "DecapascalG": 50, + "DecibarG": 55, + "GigapascalG": 54, + "HectopascalG": 59, + "KilobarG": 51, + "KilopascalG": 49, + "MegabarG": 60, + "MegapascalG": 56, + "MicrobarG": 67, + "MicropascalG": 65, + "MillibarG": 62, + "MillipascalG": 68, + "PascalG": 69 }, "PressureChangeRate": { "AtmospherePerSecond": 1, @@ -2018,5 +2046,8 @@ "SquareMeterKelvinPerKilowatt": 5, "SquareMeterKelvinPerWatt": 4, "SquareMillimeterKelvinPerWatt": 13 + }, + "Fluence": { + "NeutronPerSquareCentimeter": 4 } } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Fluence/Fluence.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Fluence/Fluence.nfproj new file mode 100644 index 0000000000..fec8b4b1f2 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Fluence/Fluence.nfproj @@ -0,0 +1,42 @@ + + + + $(MSBuildExtensionsPath)\nanoFramework\v1.0\ + + + + Debug + AnyCPU + {11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {2e4fbb82-e5b9-73cd-399b-0941478e1f53} + Library + Properties + 512 + UnitsNet + UnitsNet.Fluence + v1.0 + bin\$(Configuration)\$(AssemblyName).xml + + + + + + + + + + ..\packages\nanoFramework.CoreLibrary.1.15.5\lib\mscorlib.dll + True + True + + + + + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Fluence/UnitsNet.NanoFramework.Fluence.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Fluence/UnitsNet.NanoFramework.Fluence.nuspec new file mode 100644 index 0000000000..766d45a847 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Fluence/UnitsNet.NanoFramework.Fluence.nuspec @@ -0,0 +1,26 @@ + + + + UnitsNet.nanoFramework.Fluence + 6.0.0-pre019 + Units.NET Fluence - nanoFramework + Andreas Gullberg Larsen,nanoframework + UnitsNet + MIT-0 + https://github.com/angularsen/UnitsNet + false + Adds Fluence 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 fluence unit units quantity quantities measurement si metric imperial abbreviation abbreviations convert conversion parse immutable + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Fluence/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Fluence/packages.config new file mode 100644 index 0000000000..313a8dccdf --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Fluence/packages.config @@ -0,0 +1,4 @@ + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Fluence.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Fluence.g.cs new file mode 100644 index 0000000000..5ee3e3244f --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Fluence.g.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// 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 +{ + /// + /// + /// In nuclear physics, fluence is the time-integrated flux of particles (typically neutrons) passing through a unit area. It is commonly measured in neutrons per square centimeter (n/cm²) for reactor vessel wall exposure. + /// + public struct Fluence + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly FluenceUnit _unit; + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + /// + public FluenceUnit 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. + public Fluence(double value, FluenceUnit unit) + { + _value = value; + _unit = unit; + } + + /// + /// The base unit of Fluence, which is Second. All conversions go via this value. + /// + public static FluenceUnit BaseUnit { get; } = FluenceUnit.NeutronPerSquareCentimeter; + + /// + /// Represents the largest possible value of Fluence. + /// + public static Fluence MaxValue { get; } = new Fluence(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of Fluence. + /// + public static Fluence MinValue { get; } = new Fluence(double.MinValue, BaseUnit); + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit Second. + /// + public static Fluence Zero { get; } = new Fluence(0, BaseUnit); + #region Conversion Properties + + /// + /// Gets a value of this quantity converted into + /// + public double NeutronsPerSquareCentimeter => As(FluenceUnit.NeutronPerSquareCentimeter); + + #endregion + + #region Static Factory Methods + + /// + /// Creates a from . + /// + public static Fluence FromNeutronsPerSquareCentimeter(double neutronspersquarecentimeter) => new Fluence(neutronspersquarecentimeter, FluenceUnit.NeutronPerSquareCentimeter); + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Fluence unit value. + public static Fluence From(double value, FluenceUnit fromUnit) + { + return new Fluence(value, fromUnit); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(FluenceUnit unit) => GetValueAs(unit); + + /// + /// Converts this Fluence to another Fluence with the unit representation . + /// + /// A Fluence with the specified unit. + public Fluence ToUnit(FluenceUnit unit) + { + var convertedValue = GetValueAs(unit); + return new Fluence(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 + { + FluenceUnit.NeutronPerSquareCentimeter => _value, + _ => throw new NotImplementedException($"Can't convert {Unit} to base units.") + }; + } + + private double GetValueAs(FluenceUnit unit) + { + if (Unit == unit) + return _value; + + var baseUnitValue = GetValueInBaseUnit(); + + return unit switch + { + FluenceUnit.NeutronPerSquareCentimeter => baseUnitValue, + _ => throw new NotImplementedException($"Can't convert {Unit} to {unit}.") + }; + } + + #endregion + } +} + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs index d06e73550e..e845f38c7f 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Power.g.cs @@ -88,11 +88,21 @@ public Power(double value, PowerUnit unit) /// public double BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour); + /// + /// Gets a value of this quantity converted into + /// + public double DecapascalCubicMeterPerSecond => As(PowerUnit.DecapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Decawatts => As(PowerUnit.Decawatt); + /// + /// Gets a value of this quantity converted into + /// + public double DecipascalCubicMeterPerSecond => As(PowerUnit.DecipascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -103,6 +113,11 @@ public Power(double value, PowerUnit unit) /// public double ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower); + /// + /// Gets a value of this quantity converted into + /// + public double FemtopascalCubicMeterPerSecond => As(PowerUnit.FemtopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -113,6 +128,11 @@ public Power(double value, PowerUnit unit) /// public double GigajoulesPerHour => As(PowerUnit.GigajoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double GigapascalCubicMeterPerSecond => As(PowerUnit.GigapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -138,6 +158,11 @@ public Power(double value, PowerUnit unit) /// public double KilojoulesPerHour => As(PowerUnit.KilojoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double KilopascalCubicMeterPerSecond => As(PowerUnit.KilopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -158,6 +183,11 @@ public Power(double value, PowerUnit unit) /// public double MegajoulesPerHour => As(PowerUnit.MegajoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double MegapascalCubicMeterPerSecond => As(PowerUnit.MegapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -168,6 +198,11 @@ public Power(double value, PowerUnit unit) /// public double MetricHorsepower => As(PowerUnit.MetricHorsepower); + /// + /// Gets a value of this quantity converted into + /// + public double MicropascalCubicMeterPerSecond => As(PowerUnit.MicropascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -178,26 +213,56 @@ public Power(double value, PowerUnit unit) /// public double MillijoulesPerHour => As(PowerUnit.MillijoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double MillipascalCubicMeterPerSecond => As(PowerUnit.MillipascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Milliwatts => As(PowerUnit.Milliwatt); + /// + /// Gets a value of this quantity converted into + /// + public double NanopascalCubicMeterPerSecond => As(PowerUnit.NanopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Nanowatts => As(PowerUnit.Nanowatt); + /// + /// Gets a value of this quantity converted into + /// + public double PascalCubicMeterPerSecond => As(PowerUnit.PascalCubicMeterPerSecond); + + /// + /// Gets a value of this quantity converted into + /// + public double PetapascalCubicMeterPerSecond => As(PowerUnit.PetapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Petawatts => As(PowerUnit.Petawatt); + /// + /// Gets a value of this quantity converted into + /// + public double PicopascalCubicMeterPerSecond => As(PowerUnit.PicopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Picowatts => As(PowerUnit.Picowatt); + /// + /// Gets a value of this quantity converted into + /// + public double TerapascalCubicMeterPerSecond => As(PowerUnit.TerapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -227,11 +292,21 @@ public Power(double value, PowerUnit unit) /// public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsperhour) => new Power(britishthermalunitsperhour, PowerUnit.BritishThermalUnitPerHour); + /// + /// Creates a from . + /// + public static Power FromDecapascalCubicMeterPerSecond(double decapascalcubicmeterpersecond) => new Power(decapascalcubicmeterpersecond, PowerUnit.DecapascalCubicMeterPerSecond); + /// /// Creates a from . /// public static Power FromDecawatts(double decawatts) => new Power(decawatts, PowerUnit.Decawatt); + /// + /// Creates a from . + /// + public static Power FromDecipascalCubicMeterPerSecond(double decipascalcubicmeterpersecond) => new Power(decipascalcubicmeterpersecond, PowerUnit.DecipascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -242,6 +317,11 @@ public Power(double value, PowerUnit unit) /// public static Power FromElectricalHorsepower(double electricalhorsepower) => new Power(electricalhorsepower, PowerUnit.ElectricalHorsepower); + /// + /// Creates a from . + /// + public static Power FromFemtopascalCubicMeterPerSecond(double femtopascalcubicmeterpersecond) => new Power(femtopascalcubicmeterpersecond, PowerUnit.FemtopascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -252,6 +332,11 @@ public Power(double value, PowerUnit unit) /// public static Power FromGigajoulesPerHour(double gigajoulesperhour) => new Power(gigajoulesperhour, PowerUnit.GigajoulePerHour); + /// + /// Creates a from . + /// + public static Power FromGigapascalCubicMeterPerSecond(double gigapascalcubicmeterpersecond) => new Power(gigapascalcubicmeterpersecond, PowerUnit.GigapascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -277,6 +362,11 @@ public Power(double value, PowerUnit unit) /// public static Power FromKilojoulesPerHour(double kilojoulesperhour) => new Power(kilojoulesperhour, PowerUnit.KilojoulePerHour); + /// + /// Creates a from . + /// + public static Power FromKilopascalCubicMeterPerSecond(double kilopascalcubicmeterpersecond) => new Power(kilopascalcubicmeterpersecond, PowerUnit.KilopascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -297,6 +387,11 @@ public Power(double value, PowerUnit unit) /// public static Power FromMegajoulesPerHour(double megajoulesperhour) => new Power(megajoulesperhour, PowerUnit.MegajoulePerHour); + /// + /// Creates a from . + /// + public static Power FromMegapascalCubicMeterPerSecond(double megapascalcubicmeterpersecond) => new Power(megapascalcubicmeterpersecond, PowerUnit.MegapascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -307,6 +402,11 @@ public Power(double value, PowerUnit unit) /// public static Power FromMetricHorsepower(double metrichorsepower) => new Power(metrichorsepower, PowerUnit.MetricHorsepower); + /// + /// Creates a from . + /// + public static Power FromMicropascalCubicMeterPerSecond(double micropascalcubicmeterpersecond) => new Power(micropascalcubicmeterpersecond, PowerUnit.MicropascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -317,26 +417,56 @@ public Power(double value, PowerUnit unit) /// public static Power FromMillijoulesPerHour(double millijoulesperhour) => new Power(millijoulesperhour, PowerUnit.MillijoulePerHour); + /// + /// Creates a from . + /// + public static Power FromMillipascalCubicMeterPerSecond(double millipascalcubicmeterpersecond) => new Power(millipascalcubicmeterpersecond, PowerUnit.MillipascalCubicMeterPerSecond); + /// /// Creates a from . /// public static Power FromMilliwatts(double milliwatts) => new Power(milliwatts, PowerUnit.Milliwatt); + /// + /// Creates a from . + /// + public static Power FromNanopascalCubicMeterPerSecond(double nanopascalcubicmeterpersecond) => new Power(nanopascalcubicmeterpersecond, PowerUnit.NanopascalCubicMeterPerSecond); + /// /// Creates a from . /// public static Power FromNanowatts(double nanowatts) => new Power(nanowatts, PowerUnit.Nanowatt); + /// + /// Creates a from . + /// + public static Power FromPascalCubicMeterPerSecond(double pascalcubicmeterpersecond) => new Power(pascalcubicmeterpersecond, PowerUnit.PascalCubicMeterPerSecond); + + /// + /// Creates a from . + /// + public static Power FromPetapascalCubicMeterPerSecond(double petapascalcubicmeterpersecond) => new Power(petapascalcubicmeterpersecond, PowerUnit.PetapascalCubicMeterPerSecond); + /// /// Creates a from . /// public static Power FromPetawatts(double petawatts) => new Power(petawatts, PowerUnit.Petawatt); + /// + /// Creates a from . + /// + public static Power FromPicopascalCubicMeterPerSecond(double picopascalcubicmeterpersecond) => new Power(picopascalcubicmeterpersecond, PowerUnit.PicopascalCubicMeterPerSecond); + /// /// Creates a from . /// public static Power FromPicowatts(double picowatts) => new Power(picowatts, PowerUnit.Picowatt); + /// + /// Creates a from . + /// + public static Power FromTerapascalCubicMeterPerSecond(double terapascalcubicmeterpersecond) => new Power(terapascalcubicmeterpersecond, PowerUnit.TerapascalCubicMeterPerSecond); + /// /// Creates a from . /// @@ -394,28 +524,41 @@ private double GetValueInBaseUnit() { PowerUnit.BoilerHorsepower => _value * 9812.5, PowerUnit.BritishThermalUnitPerHour => _value * 1055.05585262 / 3600, + PowerUnit.DecapascalCubicMeterPerSecond => (_value) * 1e1d, PowerUnit.Decawatt => (_value) * 1e1d, + PowerUnit.DecipascalCubicMeterPerSecond => (_value) * 1e-1d, PowerUnit.Deciwatt => (_value) * 1e-1d, PowerUnit.ElectricalHorsepower => _value * 746, + PowerUnit.FemtopascalCubicMeterPerSecond => (_value) * 1e-15d, PowerUnit.Femtowatt => (_value) * 1e-15d, PowerUnit.GigajoulePerHour => (_value / 3600) * 1e9d, + PowerUnit.GigapascalCubicMeterPerSecond => (_value) * 1e9d, PowerUnit.Gigawatt => (_value) * 1e9d, PowerUnit.HydraulicHorsepower => _value * 745.69987158227022, PowerUnit.JoulePerHour => _value / 3600, PowerUnit.KilobritishThermalUnitPerHour => (_value * 1055.05585262 / 3600) * 1e3d, PowerUnit.KilojoulePerHour => (_value / 3600) * 1e3d, + PowerUnit.KilopascalCubicMeterPerSecond => (_value) * 1e3d, PowerUnit.Kilowatt => (_value) * 1e3d, PowerUnit.MechanicalHorsepower => _value * 76.0402249 * 9.80665, PowerUnit.MegabritishThermalUnitPerHour => (_value * 1055.05585262 / 3600) * 1e6d, PowerUnit.MegajoulePerHour => (_value / 3600) * 1e6d, + PowerUnit.MegapascalCubicMeterPerSecond => (_value) * 1e6d, PowerUnit.Megawatt => (_value) * 1e6d, PowerUnit.MetricHorsepower => _value * 75 * 9.80665, + PowerUnit.MicropascalCubicMeterPerSecond => (_value) * 1e-6d, PowerUnit.Microwatt => (_value) * 1e-6d, PowerUnit.MillijoulePerHour => (_value / 3600) * 1e-3d, + PowerUnit.MillipascalCubicMeterPerSecond => (_value) * 1e-3d, PowerUnit.Milliwatt => (_value) * 1e-3d, + PowerUnit.NanopascalCubicMeterPerSecond => (_value) * 1e-9d, PowerUnit.Nanowatt => (_value) * 1e-9d, + PowerUnit.PascalCubicMeterPerSecond => _value, + PowerUnit.PetapascalCubicMeterPerSecond => (_value) * 1e15d, PowerUnit.Petawatt => (_value) * 1e15d, + PowerUnit.PicopascalCubicMeterPerSecond => (_value) * 1e-12d, PowerUnit.Picowatt => (_value) * 1e-12d, + PowerUnit.TerapascalCubicMeterPerSecond => (_value) * 1e12d, PowerUnit.Terawatt => (_value) * 1e12d, PowerUnit.TonOfRefrigeration => _value * 3516.853, PowerUnit.Watt => _value, @@ -434,28 +577,41 @@ private double GetValueAs(PowerUnit unit) { PowerUnit.BoilerHorsepower => baseUnitValue / 9812.5, PowerUnit.BritishThermalUnitPerHour => baseUnitValue * 3600 / 1055.05585262, + PowerUnit.DecapascalCubicMeterPerSecond => (baseUnitValue) / 1e1d, PowerUnit.Decawatt => (baseUnitValue) / 1e1d, + PowerUnit.DecipascalCubicMeterPerSecond => (baseUnitValue) / 1e-1d, PowerUnit.Deciwatt => (baseUnitValue) / 1e-1d, PowerUnit.ElectricalHorsepower => baseUnitValue / 746, + PowerUnit.FemtopascalCubicMeterPerSecond => (baseUnitValue) / 1e-15d, PowerUnit.Femtowatt => (baseUnitValue) / 1e-15d, PowerUnit.GigajoulePerHour => (baseUnitValue * 3600) / 1e9d, + PowerUnit.GigapascalCubicMeterPerSecond => (baseUnitValue) / 1e9d, PowerUnit.Gigawatt => (baseUnitValue) / 1e9d, PowerUnit.HydraulicHorsepower => baseUnitValue / 745.69987158227022, PowerUnit.JoulePerHour => baseUnitValue * 3600, PowerUnit.KilobritishThermalUnitPerHour => (baseUnitValue * 3600 / 1055.05585262) / 1e3d, PowerUnit.KilojoulePerHour => (baseUnitValue * 3600) / 1e3d, + PowerUnit.KilopascalCubicMeterPerSecond => (baseUnitValue) / 1e3d, PowerUnit.Kilowatt => (baseUnitValue) / 1e3d, PowerUnit.MechanicalHorsepower => baseUnitValue / (76.0402249 * 9.80665), PowerUnit.MegabritishThermalUnitPerHour => (baseUnitValue * 3600 / 1055.05585262) / 1e6d, PowerUnit.MegajoulePerHour => (baseUnitValue * 3600) / 1e6d, + PowerUnit.MegapascalCubicMeterPerSecond => (baseUnitValue) / 1e6d, PowerUnit.Megawatt => (baseUnitValue) / 1e6d, PowerUnit.MetricHorsepower => baseUnitValue / (75 * 9.80665), + PowerUnit.MicropascalCubicMeterPerSecond => (baseUnitValue) / 1e-6d, PowerUnit.Microwatt => (baseUnitValue) / 1e-6d, PowerUnit.MillijoulePerHour => (baseUnitValue * 3600) / 1e-3d, + PowerUnit.MillipascalCubicMeterPerSecond => (baseUnitValue) / 1e-3d, PowerUnit.Milliwatt => (baseUnitValue) / 1e-3d, + PowerUnit.NanopascalCubicMeterPerSecond => (baseUnitValue) / 1e-9d, PowerUnit.Nanowatt => (baseUnitValue) / 1e-9d, + PowerUnit.PascalCubicMeterPerSecond => baseUnitValue, + PowerUnit.PetapascalCubicMeterPerSecond => (baseUnitValue) / 1e15d, PowerUnit.Petawatt => (baseUnitValue) / 1e15d, + PowerUnit.PicopascalCubicMeterPerSecond => (baseUnitValue) / 1e-12d, PowerUnit.Picowatt => (baseUnitValue) / 1e-12d, + PowerUnit.TerapascalCubicMeterPerSecond => (baseUnitValue) / 1e12d, PowerUnit.Terawatt => (baseUnitValue) / 1e12d, PowerUnit.TonOfRefrigeration => baseUnitValue / 3516.853, PowerUnit.Watt => baseUnitValue, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs index 84fa430f11..3bdc4d09c2 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Pressure.g.cs @@ -88,11 +88,21 @@ public Pressure(double value, PressureUnit unit) /// public double Bars => As(PressureUnit.Bar); + /// + /// Gets a value of this quantity converted into + /// + public double BarsG => As(PressureUnit.BarG); + /// /// Gets a value of this quantity converted into /// public double Centibars => As(PressureUnit.Centibar); + /// + /// Gets a value of this quantity converted into + /// + public double CentibarsG => As(PressureUnit.CentibarG); + /// /// Gets a value of this quantity converted into /// @@ -103,11 +113,21 @@ public Pressure(double value, PressureUnit unit) /// public double Decapascals => As(PressureUnit.Decapascal); + /// + /// Gets a value of this quantity converted into + /// + public double DecapascalsG => As(PressureUnit.DecapascalG); + /// /// Gets a value of this quantity converted into /// public double Decibars => As(PressureUnit.Decibar); + /// + /// Gets a value of this quantity converted into + /// + public double DecibarsG => As(PressureUnit.DecibarG); + /// /// Gets a value of this quantity converted into /// @@ -123,11 +143,21 @@ public Pressure(double value, PressureUnit unit) /// public double Gigapascals => As(PressureUnit.Gigapascal); + /// + /// Gets a value of this quantity converted into + /// + public double GigapascalsG => As(PressureUnit.GigapascalG); + /// /// Gets a value of this quantity converted into /// public double Hectopascals => As(PressureUnit.Hectopascal); + /// + /// Gets a value of this quantity converted into + /// + public double HectopascalsG => As(PressureUnit.HectopascalG); + /// /// Gets a value of this quantity converted into /// @@ -143,6 +173,11 @@ public Pressure(double value, PressureUnit unit) /// public double Kilobars => As(PressureUnit.Kilobar); + /// + /// Gets a value of this quantity converted into + /// + public double KilobarsG => As(PressureUnit.KilobarG); + /// /// Gets a value of this quantity converted into /// @@ -178,6 +213,11 @@ public Pressure(double value, PressureUnit unit) /// public double Kilopascals => As(PressureUnit.Kilopascal); + /// + /// Gets a value of this quantity converted into + /// + public double KilopascalsG => As(PressureUnit.KilopascalG); + /// /// Gets a value of this quantity converted into /// @@ -198,6 +238,11 @@ public Pressure(double value, PressureUnit unit) /// public double Megabars => As(PressureUnit.Megabar); + /// + /// Gets a value of this quantity converted into + /// + public double MegabarsG => As(PressureUnit.MegabarG); + /// /// Gets a value of this quantity converted into /// @@ -208,6 +253,11 @@ public Pressure(double value, PressureUnit unit) /// public double Megapascals => As(PressureUnit.Megapascal); + /// + /// Gets a value of this quantity converted into + /// + public double MegapascalsG => As(PressureUnit.MegapascalG); + /// /// Gets a value of this quantity converted into /// @@ -223,16 +273,31 @@ public Pressure(double value, PressureUnit unit) /// public double Microbars => As(PressureUnit.Microbar); + /// + /// Gets a value of this quantity converted into + /// + public double MicrobarsG => As(PressureUnit.MicrobarG); + /// /// Gets a value of this quantity converted into /// public double Micropascals => As(PressureUnit.Micropascal); + /// + /// Gets a value of this quantity converted into + /// + public double MicropascalsG => As(PressureUnit.MicropascalG); + /// /// Gets a value of this quantity converted into /// public double Millibars => As(PressureUnit.Millibar); + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsG => As(PressureUnit.MillibarG); + /// /// Gets a value of this quantity converted into /// @@ -248,6 +313,11 @@ public Pressure(double value, PressureUnit unit) /// public double Millipascals => As(PressureUnit.Millipascal); + /// + /// Gets a value of this quantity converted into + /// + public double MillipascalsG => As(PressureUnit.MillipascalG); + /// /// Gets a value of this quantity converted into /// @@ -273,6 +343,11 @@ public Pressure(double value, PressureUnit unit) /// public double Pascals => As(PressureUnit.Pascal); + /// + /// Gets a value of this quantity converted into + /// + public double PascalsG => As(PressureUnit.PascalG); + /// /// Gets a value of this quantity converted into /// @@ -332,11 +407,21 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromBars(double bars) => new Pressure(bars, PressureUnit.Bar); + /// + /// Creates a from . + /// + public static Pressure FromBarsG(double barsg) => new Pressure(barsg, PressureUnit.BarG); + /// /// Creates a from . /// public static Pressure FromCentibars(double centibars) => new Pressure(centibars, PressureUnit.Centibar); + /// + /// Creates a from . + /// + public static Pressure FromCentibarsG(double centibarsg) => new Pressure(centibarsg, PressureUnit.CentibarG); + /// /// Creates a from . /// @@ -347,11 +432,21 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromDecapascals(double decapascals) => new Pressure(decapascals, PressureUnit.Decapascal); + /// + /// Creates a from . + /// + public static Pressure FromDecapascalsG(double decapascalsg) => new Pressure(decapascalsg, PressureUnit.DecapascalG); + /// /// Creates a from . /// public static Pressure FromDecibars(double decibars) => new Pressure(decibars, PressureUnit.Decibar); + /// + /// Creates a from . + /// + public static Pressure FromDecibarsG(double decibarsg) => new Pressure(decibarsg, PressureUnit.DecibarG); + /// /// Creates a from . /// @@ -367,11 +462,21 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromGigapascals(double gigapascals) => new Pressure(gigapascals, PressureUnit.Gigapascal); + /// + /// Creates a from . + /// + public static Pressure FromGigapascalsG(double gigapascalsg) => new Pressure(gigapascalsg, PressureUnit.GigapascalG); + /// /// Creates a from . /// public static Pressure FromHectopascals(double hectopascals) => new Pressure(hectopascals, PressureUnit.Hectopascal); + /// + /// Creates a from . + /// + public static Pressure FromHectopascalsG(double hectopascalsg) => new Pressure(hectopascalsg, PressureUnit.HectopascalG); + /// /// Creates a from . /// @@ -387,6 +492,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromKilobars(double kilobars) => new Pressure(kilobars, PressureUnit.Kilobar); + /// + /// Creates a from . + /// + public static Pressure FromKilobarsG(double kilobarsg) => new Pressure(kilobarsg, PressureUnit.KilobarG); + /// /// Creates a from . /// @@ -422,6 +532,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromKilopascals(double kilopascals) => new Pressure(kilopascals, PressureUnit.Kilopascal); + /// + /// Creates a from . + /// + public static Pressure FromKilopascalsG(double kilopascalsg) => new Pressure(kilopascalsg, PressureUnit.KilopascalG); + /// /// Creates a from . /// @@ -442,6 +557,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromMegabars(double megabars) => new Pressure(megabars, PressureUnit.Megabar); + /// + /// Creates a from . + /// + public static Pressure FromMegabarsG(double megabarsg) => new Pressure(megabarsg, PressureUnit.MegabarG); + /// /// Creates a from . /// @@ -452,6 +572,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromMegapascals(double megapascals) => new Pressure(megapascals, PressureUnit.Megapascal); + /// + /// Creates a from . + /// + public static Pressure FromMegapascalsG(double megapascalsg) => new Pressure(megapascalsg, PressureUnit.MegapascalG); + /// /// Creates a from . /// @@ -467,16 +592,31 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromMicrobars(double microbars) => new Pressure(microbars, PressureUnit.Microbar); + /// + /// Creates a from . + /// + public static Pressure FromMicrobarsG(double microbarsg) => new Pressure(microbarsg, PressureUnit.MicrobarG); + /// /// Creates a from . /// public static Pressure FromMicropascals(double micropascals) => new Pressure(micropascals, PressureUnit.Micropascal); + /// + /// Creates a from . + /// + public static Pressure FromMicropascalsG(double micropascalsg) => new Pressure(micropascalsg, PressureUnit.MicropascalG); + /// /// Creates a from . /// public static Pressure FromMillibars(double millibars) => new Pressure(millibars, PressureUnit.Millibar); + /// + /// Creates a from . + /// + public static Pressure FromMillibarsG(double millibarsg) => new Pressure(millibarsg, PressureUnit.MillibarG); + /// /// Creates a from . /// @@ -492,6 +632,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromMillipascals(double millipascals) => new Pressure(millipascals, PressureUnit.Millipascal); + /// + /// Creates a from . + /// + public static Pressure FromMillipascalsG(double millipascalsg) => new Pressure(millipascalsg, PressureUnit.MillipascalG); + /// /// Creates a from . /// @@ -517,6 +662,11 @@ public Pressure(double value, PressureUnit unit) /// public static Pressure FromPascals(double pascals) => new Pressure(pascals, PressureUnit.Pascal); + /// + /// Creates a from . + /// + public static Pressure FromPascalsG(double pascalsg) => new Pressure(pascalsg, PressureUnit.PascalG); + /// /// Creates a from . /// @@ -604,17 +754,24 @@ private double GetValueInBaseUnit() { PressureUnit.Atmosphere => _value * 1.01325 * 1e5, PressureUnit.Bar => _value * 1e5, + PressureUnit.BarG => (_value * 1e5) + 101325, PressureUnit.Centibar => (_value * 1e5) * 1e-2d, + PressureUnit.CentibarG => ((_value * 1e5) + 101325) * 1e-2d, PressureUnit.CentimeterOfWaterColumn => (_value * 9.80665e3) * 1e-2d, PressureUnit.Decapascal => (_value) * 1e1d, + PressureUnit.DecapascalG => (_value + 101325) * 1e1d, PressureUnit.Decibar => (_value * 1e5) * 1e-1d, + PressureUnit.DecibarG => ((_value * 1e5) + 101325) * 1e-1d, PressureUnit.DynePerSquareCentimeter => _value * 1.0e-1, PressureUnit.FootOfHead => _value * 9804.139432 * 0.3048, PressureUnit.Gigapascal => (_value) * 1e9d, + PressureUnit.GigapascalG => (_value + 101325) * 1e9d, PressureUnit.Hectopascal => (_value) * 1e2d, + PressureUnit.HectopascalG => (_value + 101325) * 1e2d, PressureUnit.InchOfMercury => _value * 2.54e1 * 133.322387415, PressureUnit.InchOfWaterColumn => _value * 2.54e-2 * 9.80665e3, PressureUnit.Kilobar => (_value * 1e5) * 1e3d, + PressureUnit.KilobarG => ((_value * 1e5) + 101325) * 1e3d, PressureUnit.KilogramForcePerSquareCentimeter => _value * 9.80665e4, PressureUnit.KilogramForcePerSquareMeter => _value * 9.80665, PressureUnit.KilogramForcePerSquareMillimeter => _value * 9.80665e6, @@ -622,25 +779,33 @@ private double GetValueInBaseUnit() PressureUnit.KilonewtonPerSquareMeter => (_value) * 1e3d, PressureUnit.KilonewtonPerSquareMillimeter => (_value * 1e6) * 1e3d, PressureUnit.Kilopascal => (_value) * 1e3d, + PressureUnit.KilopascalG => (_value + 101325) * 1e3d, PressureUnit.KilopoundForcePerSquareFoot => (_value * 4.4482216152605 / 9.290304e-2) * 1e3d, PressureUnit.KilopoundForcePerSquareInch => (_value * 4.4482216152605 / 0.00064516) * 1e3d, PressureUnit.KilopoundForcePerSquareMil => (_value * 4.4482216152605 / (2.54e-5 * 2.54e-5)) * 1e3d, PressureUnit.Megabar => (_value * 1e5) * 1e6d, + PressureUnit.MegabarG => ((_value * 1e5) + 101325) * 1e6d, PressureUnit.MeganewtonPerSquareMeter => (_value) * 1e6d, PressureUnit.Megapascal => (_value) * 1e6d, + PressureUnit.MegapascalG => (_value + 101325) * 1e6d, PressureUnit.MeterOfHead => _value * 9804.139432, PressureUnit.MeterOfWaterColumn => _value * 9.80665e3, PressureUnit.Microbar => (_value * 1e5) * 1e-6d, + PressureUnit.MicrobarG => ((_value * 1e5) + 101325) * 1e-6d, PressureUnit.Micropascal => (_value) * 1e-6d, + PressureUnit.MicropascalG => (_value + 101325) * 1e-6d, PressureUnit.Millibar => (_value * 1e5) * 1e-3d, + PressureUnit.MillibarG => ((_value * 1e5) + 101325) * 1e-3d, PressureUnit.MillimeterOfMercury => _value * 133.322387415, PressureUnit.MillimeterOfWaterColumn => (_value * 9.80665e3) * 1e-3d, PressureUnit.Millipascal => (_value) * 1e-3d, + PressureUnit.MillipascalG => (_value + 101325) * 1e-3d, PressureUnit.Millitorr => (_value * 101325 / 760) * 1e-3d, PressureUnit.NewtonPerSquareCentimeter => _value * 1e4, PressureUnit.NewtonPerSquareMeter => _value, PressureUnit.NewtonPerSquareMillimeter => _value * 1e6, PressureUnit.Pascal => _value, + PressureUnit.PascalG => _value + 101325, PressureUnit.PoundForcePerSquareFoot => _value * 4.4482216152605 / 9.290304e-2, PressureUnit.PoundForcePerSquareInch => _value * 4.4482216152605 / 0.00064516, PressureUnit.PoundForcePerSquareMil => _value * 4.4482216152605 / (2.54e-5 * 2.54e-5), @@ -665,17 +830,24 @@ private double GetValueAs(PressureUnit unit) { PressureUnit.Atmosphere => baseUnitValue / (1.01325 * 1e5), PressureUnit.Bar => baseUnitValue / 1e5, + PressureUnit.BarG => (baseUnitValue - 101325) / 1e5, PressureUnit.Centibar => (baseUnitValue / 1e5) / 1e-2d, + PressureUnit.CentibarG => ((baseUnitValue - 101325) / 1e5) / 1e-2d, PressureUnit.CentimeterOfWaterColumn => (baseUnitValue / 9.80665e3) / 1e-2d, PressureUnit.Decapascal => (baseUnitValue) / 1e1d, + PressureUnit.DecapascalG => (baseUnitValue - 101325) / 1e1d, PressureUnit.Decibar => (baseUnitValue / 1e5) / 1e-1d, + PressureUnit.DecibarG => ((baseUnitValue - 101325) / 1e5) / 1e-1d, PressureUnit.DynePerSquareCentimeter => baseUnitValue / 1.0e-1, PressureUnit.FootOfHead => baseUnitValue / (9804.139432 * 0.3048), PressureUnit.Gigapascal => (baseUnitValue) / 1e9d, + PressureUnit.GigapascalG => (baseUnitValue - 101325) / 1e9d, PressureUnit.Hectopascal => (baseUnitValue) / 1e2d, + PressureUnit.HectopascalG => (baseUnitValue - 101325) / 1e2d, PressureUnit.InchOfMercury => baseUnitValue / (2.54e1 * 133.322387415), PressureUnit.InchOfWaterColumn => baseUnitValue / (2.54e-2 * 9.80665e3), PressureUnit.Kilobar => (baseUnitValue / 1e5) / 1e3d, + PressureUnit.KilobarG => ((baseUnitValue - 101325) / 1e5) / 1e3d, PressureUnit.KilogramForcePerSquareCentimeter => baseUnitValue / 9.80665e4, PressureUnit.KilogramForcePerSquareMeter => baseUnitValue / 9.80665, PressureUnit.KilogramForcePerSquareMillimeter => baseUnitValue / 9.80665e6, @@ -683,25 +855,33 @@ private double GetValueAs(PressureUnit unit) PressureUnit.KilonewtonPerSquareMeter => (baseUnitValue) / 1e3d, PressureUnit.KilonewtonPerSquareMillimeter => (baseUnitValue / 1e6) / 1e3d, PressureUnit.Kilopascal => (baseUnitValue) / 1e3d, + PressureUnit.KilopascalG => (baseUnitValue - 101325) / 1e3d, PressureUnit.KilopoundForcePerSquareFoot => (baseUnitValue * 9.290304e-2 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareInch => (baseUnitValue * 0.00064516 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareMil => (baseUnitValue * (2.54e-5 * 2.54e-5) / 4.4482216152605) / 1e3d, PressureUnit.Megabar => (baseUnitValue / 1e5) / 1e6d, + PressureUnit.MegabarG => ((baseUnitValue - 101325) / 1e5) / 1e6d, PressureUnit.MeganewtonPerSquareMeter => (baseUnitValue) / 1e6d, PressureUnit.Megapascal => (baseUnitValue) / 1e6d, + PressureUnit.MegapascalG => (baseUnitValue - 101325) / 1e6d, PressureUnit.MeterOfHead => baseUnitValue / 9804.139432, PressureUnit.MeterOfWaterColumn => baseUnitValue / 9.80665e3, PressureUnit.Microbar => (baseUnitValue / 1e5) / 1e-6d, + PressureUnit.MicrobarG => ((baseUnitValue - 101325) / 1e5) / 1e-6d, PressureUnit.Micropascal => (baseUnitValue) / 1e-6d, + PressureUnit.MicropascalG => (baseUnitValue - 101325) / 1e-6d, PressureUnit.Millibar => (baseUnitValue / 1e5) / 1e-3d, + PressureUnit.MillibarG => ((baseUnitValue - 101325) / 1e5) / 1e-3d, PressureUnit.MillimeterOfMercury => baseUnitValue / 133.322387415, PressureUnit.MillimeterOfWaterColumn => (baseUnitValue / 9.80665e3) / 1e-3d, PressureUnit.Millipascal => (baseUnitValue) / 1e-3d, + PressureUnit.MillipascalG => (baseUnitValue - 101325) / 1e-3d, PressureUnit.Millitorr => (baseUnitValue * 760 / 101325) / 1e-3d, PressureUnit.NewtonPerSquareCentimeter => baseUnitValue / 1e4, PressureUnit.NewtonPerSquareMeter => baseUnitValue, PressureUnit.NewtonPerSquareMillimeter => baseUnitValue / 1e6, PressureUnit.Pascal => baseUnitValue, + PressureUnit.PascalG => baseUnitValue - 101325, PressureUnit.PoundForcePerSquareFoot => baseUnitValue * 9.290304e-2 / 4.4482216152605, PressureUnit.PoundForcePerSquareInch => baseUnitValue * 0.00064516 / 4.4482216152605, PressureUnit.PoundForcePerSquareMil => baseUnitValue * (2.54e-5 * 2.54e-5) / 4.4482216152605, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/FluenceUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/FluenceUnit.g.cs new file mode 100644 index 0000000000..a8b57011a2 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/FluenceUnit.g.cs @@ -0,0 +1,36 @@ +//------------------------------------------------------------------------------ +// +// 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 FluenceUnit + { + + /// + /// The fluence of neutrons measured per square centimeter (n/cm²). Example: A reactor vessel may receive 6×10¹⁹ n/cm² over its lifetime. + /// + NeutronPerSquareCentimeter = 4, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs index c0ddfe10ec..d973798ad1 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/PowerUnit.g.cs @@ -33,7 +33,9 @@ public enum PowerUnit BoilerHorsepower = 1, /// Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details. BritishThermalUnitPerHour = 2, + DecapascalCubicMeterPerSecond = 35, Decawatt = 3, + DecipascalCubicMeterPerSecond = 36, Deciwatt = 4, /// @@ -41,8 +43,10 @@ public enum PowerUnit /// /// https://en.wikipedia.org/wiki/Horsepower#Electrical_horsepower ElectricalHorsepower = 5, + FemtopascalCubicMeterPerSecond = 34, Femtowatt = 6, GigajoulePerHour = 7, + GigapascalCubicMeterPerSecond = 32, Gigawatt = 8, /// @@ -53,6 +57,7 @@ public enum PowerUnit JoulePerHour = 10, KilobritishThermalUnitPerHour = 11, KilojoulePerHour = 12, + KilopascalCubicMeterPerSecond = 28, Kilowatt = 13, /// @@ -62,6 +67,7 @@ public enum PowerUnit MechanicalHorsepower = 14, MegabritishThermalUnitPerHour = 15, MegajoulePerHour = 16, + MegapascalCubicMeterPerSecond = 27, Megawatt = 17, /// @@ -69,12 +75,19 @@ public enum PowerUnit /// /// https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower_(PS,_KM,_cv,_hk,_pk,_k,_ks,_ch) MetricHorsepower = 18, + MicropascalCubicMeterPerSecond = 37, Microwatt = 19, MillijoulePerHour = 20, + MillipascalCubicMeterPerSecond = 30, Milliwatt = 21, + NanopascalCubicMeterPerSecond = 31, Nanowatt = 22, + PascalCubicMeterPerSecond = 33, + PetapascalCubicMeterPerSecond = 45, Petawatt = 23, + PicopascalCubicMeterPerSecond = 47, Picowatt = 24, + TerapascalCubicMeterPerSecond = 42, Terawatt = 25, TonOfRefrigeration = 29, Watt = 26, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs index dbcff54072..87ef37ec0d 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureUnit.g.cs @@ -37,14 +37,25 @@ public enum PressureUnit /// /// https://en.wikipedia.org/wiki/Bar_(unit) Bar = 2, + + /// + /// The bar(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 1.01325 bar). + /// + /// https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure + BarG = 53, Centibar = 3, + CentibarG = 58, CentimeterOfWaterColumn = 48, Decapascal = 4, + DecapascalG = 50, Decibar = 5, + DecibarG = 55, DynePerSquareCentimeter = 6, FootOfHead = 8, Gigapascal = 9, + GigapascalG = 54, Hectopascal = 10, + HectopascalG = 59, /// /// Inch of mercury (inHg and ″Hg) is a non-SI unit of measurement for pressure. It is used for barometric pressure in weather reports, refrigeration and aviation in the United States. It is the pressure exerted by a column of mercury 1 inch (25.4 mm) in height at the standard acceleration of gravity. @@ -58,6 +69,7 @@ public enum PressureUnit /// https://en.wikipedia.org/wiki/Inch_of_water InchOfWaterColumn = 12, Kilobar = 13, + KilobarG = 51, /// /// A kilogram-force per centimetre square (kgf/cm2), often just kilogram per square centimetre (kg/cm2), or kilopond per centimetre square (kp/cm2) is a deprecated unit of pressure using metric units. It is not a part of the International System of Units (SI), the modern metric system. 1 kgf/cm2 equals 98.0665 kPa (kilopascals). It is also known as a technical atmosphere (symbol: at). @@ -70,12 +82,15 @@ public enum PressureUnit KilonewtonPerSquareMeter = 18, KilonewtonPerSquareMillimeter = 19, Kilopascal = 20, + KilopascalG = 49, KilopoundForcePerSquareFoot = 21, KilopoundForcePerSquareInch = 22, KilopoundForcePerSquareMil = 23, Megabar = 24, + MegabarG = 60, MeganewtonPerSquareMeter = 25, Megapascal = 26, + MegapascalG = 56, MeterOfHead = 28, /// @@ -84,8 +99,11 @@ public enum PressureUnit /// https://en.wikipedia.org/wiki/Centimetre_or_millimetre_of_water MeterOfWaterColumn = 57, Microbar = 29, + MicrobarG = 67, Micropascal = 30, + MicropascalG = 65, Millibar = 31, + MillibarG = 62, /// /// A millimetre of mercury is a manometric unit of pressure, formerly defined as the extra pressure generated by a column of mercury one millimetre high, and currently defined as exactly 133.322387415 pascals. @@ -94,11 +112,18 @@ public enum PressureUnit MillimeterOfMercury = 32, MillimeterOfWaterColumn = 33, Millipascal = 34, + MillipascalG = 68, Millitorr = 52, NewtonPerSquareCentimeter = 35, NewtonPerSquareMeter = 36, NewtonPerSquareMillimeter = 37, Pascal = 38, + + /// + /// The Pa(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 101325 Pa). + /// + /// https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure + PascalG = 69, PoundForcePerSquareFoot = 39, PoundForcePerSquareInch = 40, PoundForcePerSquareMil = 41, diff --git a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln index f2d98d63c4..f70a8ea46b 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln +++ b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln @@ -86,6 +86,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}") = "Fluence", "Fluence\Fluence.nfproj", "{2e4fbb82-e5b9-73cd-399b-0941478e1f53}" +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}" @@ -516,6 +518,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 +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.Debug|Any CPU.ActiveCfg = Debug|Any CPU +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.Debug|Any CPU.Build.0 = Debug|Any CPU +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.Debug|Any CPU.Deploy.0 = Debug|Any CPU +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.Release|Any CPU.ActiveCfg = Release|Any CPU +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.Release|Any CPU.Build.0 = Release|Any CPU +{2e4fbb82-e5b9-73cd-399b-0941478e1f53}.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 diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs new file mode 100644 index 0000000000..fded7e8889 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFluence; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToFluenceExtensionsTests + { + [Fact] + public void NumberToNeutronsPerSquareCentimeterTest() => + Assert.Equal(Fluence.FromNeutronsPerSquareCentimeter(2), 2.NeutronsPerSquareCentimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs index 5fca8f9312..ff86886d58 100644 --- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs @@ -32,10 +32,18 @@ public void NumberToBoilerHorsepowerTest() => public void NumberToBritishThermalUnitsPerHourTest() => Assert.Equal(Power.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour); + [Fact] + public void NumberToDecapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromDecapascalCubicMeterPerSecond(2), 2.DecapascalCubicMeterPerSecond); + [Fact] public void NumberToDecawattsTest() => Assert.Equal(Power.FromDecawatts(2), 2.Decawatts); + [Fact] + public void NumberToDecipascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromDecipascalCubicMeterPerSecond(2), 2.DecipascalCubicMeterPerSecond); + [Fact] public void NumberToDeciwattsTest() => Assert.Equal(Power.FromDeciwatts(2), 2.Deciwatts); @@ -44,6 +52,10 @@ public void NumberToDeciwattsTest() => public void NumberToElectricalHorsepowerTest() => Assert.Equal(Power.FromElectricalHorsepower(2), 2.ElectricalHorsepower); + [Fact] + public void NumberToFemtopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromFemtopascalCubicMeterPerSecond(2), 2.FemtopascalCubicMeterPerSecond); + [Fact] public void NumberToFemtowattsTest() => Assert.Equal(Power.FromFemtowatts(2), 2.Femtowatts); @@ -52,6 +64,10 @@ public void NumberToFemtowattsTest() => public void NumberToGigajoulesPerHourTest() => Assert.Equal(Power.FromGigajoulesPerHour(2), 2.GigajoulesPerHour); + [Fact] + public void NumberToGigapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromGigapascalCubicMeterPerSecond(2), 2.GigapascalCubicMeterPerSecond); + [Fact] public void NumberToGigawattsTest() => Assert.Equal(Power.FromGigawatts(2), 2.Gigawatts); @@ -72,6 +88,10 @@ public void NumberToKilobritishThermalUnitsPerHourTest() => public void NumberToKilojoulesPerHourTest() => Assert.Equal(Power.FromKilojoulesPerHour(2), 2.KilojoulesPerHour); + [Fact] + public void NumberToKilopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromKilopascalCubicMeterPerSecond(2), 2.KilopascalCubicMeterPerSecond); + [Fact] public void NumberToKilowattsTest() => Assert.Equal(Power.FromKilowatts(2), 2.Kilowatts); @@ -88,6 +108,10 @@ public void NumberToMegabritishThermalUnitsPerHourTest() => public void NumberToMegajoulesPerHourTest() => Assert.Equal(Power.FromMegajoulesPerHour(2), 2.MegajoulesPerHour); + [Fact] + public void NumberToMegapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMegapascalCubicMeterPerSecond(2), 2.MegapascalCubicMeterPerSecond); + [Fact] public void NumberToMegawattsTest() => Assert.Equal(Power.FromMegawatts(2), 2.Megawatts); @@ -96,6 +120,10 @@ public void NumberToMegawattsTest() => public void NumberToMetricHorsepowerTest() => Assert.Equal(Power.FromMetricHorsepower(2), 2.MetricHorsepower); + [Fact] + public void NumberToMicropascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMicropascalCubicMeterPerSecond(2), 2.MicropascalCubicMeterPerSecond); + [Fact] public void NumberToMicrowattsTest() => Assert.Equal(Power.FromMicrowatts(2), 2.Microwatts); @@ -104,22 +132,46 @@ public void NumberToMicrowattsTest() => public void NumberToMillijoulesPerHourTest() => Assert.Equal(Power.FromMillijoulesPerHour(2), 2.MillijoulesPerHour); + [Fact] + public void NumberToMillipascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMillipascalCubicMeterPerSecond(2), 2.MillipascalCubicMeterPerSecond); + [Fact] public void NumberToMilliwattsTest() => Assert.Equal(Power.FromMilliwatts(2), 2.Milliwatts); + [Fact] + public void NumberToNanopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromNanopascalCubicMeterPerSecond(2), 2.NanopascalCubicMeterPerSecond); + [Fact] public void NumberToNanowattsTest() => Assert.Equal(Power.FromNanowatts(2), 2.Nanowatts); + [Fact] + public void NumberToPascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPascalCubicMeterPerSecond(2), 2.PascalCubicMeterPerSecond); + + [Fact] + public void NumberToPetapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPetapascalCubicMeterPerSecond(2), 2.PetapascalCubicMeterPerSecond); + [Fact] public void NumberToPetawattsTest() => Assert.Equal(Power.FromPetawatts(2), 2.Petawatts); + [Fact] + public void NumberToPicopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPicopascalCubicMeterPerSecond(2), 2.PicopascalCubicMeterPerSecond); + [Fact] public void NumberToPicowattsTest() => Assert.Equal(Power.FromPicowatts(2), 2.Picowatts); + [Fact] + public void NumberToTerapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromTerapascalCubicMeterPerSecond(2), 2.TerapascalCubicMeterPerSecond); + [Fact] public void NumberToTerawattsTest() => Assert.Equal(Power.FromTerawatts(2), 2.Terawatts); diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs index 904dc52a68..30c943f9b6 100644 --- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs @@ -32,10 +32,18 @@ public void NumberToAtmospheresTest() => public void NumberToBarsTest() => Assert.Equal(Pressure.FromBars(2), 2.Bars); + [Fact] + public void NumberToBarsGTest() => + Assert.Equal(Pressure.FromBarsG(2), 2.BarsG); + [Fact] public void NumberToCentibarsTest() => Assert.Equal(Pressure.FromCentibars(2), 2.Centibars); + [Fact] + public void NumberToCentibarsGTest() => + Assert.Equal(Pressure.FromCentibarsG(2), 2.CentibarsG); + [Fact] public void NumberToCentimetersOfWaterColumnTest() => Assert.Equal(Pressure.FromCentimetersOfWaterColumn(2), 2.CentimetersOfWaterColumn); @@ -44,10 +52,18 @@ public void NumberToCentimetersOfWaterColumnTest() => public void NumberToDecapascalsTest() => Assert.Equal(Pressure.FromDecapascals(2), 2.Decapascals); + [Fact] + public void NumberToDecapascalsGTest() => + Assert.Equal(Pressure.FromDecapascalsG(2), 2.DecapascalsG); + [Fact] public void NumberToDecibarsTest() => Assert.Equal(Pressure.FromDecibars(2), 2.Decibars); + [Fact] + public void NumberToDecibarsGTest() => + Assert.Equal(Pressure.FromDecibarsG(2), 2.DecibarsG); + [Fact] public void NumberToDynesPerSquareCentimeterTest() => Assert.Equal(Pressure.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter); @@ -60,10 +76,18 @@ public void NumberToFeetOfHeadTest() => public void NumberToGigapascalsTest() => Assert.Equal(Pressure.FromGigapascals(2), 2.Gigapascals); + [Fact] + public void NumberToGigapascalsGTest() => + Assert.Equal(Pressure.FromGigapascalsG(2), 2.GigapascalsG); + [Fact] public void NumberToHectopascalsTest() => Assert.Equal(Pressure.FromHectopascals(2), 2.Hectopascals); + [Fact] + public void NumberToHectopascalsGTest() => + Assert.Equal(Pressure.FromHectopascalsG(2), 2.HectopascalsG); + [Fact] public void NumberToInchesOfMercuryTest() => Assert.Equal(Pressure.FromInchesOfMercury(2), 2.InchesOfMercury); @@ -76,6 +100,10 @@ public void NumberToInchesOfWaterColumnTest() => public void NumberToKilobarsTest() => Assert.Equal(Pressure.FromKilobars(2), 2.Kilobars); + [Fact] + public void NumberToKilobarsGTest() => + Assert.Equal(Pressure.FromKilobarsG(2), 2.KilobarsG); + [Fact] public void NumberToKilogramsForcePerSquareCentimeterTest() => Assert.Equal(Pressure.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter); @@ -104,6 +132,10 @@ public void NumberToKilonewtonsPerSquareMillimeterTest() => public void NumberToKilopascalsTest() => Assert.Equal(Pressure.FromKilopascals(2), 2.Kilopascals); + [Fact] + public void NumberToKilopascalsGTest() => + Assert.Equal(Pressure.FromKilopascalsG(2), 2.KilopascalsG); + [Fact] public void NumberToKilopoundsForcePerSquareFootTest() => Assert.Equal(Pressure.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot); @@ -120,6 +152,10 @@ public void NumberToKilopoundsForcePerSquareMilTest() => public void NumberToMegabarsTest() => Assert.Equal(Pressure.FromMegabars(2), 2.Megabars); + [Fact] + public void NumberToMegabarsGTest() => + Assert.Equal(Pressure.FromMegabarsG(2), 2.MegabarsG); + [Fact] public void NumberToMeganewtonsPerSquareMeterTest() => Assert.Equal(Pressure.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter); @@ -128,6 +164,10 @@ public void NumberToMeganewtonsPerSquareMeterTest() => public void NumberToMegapascalsTest() => Assert.Equal(Pressure.FromMegapascals(2), 2.Megapascals); + [Fact] + public void NumberToMegapascalsGTest() => + Assert.Equal(Pressure.FromMegapascalsG(2), 2.MegapascalsG); + [Fact] public void NumberToMetersOfHeadTest() => Assert.Equal(Pressure.FromMetersOfHead(2), 2.MetersOfHead); @@ -140,14 +180,26 @@ public void NumberToMetersOfWaterColumnTest() => public void NumberToMicrobarsTest() => Assert.Equal(Pressure.FromMicrobars(2), 2.Microbars); + [Fact] + public void NumberToMicrobarsGTest() => + Assert.Equal(Pressure.FromMicrobarsG(2), 2.MicrobarsG); + [Fact] public void NumberToMicropascalsTest() => Assert.Equal(Pressure.FromMicropascals(2), 2.Micropascals); + [Fact] + public void NumberToMicropascalsGTest() => + Assert.Equal(Pressure.FromMicropascalsG(2), 2.MicropascalsG); + [Fact] public void NumberToMillibarsTest() => Assert.Equal(Pressure.FromMillibars(2), 2.Millibars); + [Fact] + public void NumberToMillibarsGTest() => + Assert.Equal(Pressure.FromMillibarsG(2), 2.MillibarsG); + [Fact] public void NumberToMillimetersOfMercuryTest() => Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury); @@ -160,6 +212,10 @@ public void NumberToMillimetersOfWaterColumnTest() => public void NumberToMillipascalsTest() => Assert.Equal(Pressure.FromMillipascals(2), 2.Millipascals); + [Fact] + public void NumberToMillipascalsGTest() => + Assert.Equal(Pressure.FromMillipascalsG(2), 2.MillipascalsG); + [Fact] public void NumberToMillitorrsTest() => Assert.Equal(Pressure.FromMillitorrs(2), 2.Millitorrs); @@ -180,6 +236,10 @@ public void NumberToNewtonsPerSquareMillimeterTest() => public void NumberToPascalsTest() => Assert.Equal(Pressure.FromPascals(2), 2.Pascals); + [Fact] + public void NumberToPascalsGTest() => + Assert.Equal(Pressure.FromPascalsG(2), 2.PascalsG); + [Fact] public void NumberToPoundsForcePerSquareFootTest() => Assert.Equal(Pressure.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot); diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluenceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluenceExtensions.g.cs new file mode 100644 index 0000000000..6d3a799aaf --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluenceExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFluence +{ + /// + /// A number to Fluence Extensions + /// + public static class NumberToFluenceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Fluence NeutronsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Fluence.FromNeutronsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Fluence.FromNeutronsPerSquareCentimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs index 6b0b8226b7..15e0392b91 100644 --- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs @@ -58,6 +58,14 @@ public Power BritishThermalUnitsPerHour => Power.FromBritishThermalUnitsPerHour(value.ToDouble(null)); #endif + /// + public Power DecapascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromDecapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromDecapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Decawatts #if NET7_0_OR_GREATER @@ -66,6 +74,14 @@ public Power Decawatts => Power.FromDecawatts(value.ToDouble(null)); #endif + /// + public Power DecipascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromDecipascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromDecipascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Deciwatts #if NET7_0_OR_GREATER @@ -82,6 +98,14 @@ public Power ElectricalHorsepower => Power.FromElectricalHorsepower(value.ToDouble(null)); #endif + /// + public Power FemtopascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromFemtopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromFemtopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Femtowatts #if NET7_0_OR_GREATER @@ -98,6 +122,14 @@ public Power GigajoulesPerHour => Power.FromGigajoulesPerHour(value.ToDouble(null)); #endif + /// + public Power GigapascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromGigapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromGigapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Gigawatts #if NET7_0_OR_GREATER @@ -138,6 +170,14 @@ public Power KilojoulesPerHour => Power.FromKilojoulesPerHour(value.ToDouble(null)); #endif + /// + public Power KilopascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromKilopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromKilopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Kilowatts #if NET7_0_OR_GREATER @@ -170,6 +210,14 @@ public Power MegajoulesPerHour => Power.FromMegajoulesPerHour(value.ToDouble(null)); #endif + /// + public Power MegapascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromMegapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromMegapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Megawatts #if NET7_0_OR_GREATER @@ -186,6 +234,14 @@ public Power MetricHorsepower => Power.FromMetricHorsepower(value.ToDouble(null)); #endif + /// + public Power MicropascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromMicropascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromMicropascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Microwatts #if NET7_0_OR_GREATER @@ -202,6 +258,14 @@ public Power MillijoulesPerHour => Power.FromMillijoulesPerHour(value.ToDouble(null)); #endif + /// + public Power MillipascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromMillipascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromMillipascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Milliwatts #if NET7_0_OR_GREATER @@ -210,6 +274,14 @@ public Power Milliwatts => Power.FromMilliwatts(value.ToDouble(null)); #endif + /// + public Power NanopascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromNanopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromNanopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Nanowatts #if NET7_0_OR_GREATER @@ -218,6 +290,22 @@ public Power Nanowatts => Power.FromNanowatts(value.ToDouble(null)); #endif + /// + public Power PascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromPascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromPascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + + /// + public Power PetapascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromPetapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromPetapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Petawatts #if NET7_0_OR_GREATER @@ -226,6 +314,14 @@ public Power Petawatts => Power.FromPetawatts(value.ToDouble(null)); #endif + /// + public Power PicopascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromPicopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromPicopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Picowatts #if NET7_0_OR_GREATER @@ -234,6 +330,14 @@ public Power Picowatts => Power.FromPicowatts(value.ToDouble(null)); #endif + /// + public Power TerapascalCubicMeterPerSecond +#if NET7_0_OR_GREATER + => Power.FromTerapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + => Power.FromTerapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public Power Terawatts #if NET7_0_OR_GREATER diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs index 538f5530f5..8787f80a2d 100644 --- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs @@ -58,6 +58,14 @@ public Pressure Bars => Pressure.FromBars(value.ToDouble(null)); #endif + /// + public Pressure BarsG +#if NET7_0_OR_GREATER + => Pressure.FromBarsG(double.CreateChecked(value)); +#else + => Pressure.FromBarsG(value.ToDouble(null)); +#endif + /// public Pressure Centibars #if NET7_0_OR_GREATER @@ -66,6 +74,14 @@ public Pressure Centibars => Pressure.FromCentibars(value.ToDouble(null)); #endif + /// + public Pressure CentibarsG +#if NET7_0_OR_GREATER + => Pressure.FromCentibarsG(double.CreateChecked(value)); +#else + => Pressure.FromCentibarsG(value.ToDouble(null)); +#endif + /// public Pressure CentimetersOfWaterColumn #if NET7_0_OR_GREATER @@ -82,6 +98,14 @@ public Pressure Decapascals => Pressure.FromDecapascals(value.ToDouble(null)); #endif + /// + public Pressure DecapascalsG +#if NET7_0_OR_GREATER + => Pressure.FromDecapascalsG(double.CreateChecked(value)); +#else + => Pressure.FromDecapascalsG(value.ToDouble(null)); +#endif + /// public Pressure Decibars #if NET7_0_OR_GREATER @@ -90,6 +114,14 @@ public Pressure Decibars => Pressure.FromDecibars(value.ToDouble(null)); #endif + /// + public Pressure DecibarsG +#if NET7_0_OR_GREATER + => Pressure.FromDecibarsG(double.CreateChecked(value)); +#else + => Pressure.FromDecibarsG(value.ToDouble(null)); +#endif + /// public Pressure DynesPerSquareCentimeter #if NET7_0_OR_GREATER @@ -114,6 +146,14 @@ public Pressure Gigapascals => Pressure.FromGigapascals(value.ToDouble(null)); #endif + /// + public Pressure GigapascalsG +#if NET7_0_OR_GREATER + => Pressure.FromGigapascalsG(double.CreateChecked(value)); +#else + => Pressure.FromGigapascalsG(value.ToDouble(null)); +#endif + /// public Pressure Hectopascals #if NET7_0_OR_GREATER @@ -122,6 +162,14 @@ public Pressure Hectopascals => Pressure.FromHectopascals(value.ToDouble(null)); #endif + /// + public Pressure HectopascalsG +#if NET7_0_OR_GREATER + => Pressure.FromHectopascalsG(double.CreateChecked(value)); +#else + => Pressure.FromHectopascalsG(value.ToDouble(null)); +#endif + /// public Pressure InchesOfMercury #if NET7_0_OR_GREATER @@ -146,6 +194,14 @@ public Pressure Kilobars => Pressure.FromKilobars(value.ToDouble(null)); #endif + /// + public Pressure KilobarsG +#if NET7_0_OR_GREATER + => Pressure.FromKilobarsG(double.CreateChecked(value)); +#else + => Pressure.FromKilobarsG(value.ToDouble(null)); +#endif + /// public Pressure KilogramsForcePerSquareCentimeter #if NET7_0_OR_GREATER @@ -202,6 +258,14 @@ public Pressure Kilopascals => Pressure.FromKilopascals(value.ToDouble(null)); #endif + /// + public Pressure KilopascalsG +#if NET7_0_OR_GREATER + => Pressure.FromKilopascalsG(double.CreateChecked(value)); +#else + => Pressure.FromKilopascalsG(value.ToDouble(null)); +#endif + /// public Pressure KilopoundsForcePerSquareFoot #if NET7_0_OR_GREATER @@ -234,6 +298,14 @@ public Pressure Megabars => Pressure.FromMegabars(value.ToDouble(null)); #endif + /// + public Pressure MegabarsG +#if NET7_0_OR_GREATER + => Pressure.FromMegabarsG(double.CreateChecked(value)); +#else + => Pressure.FromMegabarsG(value.ToDouble(null)); +#endif + /// public Pressure MeganewtonsPerSquareMeter #if NET7_0_OR_GREATER @@ -250,6 +322,14 @@ public Pressure Megapascals => Pressure.FromMegapascals(value.ToDouble(null)); #endif + /// + public Pressure MegapascalsG +#if NET7_0_OR_GREATER + => Pressure.FromMegapascalsG(double.CreateChecked(value)); +#else + => Pressure.FromMegapascalsG(value.ToDouble(null)); +#endif + /// public Pressure MetersOfHead #if NET7_0_OR_GREATER @@ -274,6 +354,14 @@ public Pressure Microbars => Pressure.FromMicrobars(value.ToDouble(null)); #endif + /// + public Pressure MicrobarsG +#if NET7_0_OR_GREATER + => Pressure.FromMicrobarsG(double.CreateChecked(value)); +#else + => Pressure.FromMicrobarsG(value.ToDouble(null)); +#endif + /// public Pressure Micropascals #if NET7_0_OR_GREATER @@ -282,6 +370,14 @@ public Pressure Micropascals => Pressure.FromMicropascals(value.ToDouble(null)); #endif + /// + public Pressure MicropascalsG +#if NET7_0_OR_GREATER + => Pressure.FromMicropascalsG(double.CreateChecked(value)); +#else + => Pressure.FromMicropascalsG(value.ToDouble(null)); +#endif + /// public Pressure Millibars #if NET7_0_OR_GREATER @@ -290,6 +386,14 @@ public Pressure Millibars => Pressure.FromMillibars(value.ToDouble(null)); #endif + /// + public Pressure MillibarsG +#if NET7_0_OR_GREATER + => Pressure.FromMillibarsG(double.CreateChecked(value)); +#else + => Pressure.FromMillibarsG(value.ToDouble(null)); +#endif + /// public Pressure MillimetersOfMercury #if NET7_0_OR_GREATER @@ -314,6 +418,14 @@ public Pressure Millipascals => Pressure.FromMillipascals(value.ToDouble(null)); #endif + /// + public Pressure MillipascalsG +#if NET7_0_OR_GREATER + => Pressure.FromMillipascalsG(double.CreateChecked(value)); +#else + => Pressure.FromMillipascalsG(value.ToDouble(null)); +#endif + /// public Pressure Millitorrs #if NET7_0_OR_GREATER @@ -354,6 +466,14 @@ public Pressure Pascals => Pressure.FromPascals(value.ToDouble(null)); #endif + /// + public Pressure PascalsG +#if NET7_0_OR_GREATER + => Pressure.FromPascalsG(double.CreateChecked(value)); +#else + => Pressure.FromPascalsG(value.ToDouble(null)); +#endif + /// public Pressure PoundsForcePerSquareFoot #if NET7_0_OR_GREATER diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs new file mode 100644 index 0000000000..87b9d77da4 --- /dev/null +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFluenceExtensionsTest.g.cs @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFluence; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToFluenceExtensionsTests + { + [Fact] + public void NumberToNeutronsPerSquareCentimeterTest() => + Assert.Equal(Fluence.FromNeutronsPerSquareCentimeter(2), 2.NeutronsPerSquareCentimeter()); + + } +} diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs index 43c762e9e1..cebce0d135 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs @@ -32,10 +32,18 @@ public void NumberToBoilerHorsepowerTest() => public void NumberToBritishThermalUnitsPerHourTest() => Assert.Equal(Power.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour()); + [Fact] + public void NumberToDecapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromDecapascalCubicMeterPerSecond(2), 2.DecapascalCubicMeterPerSecond()); + [Fact] public void NumberToDecawattsTest() => Assert.Equal(Power.FromDecawatts(2), 2.Decawatts()); + [Fact] + public void NumberToDecipascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromDecipascalCubicMeterPerSecond(2), 2.DecipascalCubicMeterPerSecond()); + [Fact] public void NumberToDeciwattsTest() => Assert.Equal(Power.FromDeciwatts(2), 2.Deciwatts()); @@ -44,6 +52,10 @@ public void NumberToDeciwattsTest() => public void NumberToElectricalHorsepowerTest() => Assert.Equal(Power.FromElectricalHorsepower(2), 2.ElectricalHorsepower()); + [Fact] + public void NumberToFemtopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromFemtopascalCubicMeterPerSecond(2), 2.FemtopascalCubicMeterPerSecond()); + [Fact] public void NumberToFemtowattsTest() => Assert.Equal(Power.FromFemtowatts(2), 2.Femtowatts()); @@ -52,6 +64,10 @@ public void NumberToFemtowattsTest() => public void NumberToGigajoulesPerHourTest() => Assert.Equal(Power.FromGigajoulesPerHour(2), 2.GigajoulesPerHour()); + [Fact] + public void NumberToGigapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromGigapascalCubicMeterPerSecond(2), 2.GigapascalCubicMeterPerSecond()); + [Fact] public void NumberToGigawattsTest() => Assert.Equal(Power.FromGigawatts(2), 2.Gigawatts()); @@ -72,6 +88,10 @@ public void NumberToKilobritishThermalUnitsPerHourTest() => public void NumberToKilojoulesPerHourTest() => Assert.Equal(Power.FromKilojoulesPerHour(2), 2.KilojoulesPerHour()); + [Fact] + public void NumberToKilopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromKilopascalCubicMeterPerSecond(2), 2.KilopascalCubicMeterPerSecond()); + [Fact] public void NumberToKilowattsTest() => Assert.Equal(Power.FromKilowatts(2), 2.Kilowatts()); @@ -88,6 +108,10 @@ public void NumberToMegabritishThermalUnitsPerHourTest() => public void NumberToMegajoulesPerHourTest() => Assert.Equal(Power.FromMegajoulesPerHour(2), 2.MegajoulesPerHour()); + [Fact] + public void NumberToMegapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMegapascalCubicMeterPerSecond(2), 2.MegapascalCubicMeterPerSecond()); + [Fact] public void NumberToMegawattsTest() => Assert.Equal(Power.FromMegawatts(2), 2.Megawatts()); @@ -96,6 +120,10 @@ public void NumberToMegawattsTest() => public void NumberToMetricHorsepowerTest() => Assert.Equal(Power.FromMetricHorsepower(2), 2.MetricHorsepower()); + [Fact] + public void NumberToMicropascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMicropascalCubicMeterPerSecond(2), 2.MicropascalCubicMeterPerSecond()); + [Fact] public void NumberToMicrowattsTest() => Assert.Equal(Power.FromMicrowatts(2), 2.Microwatts()); @@ -104,22 +132,46 @@ public void NumberToMicrowattsTest() => public void NumberToMillijoulesPerHourTest() => Assert.Equal(Power.FromMillijoulesPerHour(2), 2.MillijoulesPerHour()); + [Fact] + public void NumberToMillipascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromMillipascalCubicMeterPerSecond(2), 2.MillipascalCubicMeterPerSecond()); + [Fact] public void NumberToMilliwattsTest() => Assert.Equal(Power.FromMilliwatts(2), 2.Milliwatts()); + [Fact] + public void NumberToNanopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromNanopascalCubicMeterPerSecond(2), 2.NanopascalCubicMeterPerSecond()); + [Fact] public void NumberToNanowattsTest() => Assert.Equal(Power.FromNanowatts(2), 2.Nanowatts()); + [Fact] + public void NumberToPascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPascalCubicMeterPerSecond(2), 2.PascalCubicMeterPerSecond()); + + [Fact] + public void NumberToPetapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPetapascalCubicMeterPerSecond(2), 2.PetapascalCubicMeterPerSecond()); + [Fact] public void NumberToPetawattsTest() => Assert.Equal(Power.FromPetawatts(2), 2.Petawatts()); + [Fact] + public void NumberToPicopascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromPicopascalCubicMeterPerSecond(2), 2.PicopascalCubicMeterPerSecond()); + [Fact] public void NumberToPicowattsTest() => Assert.Equal(Power.FromPicowatts(2), 2.Picowatts()); + [Fact] + public void NumberToTerapascalCubicMeterPerSecondTest() => + Assert.Equal(Power.FromTerapascalCubicMeterPerSecond(2), 2.TerapascalCubicMeterPerSecond()); + [Fact] public void NumberToTerawattsTest() => Assert.Equal(Power.FromTerawatts(2), 2.Terawatts()); diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs index eccdde9422..91d25d11db 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs @@ -32,10 +32,18 @@ public void NumberToAtmospheresTest() => public void NumberToBarsTest() => Assert.Equal(Pressure.FromBars(2), 2.Bars()); + [Fact] + public void NumberToBarsGTest() => + Assert.Equal(Pressure.FromBarsG(2), 2.BarsG()); + [Fact] public void NumberToCentibarsTest() => Assert.Equal(Pressure.FromCentibars(2), 2.Centibars()); + [Fact] + public void NumberToCentibarsGTest() => + Assert.Equal(Pressure.FromCentibarsG(2), 2.CentibarsG()); + [Fact] public void NumberToCentimetersOfWaterColumnTest() => Assert.Equal(Pressure.FromCentimetersOfWaterColumn(2), 2.CentimetersOfWaterColumn()); @@ -44,10 +52,18 @@ public void NumberToCentimetersOfWaterColumnTest() => public void NumberToDecapascalsTest() => Assert.Equal(Pressure.FromDecapascals(2), 2.Decapascals()); + [Fact] + public void NumberToDecapascalsGTest() => + Assert.Equal(Pressure.FromDecapascalsG(2), 2.DecapascalsG()); + [Fact] public void NumberToDecibarsTest() => Assert.Equal(Pressure.FromDecibars(2), 2.Decibars()); + [Fact] + public void NumberToDecibarsGTest() => + Assert.Equal(Pressure.FromDecibarsG(2), 2.DecibarsG()); + [Fact] public void NumberToDynesPerSquareCentimeterTest() => Assert.Equal(Pressure.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter()); @@ -60,10 +76,18 @@ public void NumberToFeetOfHeadTest() => public void NumberToGigapascalsTest() => Assert.Equal(Pressure.FromGigapascals(2), 2.Gigapascals()); + [Fact] + public void NumberToGigapascalsGTest() => + Assert.Equal(Pressure.FromGigapascalsG(2), 2.GigapascalsG()); + [Fact] public void NumberToHectopascalsTest() => Assert.Equal(Pressure.FromHectopascals(2), 2.Hectopascals()); + [Fact] + public void NumberToHectopascalsGTest() => + Assert.Equal(Pressure.FromHectopascalsG(2), 2.HectopascalsG()); + [Fact] public void NumberToInchesOfMercuryTest() => Assert.Equal(Pressure.FromInchesOfMercury(2), 2.InchesOfMercury()); @@ -76,6 +100,10 @@ public void NumberToInchesOfWaterColumnTest() => public void NumberToKilobarsTest() => Assert.Equal(Pressure.FromKilobars(2), 2.Kilobars()); + [Fact] + public void NumberToKilobarsGTest() => + Assert.Equal(Pressure.FromKilobarsG(2), 2.KilobarsG()); + [Fact] public void NumberToKilogramsForcePerSquareCentimeterTest() => Assert.Equal(Pressure.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter()); @@ -104,6 +132,10 @@ public void NumberToKilonewtonsPerSquareMillimeterTest() => public void NumberToKilopascalsTest() => Assert.Equal(Pressure.FromKilopascals(2), 2.Kilopascals()); + [Fact] + public void NumberToKilopascalsGTest() => + Assert.Equal(Pressure.FromKilopascalsG(2), 2.KilopascalsG()); + [Fact] public void NumberToKilopoundsForcePerSquareFootTest() => Assert.Equal(Pressure.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot()); @@ -120,6 +152,10 @@ public void NumberToKilopoundsForcePerSquareMilTest() => public void NumberToMegabarsTest() => Assert.Equal(Pressure.FromMegabars(2), 2.Megabars()); + [Fact] + public void NumberToMegabarsGTest() => + Assert.Equal(Pressure.FromMegabarsG(2), 2.MegabarsG()); + [Fact] public void NumberToMeganewtonsPerSquareMeterTest() => Assert.Equal(Pressure.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter()); @@ -128,6 +164,10 @@ public void NumberToMeganewtonsPerSquareMeterTest() => public void NumberToMegapascalsTest() => Assert.Equal(Pressure.FromMegapascals(2), 2.Megapascals()); + [Fact] + public void NumberToMegapascalsGTest() => + Assert.Equal(Pressure.FromMegapascalsG(2), 2.MegapascalsG()); + [Fact] public void NumberToMetersOfHeadTest() => Assert.Equal(Pressure.FromMetersOfHead(2), 2.MetersOfHead()); @@ -140,14 +180,26 @@ public void NumberToMetersOfWaterColumnTest() => public void NumberToMicrobarsTest() => Assert.Equal(Pressure.FromMicrobars(2), 2.Microbars()); + [Fact] + public void NumberToMicrobarsGTest() => + Assert.Equal(Pressure.FromMicrobarsG(2), 2.MicrobarsG()); + [Fact] public void NumberToMicropascalsTest() => Assert.Equal(Pressure.FromMicropascals(2), 2.Micropascals()); + [Fact] + public void NumberToMicropascalsGTest() => + Assert.Equal(Pressure.FromMicropascalsG(2), 2.MicropascalsG()); + [Fact] public void NumberToMillibarsTest() => Assert.Equal(Pressure.FromMillibars(2), 2.Millibars()); + [Fact] + public void NumberToMillibarsGTest() => + Assert.Equal(Pressure.FromMillibarsG(2), 2.MillibarsG()); + [Fact] public void NumberToMillimetersOfMercuryTest() => Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury()); @@ -160,6 +212,10 @@ public void NumberToMillimetersOfWaterColumnTest() => public void NumberToMillipascalsTest() => Assert.Equal(Pressure.FromMillipascals(2), 2.Millipascals()); + [Fact] + public void NumberToMillipascalsGTest() => + Assert.Equal(Pressure.FromMillipascalsG(2), 2.MillipascalsG()); + [Fact] public void NumberToMillitorrsTest() => Assert.Equal(Pressure.FromMillitorrs(2), 2.Millitorrs()); @@ -180,6 +236,10 @@ public void NumberToNewtonsPerSquareMillimeterTest() => public void NumberToPascalsTest() => Assert.Equal(Pressure.FromPascals(2), 2.Pascals()); + [Fact] + public void NumberToPascalsGTest() => + Assert.Equal(Pressure.FromPascalsG(2), 2.PascalsG()); + [Fact] public void NumberToPoundsForcePerSquareFootTest() => Assert.Equal(Pressure.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluenceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluenceExtensions.g.cs new file mode 100644 index 0000000000..49bf4678fa --- /dev/null +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFluenceExtensions.g.cs @@ -0,0 +1,47 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFluence +{ + /// + /// A number to Fluence Extensions + /// + public static class NumberToFluenceExtensions + { + /// + public static Fluence NeutronsPerSquareCentimeter(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Fluence.FromNeutronsPerSquareCentimeter(double.CreateChecked(value)); +#else + , IConvertible + => Fluence.FromNeutronsPerSquareCentimeter(value.ToDouble(null)); +#endif + + } +} diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs index a3f802215b..453aab9cd4 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs @@ -54,6 +54,17 @@ public static Power BritishThermalUnitsPerHour(this T value) => Power.FromBritishThermalUnitsPerHour(value.ToDouble(null)); #endif + /// + public static Power DecapascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromDecapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromDecapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Decawatts(this T value) where T : notnull @@ -65,6 +76,17 @@ public static Power Decawatts(this T value) => Power.FromDecawatts(value.ToDouble(null)); #endif + /// + public static Power DecipascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromDecipascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromDecipascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Deciwatts(this T value) where T : notnull @@ -87,6 +109,17 @@ public static Power ElectricalHorsepower(this T value) => Power.FromElectricalHorsepower(value.ToDouble(null)); #endif + /// + public static Power FemtopascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromFemtopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromFemtopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Femtowatts(this T value) where T : notnull @@ -109,6 +142,17 @@ public static Power GigajoulesPerHour(this T value) => Power.FromGigajoulesPerHour(value.ToDouble(null)); #endif + /// + public static Power GigapascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromGigapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromGigapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Gigawatts(this T value) where T : notnull @@ -164,6 +208,17 @@ public static Power KilojoulesPerHour(this T value) => Power.FromKilojoulesPerHour(value.ToDouble(null)); #endif + /// + public static Power KilopascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromKilopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromKilopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Kilowatts(this T value) where T : notnull @@ -208,6 +263,17 @@ public static Power MegajoulesPerHour(this T value) => Power.FromMegajoulesPerHour(value.ToDouble(null)); #endif + /// + public static Power MegapascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromMegapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromMegapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Megawatts(this T value) where T : notnull @@ -230,6 +296,17 @@ public static Power MetricHorsepower(this T value) => Power.FromMetricHorsepower(value.ToDouble(null)); #endif + /// + public static Power MicropascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromMicropascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromMicropascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Microwatts(this T value) where T : notnull @@ -252,6 +329,17 @@ public static Power MillijoulesPerHour(this T value) => Power.FromMillijoulesPerHour(value.ToDouble(null)); #endif + /// + public static Power MillipascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromMillipascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromMillipascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Milliwatts(this T value) where T : notnull @@ -263,6 +351,17 @@ public static Power Milliwatts(this T value) => Power.FromMilliwatts(value.ToDouble(null)); #endif + /// + public static Power NanopascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromNanopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromNanopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Nanowatts(this T value) where T : notnull @@ -274,6 +373,28 @@ public static Power Nanowatts(this T value) => Power.FromNanowatts(value.ToDouble(null)); #endif + /// + public static Power PascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromPascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromPascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + + /// + public static Power PetapascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromPetapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromPetapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Petawatts(this T value) where T : notnull @@ -285,6 +406,17 @@ public static Power Petawatts(this T value) => Power.FromPetawatts(value.ToDouble(null)); #endif + /// + public static Power PicopascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromPicopascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromPicopascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Picowatts(this T value) where T : notnull @@ -296,6 +428,17 @@ public static Power Picowatts(this T value) => Power.FromPicowatts(value.ToDouble(null)); #endif + /// + public static Power TerapascalCubicMeterPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Power.FromTerapascalCubicMeterPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => Power.FromTerapascalCubicMeterPerSecond(value.ToDouble(null)); +#endif + /// public static Power Terawatts(this T value) where T : notnull diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs index b731ef1138..424b364f5b 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs @@ -54,6 +54,17 @@ public static Pressure Bars(this T value) => Pressure.FromBars(value.ToDouble(null)); #endif + /// + public static Pressure BarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromBarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromBarsG(value.ToDouble(null)); +#endif + /// public static Pressure Centibars(this T value) where T : notnull @@ -65,6 +76,17 @@ public static Pressure Centibars(this T value) => Pressure.FromCentibars(value.ToDouble(null)); #endif + /// + public static Pressure CentibarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromCentibarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromCentibarsG(value.ToDouble(null)); +#endif + /// public static Pressure CentimetersOfWaterColumn(this T value) where T : notnull @@ -87,6 +109,17 @@ public static Pressure Decapascals(this T value) => Pressure.FromDecapascals(value.ToDouble(null)); #endif + /// + public static Pressure DecapascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromDecapascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromDecapascalsG(value.ToDouble(null)); +#endif + /// public static Pressure Decibars(this T value) where T : notnull @@ -98,6 +131,17 @@ public static Pressure Decibars(this T value) => Pressure.FromDecibars(value.ToDouble(null)); #endif + /// + public static Pressure DecibarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromDecibarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromDecibarsG(value.ToDouble(null)); +#endif + /// public static Pressure DynesPerSquareCentimeter(this T value) where T : notnull @@ -131,6 +175,17 @@ public static Pressure Gigapascals(this T value) => Pressure.FromGigapascals(value.ToDouble(null)); #endif + /// + public static Pressure GigapascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromGigapascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromGigapascalsG(value.ToDouble(null)); +#endif + /// public static Pressure Hectopascals(this T value) where T : notnull @@ -142,6 +197,17 @@ public static Pressure Hectopascals(this T value) => Pressure.FromHectopascals(value.ToDouble(null)); #endif + /// + public static Pressure HectopascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromHectopascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromHectopascalsG(value.ToDouble(null)); +#endif + /// public static Pressure InchesOfMercury(this T value) where T : notnull @@ -175,6 +241,17 @@ public static Pressure Kilobars(this T value) => Pressure.FromKilobars(value.ToDouble(null)); #endif + /// + public static Pressure KilobarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromKilobarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromKilobarsG(value.ToDouble(null)); +#endif + /// public static Pressure KilogramsForcePerSquareCentimeter(this T value) where T : notnull @@ -252,6 +329,17 @@ public static Pressure Kilopascals(this T value) => Pressure.FromKilopascals(value.ToDouble(null)); #endif + /// + public static Pressure KilopascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromKilopascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromKilopascalsG(value.ToDouble(null)); +#endif + /// public static Pressure KilopoundsForcePerSquareFoot(this T value) where T : notnull @@ -296,6 +384,17 @@ public static Pressure Megabars(this T value) => Pressure.FromMegabars(value.ToDouble(null)); #endif + /// + public static Pressure MegabarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMegabarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMegabarsG(value.ToDouble(null)); +#endif + /// public static Pressure MeganewtonsPerSquareMeter(this T value) where T : notnull @@ -318,6 +417,17 @@ public static Pressure Megapascals(this T value) => Pressure.FromMegapascals(value.ToDouble(null)); #endif + /// + public static Pressure MegapascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMegapascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMegapascalsG(value.ToDouble(null)); +#endif + /// public static Pressure MetersOfHead(this T value) where T : notnull @@ -351,6 +461,17 @@ public static Pressure Microbars(this T value) => Pressure.FromMicrobars(value.ToDouble(null)); #endif + /// + public static Pressure MicrobarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMicrobarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMicrobarsG(value.ToDouble(null)); +#endif + /// public static Pressure Micropascals(this T value) where T : notnull @@ -362,6 +483,17 @@ public static Pressure Micropascals(this T value) => Pressure.FromMicropascals(value.ToDouble(null)); #endif + /// + public static Pressure MicropascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMicropascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMicropascalsG(value.ToDouble(null)); +#endif + /// public static Pressure Millibars(this T value) where T : notnull @@ -373,6 +505,17 @@ public static Pressure Millibars(this T value) => Pressure.FromMillibars(value.ToDouble(null)); #endif + /// + public static Pressure MillibarsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMillibarsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMillibarsG(value.ToDouble(null)); +#endif + /// public static Pressure MillimetersOfMercury(this T value) where T : notnull @@ -406,6 +549,17 @@ public static Pressure Millipascals(this T value) => Pressure.FromMillipascals(value.ToDouble(null)); #endif + /// + public static Pressure MillipascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromMillipascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromMillipascalsG(value.ToDouble(null)); +#endif + /// public static Pressure Millitorrs(this T value) where T : notnull @@ -461,6 +615,17 @@ public static Pressure Pascals(this T value) => Pressure.FromPascals(value.ToDouble(null)); #endif + /// + public static Pressure PascalsG(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Pressure.FromPascalsG(double.CreateChecked(value)); +#else + , IConvertible + => Pressure.FromPascalsG(value.ToDouble(null)); +#endif + /// public static Pressure PoundsForcePerSquareFoot(this T value) where T : notnull diff --git a/UnitsNet.Tests/CustomCode/FluenceTests.cs b/UnitsNet.Tests/CustomCode/FluenceTests.cs new file mode 100644 index 0000000000..99069dc56f --- /dev/null +++ b/UnitsNet.Tests/CustomCode/FluenceTests.cs @@ -0,0 +1,28 @@ +//------------------------------------------------------------------------------ +// +// 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 FluenceTests : FluenceTestsBase + { + // Override properties in base class here + } +} diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 9dfabd182a..7760619a14 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -76,6 +76,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, FluenceUnit.NeutronPerSquareCentimeter, Quantity.From(3, FluenceUnit.NeutronPerSquareCentimeter)); 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)); @@ -211,6 +212,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty() Assertion(Energy.Info, Energy.Zero); Assertion(EnergyDensity.Info, EnergyDensity.Zero); Assertion(Entropy.Info, Entropy.Zero); + Assertion(Fluence.Info, Fluence.Zero); Assertion(FluidResistance.Info, FluidResistance.Zero); Assertion(Force.Info, Force.Zero); Assertion(ForceChangeRate.Info, ForceChangeRate.Zero); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FluenceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FluenceTestsBase.g.cs new file mode 100644 index 0000000000..a269d6fd6c --- /dev/null +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FluenceTestsBase.g.cs @@ -0,0 +1,650 @@ +//------------------------------------------------------------------------------ +// +// 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.InternalHelpers; +using UnitsNet.Tests.Helpers; +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 Fluence. + /// +// ReSharper disable once PartialTypeWithSinglePart + public abstract partial class FluenceTestsBase : QuantityTestsBase + { + protected abstract double NeutronsPerSquareCentimeterInOneNeutronPerSquareCentimeter { get; } + +// ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double NeutronsPerSquareCentimeterTolerance { get { return 1e-5; } } +// ReSharper restore VirtualMemberNeverOverriden.Global + + protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(FluenceUnit unit) + { + return unit switch + { + FluenceUnit.NeutronPerSquareCentimeter => (NeutronsPerSquareCentimeterInOneNeutronPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance), + _ => throw new NotSupportedException() + }; + } + + public static IEnumerable UnitTypes = new List + { + new object[] { FluenceUnit.NeutronPerSquareCentimeter }, + }; + + [Fact] + public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit() + { + var quantity = new Fluence(); + Assert.Equal(0, quantity.Value); + Assert.Equal(FluenceUnit.NeutronPerSquareCentimeter, quantity.Unit); + } + + [Fact] + public void Ctor_WithInfinityValue_DoNotThrowsArgumentException() + { + var exception1 = Record.Exception(() => new Fluence(double.PositiveInfinity, FluenceUnit.NeutronPerSquareCentimeter)); + var exception2 = Record.Exception(() => new Fluence(double.NegativeInfinity, FluenceUnit.NeutronPerSquareCentimeter)); + + Assert.Null(exception1); + Assert.Null(exception2); + } + + [Fact] + public void Ctor_WithNaNValue_DoNotThrowsArgumentException() + { + var exception = Record.Exception(() => new Fluence(double.NaN, FluenceUnit.NeutronPerSquareCentimeter)); + + Assert.Null(exception); + } + + [Fact] + public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException() + { + Assert.Throws(() => new Fluence(value: 1, unitSystem: null)); + } + + [Fact] + public virtual void Ctor_SIUnitSystem_ReturnsQuantityWithSIUnits() + { + var quantity = new Fluence(value: 1, unitSystem: UnitSystem.SI); + Assert.Equal(1, quantity.Value); + Assert.True(quantity.QuantityInfo[quantity.Unit].BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits)); + } + + [Fact] + public void Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits); + Assert.Throws(() => new Fluence(value: 1, unitSystem: unsupportedUnitSystem)); + } + + [Fact] + public void Fluence_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() + { + FluenceUnit[] unitsOrderedByName = EnumHelper.GetValues().OrderBy(x => x.ToString(), StringComparer.OrdinalIgnoreCase).ToArray(); + var quantity = new Fluence(1, FluenceUnit.NeutronPerSquareCentimeter); + + QuantityInfo quantityInfo = quantity.QuantityInfo; + + Assert.Equal("Fluence", quantityInfo.Name); + Assert.Equal(Fluence.Zero, quantityInfo.Zero); + Assert.Equal(Fluence.BaseUnit, quantityInfo.BaseUnitInfo.Value); + Assert.Equal(unitsOrderedByName, quantityInfo.Units); + Assert.Equal(unitsOrderedByName, quantityInfo.UnitInfos.Select(x => x.Value)); + Assert.Equal(Fluence.Info, quantityInfo); + Assert.Equal(quantityInfo, ((IQuantity)quantity).QuantityInfo); + Assert.Equal(quantityInfo, ((IQuantity)quantity).QuantityInfo); + } + + [Fact] + public void NeutronPerSquareCentimeterToFluenceUnits() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + AssertEx.EqualTolerance(NeutronsPerSquareCentimeterInOneNeutronPerSquareCentimeter, neutronpersquarecentimeter.NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + } + + [Fact] + public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() + { + Assert.All(EnumHelper.GetValues(), unit => + { + var quantity = Fluence.From(1, unit); + Assert.Equal(1, quantity.Value); + Assert.Equal(unit, quantity.Unit); + }); + } + + [Fact] + public void FromNeutronsPerSquareCentimeter_WithInfinityValue_DoNotThrowsArgumentException() + { + var exception1 = Record.Exception(() => Fluence.FromNeutronsPerSquareCentimeter(double.PositiveInfinity)); + var exception2 = Record.Exception(() => Fluence.FromNeutronsPerSquareCentimeter(double.NegativeInfinity)); + + Assert.Null(exception1); + Assert.Null(exception2); + } + + [Fact] + public void FromNeutronsPerSquareCentimeter_WithNanValue_DoNotThrowsArgumentException() + { + var exception = Record.Exception(() => Fluence.FromNeutronsPerSquareCentimeter(double.NaN)); + + Assert.Null(exception); + } + + [Fact] + public void As() + { + var neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + AssertEx.EqualTolerance(NeutronsPerSquareCentimeterInOneNeutronPerSquareCentimeter, neutronpersquarecentimeter.As(FluenceUnit.NeutronPerSquareCentimeter), NeutronsPerSquareCentimeterTolerance); + } + + [Fact] + public virtual void BaseUnit_HasSIBase() + { + var baseUnitInfo = Fluence.Info.BaseUnitInfo; + Assert.True(baseUnitInfo.BaseUnits.IsSubsetOf(UnitSystem.SI.BaseUnits)); + } + + [Fact] + public virtual void As_UnitSystem_SI_ReturnsQuantityInSIUnits() + { + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + var expectedValue = quantity.As(Fluence.Info.GetDefaultUnit(UnitSystem.SI)); + + var convertedValue = quantity.As(UnitSystem.SI); + + Assert.Equal(expectedValue, convertedValue); + } + + [Fact] + public void As_UnitSystem_ThrowsArgumentNullExceptionIfNull() + { + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + UnitSystem nullUnitSystem = null!; + Assert.Throws(() => quantity.As(nullUnitSystem)); + } + + [Fact] + public void As_UnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits); + Assert.Throws(() => quantity.As(unsupportedUnitSystem)); + } + + [Fact] + public virtual void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits() + { + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + var expectedUnit = Fluence.Info.GetDefaultUnit(UnitSystem.SI); + var expectedValue = quantity.As(expectedUnit); + + Fluence convertedQuantity = quantity.ToUnit(UnitSystem.SI); + + Assert.Equal(expectedUnit, convertedQuantity.Unit); + Assert.Equal(expectedValue, convertedQuantity.Value); + } + + [Fact] + public void ToUnit_UnitSystem_ThrowsArgumentNullExceptionIfNull() + { + UnitSystem nullUnitSystem = null!; + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + Assert.Throws(() => quantity.ToUnit(nullUnitSystem)); + } + + [Fact] + public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + var unsupportedUnitSystem = new UnitSystem(UnsupportedBaseUnits); + var quantity = new Fluence(value: 1, unit: Fluence.BaseUnit); + Assert.Throws(() => quantity.ToUnit(unsupportedUnitSystem)); + } + + [Theory] + [InlineData("en-US", "4.2 n/cm²", FluenceUnit.NeutronPerSquareCentimeter, 4.2)] + [InlineData("en-US", "4.2 n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter, 4.2)] + public void Parse(string culture, string quantityString, FluenceUnit expectedUnit, double expectedValue) + { + using var _ = new CultureScope(culture); + var parsed = Fluence.Parse(quantityString); + Assert.Equal(expectedUnit, parsed.Unit); + Assert.Equal(expectedValue, parsed.Value); + } + + [Theory] + [InlineData("en-US", "4.2 n/cm²", FluenceUnit.NeutronPerSquareCentimeter, 4.2)] + [InlineData("en-US", "4.2 n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter, 4.2)] + public void TryParse(string culture, string quantityString, FluenceUnit expectedUnit, double expectedValue) + { + using var _ = new CultureScope(culture); + Assert.True(Fluence.TryParse(quantityString, out Fluence parsed)); + Assert.Equal(expectedUnit, parsed.Unit); + Assert.Equal(expectedValue, parsed.Value); + } + + [Theory] + [InlineData("n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, FluenceUnit expectedUnit) + { + // Fallback culture "en-US" is always localized + using var _ = new CultureScope("en-US"); + FluenceUnit parsedUnit = Fluence.ParseUnit(abbreviation); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, FluenceUnit expectedUnit) + { + // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. + using var _ = new CultureScope("is-IS"); + FluenceUnit parsedUnit = Fluence.ParseUnit(abbreviation); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("en-US", "n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("en-US", "n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, FluenceUnit expectedUnit) + { + using var _ = new CultureScope(culture); + FluenceUnit parsedUnit = Fluence.ParseUnit(abbreviation); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("en-US", "n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("en-US", "n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void ParseUnit_WithCulture(string culture, string abbreviation, FluenceUnit expectedUnit) + { + FluenceUnit parsedUnit = Fluence.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, FluenceUnit expectedUnit) + { + // Fallback culture "en-US" is always localized + using var _ = new CultureScope("en-US"); + Assert.True(Fluence.TryParseUnit(abbreviation, out FluenceUnit parsedUnit)); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, FluenceUnit expectedUnit) + { + // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. + using var _ = new CultureScope("is-IS"); + Assert.True(Fluence.TryParseUnit(abbreviation, out FluenceUnit parsedUnit)); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("en-US", "n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("en-US", "n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, FluenceUnit expectedUnit) + { + using var _ = new CultureScope(culture); + Assert.True(Fluence.TryParseUnit(abbreviation, out FluenceUnit parsedUnit)); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("en-US", "n/cm²", FluenceUnit.NeutronPerSquareCentimeter)] + [InlineData("en-US", "n·cm⁻²", FluenceUnit.NeutronPerSquareCentimeter)] + public void TryParseUnit_WithCulture(string culture, string abbreviation, FluenceUnit expectedUnit) + { + Assert.True(Fluence.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out FluenceUnit parsedUnit)); + Assert.Equal(expectedUnit, parsedUnit); + } + + [Theory] + [InlineData("en-US", FluenceUnit.NeutronPerSquareCentimeter, "n/cm²")] + public void GetAbbreviationForCulture(string culture, FluenceUnit unit, string expectedAbbreviation) + { + var defaultAbbreviation = Fluence.GetAbbreviation(unit, CultureInfo.GetCultureInfo(culture)); + Assert.Equal(expectedAbbreviation, defaultAbbreviation); + } + + [Fact] + public void GetAbbreviationWithDefaultCulture() + { + Assert.All(Fluence.Units, unit => + { + var expectedAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit); + + var defaultAbbreviation = Fluence.GetAbbreviation(unit); + + Assert.Equal(expectedAbbreviation, defaultAbbreviation); + }); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit(FluenceUnit unit) + { + var inBaseUnits = Fluence.From(1.0, Fluence.BaseUnit); + var converted = inBaseUnits.ToUnit(unit); + + var conversionFactor = GetConversionFactor(unit); + AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, converted.Value, conversionFactor.Tolerence); + Assert.Equal(unit, converted.Unit); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit_WithSameUnits_AreEqual(FluenceUnit unit) + { + var quantity = Fluence.From(3.0, unit); + var toUnitWithSameUnit = quantity.ToUnit(unit); + Assert.Equal(quantity, toUnitWithSameUnit); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(FluenceUnit unit) + { + Assert.All(Fluence.Units.Where(u => u != Fluence.BaseUnit), fromUnit => + { + var quantity = Fluence.From(3.0, fromUnit); + var converted = quantity.ToUnit(unit); + Assert.Equal(converted.Unit, unit); + }); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(FluenceUnit unit) + { + var quantity = default(Fluence); + var converted = quantity.ToUnit(unit); + Assert.Equal(converted.Unit, unit); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit_FromIQuantity_ReturnsTheExpectedIQuantity(FluenceUnit unit) + { + var quantity = Fluence.From(3, Fluence.BaseUnit); + Fluence expectedQuantity = quantity.ToUnit(unit); + Assert.Multiple(() => + { + IQuantity quantityToConvert = quantity; + IQuantity convertedQuantity = quantityToConvert.ToUnit(unit); + Assert.Equal(unit, convertedQuantity.Unit); + }, () => + { + IQuantity quantityToConvert = quantity; + IQuantity convertedQuantity = quantityToConvert.ToUnit(unit); + Assert.Equal(unit, convertedQuantity.Unit); + }); + } + + [Fact] + public void ConversionRoundTrip() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + AssertEx.EqualTolerance(1, Fluence.FromNeutronsPerSquareCentimeter(neutronpersquarecentimeter.NeutronsPerSquareCentimeter).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + } + + [Fact] + public void ArithmeticOperators() + { + Fluence v = Fluence.FromNeutronsPerSquareCentimeter(1); + AssertEx.EqualTolerance(-1, -v.NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(2, (Fluence.FromNeutronsPerSquareCentimeter(3)-v).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(2, (v + v).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(10, (v*10).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(10, (10*v).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(2, (Fluence.FromNeutronsPerSquareCentimeter(10)/5).NeutronsPerSquareCentimeter, NeutronsPerSquareCentimeterTolerance); + AssertEx.EqualTolerance(2, Fluence.FromNeutronsPerSquareCentimeter(10)/Fluence.FromNeutronsPerSquareCentimeter(5), NeutronsPerSquareCentimeterTolerance); + } + + [Fact] + public void ComparisonOperators() + { + Fluence oneNeutronPerSquareCentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Fluence twoNeutronsPerSquareCentimeter = Fluence.FromNeutronsPerSquareCentimeter(2); + + Assert.True(oneNeutronPerSquareCentimeter < twoNeutronsPerSquareCentimeter); + Assert.True(oneNeutronPerSquareCentimeter <= twoNeutronsPerSquareCentimeter); + Assert.True(twoNeutronsPerSquareCentimeter > oneNeutronPerSquareCentimeter); + Assert.True(twoNeutronsPerSquareCentimeter >= oneNeutronPerSquareCentimeter); + + Assert.False(oneNeutronPerSquareCentimeter > twoNeutronsPerSquareCentimeter); + Assert.False(oneNeutronPerSquareCentimeter >= twoNeutronsPerSquareCentimeter); + Assert.False(twoNeutronsPerSquareCentimeter < oneNeutronPerSquareCentimeter); + Assert.False(twoNeutronsPerSquareCentimeter <= oneNeutronPerSquareCentimeter); + } + + [Fact] + public void CompareToIsImplemented() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Assert.Equal(0, neutronpersquarecentimeter.CompareTo(neutronpersquarecentimeter)); + Assert.True(neutronpersquarecentimeter.CompareTo(Fluence.Zero) > 0); + Assert.True(Fluence.Zero.CompareTo(neutronpersquarecentimeter) < 0); + } + + [Fact] + public void CompareToThrowsOnTypeMismatch() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Assert.Throws(() => neutronpersquarecentimeter.CompareTo(new object())); + } + + [Fact] + public void CompareToThrowsOnNull() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Assert.Throws(() => neutronpersquarecentimeter.CompareTo(null)); + } + + [Theory] + [InlineData(1, FluenceUnit.NeutronPerSquareCentimeter, 1, FluenceUnit.NeutronPerSquareCentimeter, true)] // Same value and unit. + [InlineData(1, FluenceUnit.NeutronPerSquareCentimeter, 2, FluenceUnit.NeutronPerSquareCentimeter, false)] // Different value. + [InlineData(2, FluenceUnit.NeutronPerSquareCentimeter, 1, FluenceUnit.NeutronPerSquareCentimeter, false)] // Different value and unit. + public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, FluenceUnit unitA, double valueB, FluenceUnit unitB, bool expectEqual) + { + var a = new Fluence(valueA, unitA); + var b = new Fluence(valueB, unitB); + + // Operator overloads. + Assert.Equal(expectEqual, a == b); + Assert.Equal(expectEqual, b == a); + Assert.Equal(!expectEqual, a != b); + Assert.Equal(!expectEqual, b != a); + + // IEquatable + Assert.Equal(expectEqual, a.Equals(b)); + Assert.Equal(expectEqual, b.Equals(a)); + + // IEquatable + Assert.Equal(expectEqual, a.Equals((object)b)); + Assert.Equal(expectEqual, b.Equals((object)a)); + } + + [Fact] + public void Equals_Null_ReturnsFalse() + { + var a = Fluence.Zero; + + Assert.False(a.Equals((object)null)); + + // "The result of the expression is always 'false'..." + #pragma warning disable CS8073 + Assert.False(a == null); + Assert.False(null == a); + Assert.True(a != null); + Assert.True(null != a); + #pragma warning restore CS8073 + } + + [Fact] + public void EqualsReturnsFalseOnTypeMismatch() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Assert.False(neutronpersquarecentimeter.Equals(new object())); + } + + [Fact] + public void EqualsReturnsFalseOnNull() + { + Fluence neutronpersquarecentimeter = Fluence.FromNeutronsPerSquareCentimeter(1); + Assert.False(neutronpersquarecentimeter.Equals(null)); + } + + [Theory] + [InlineData(1, 2)] + [InlineData(100, 110)] + [InlineData(100, 90)] + public void Equals_WithTolerance(double firstValue, double secondValue) + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(firstValue); + var otherQuantity = Fluence.FromNeutronsPerSquareCentimeter(secondValue); + Fluence maxTolerance = quantity > otherQuantity ? quantity - otherQuantity : otherQuantity - quantity; + var largerTolerance = maxTolerance * 1.1; + var smallerTolerance = maxTolerance / 1.1; + Assert.True(quantity.Equals(quantity, Fluence.Zero)); + Assert.True(quantity.Equals(quantity, maxTolerance)); + Assert.True(quantity.Equals(otherQuantity, maxTolerance)); + Assert.True(quantity.Equals(otherQuantity, largerTolerance)); + Assert.False(quantity.Equals(otherQuantity, smallerTolerance)); + } + + [Fact] + public void Equals_WithNegativeTolerance_ThrowsArgumentOutOfRangeException() + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(1); + var negativeTolerance = Fluence.FromNeutronsPerSquareCentimeter(-1); + Assert.Throws(() => quantity.Equals(quantity, negativeTolerance)); + } + + [Fact] + public void HasAtLeastOneAbbreviationSpecified() + { + var units = Enum.GetValues(); + foreach (var unit in units) + { + var defaultAbbreviation = UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit); + } + } + + [Fact] + public void BaseDimensionsShouldNeverBeNull() + { + Assert.False(Fluence.BaseDimensions is null); + } + + [Fact] + public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() + { + using var _ = new CultureScope("en-US"); + Assert.Equal("1 n/cm²", new Fluence(1, FluenceUnit.NeutronPerSquareCentimeter).ToString()); + } + + [Fact] + public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings() + { + // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback. + var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); + + Assert.Equal("1 n/cm²", new Fluence(1, FluenceUnit.NeutronPerSquareCentimeter).ToString(swedishCulture)); + } + + [Fact] + public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture() + { + var _ = new CultureScope(CultureInfo.InvariantCulture); + Assert.Equal("0.1 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s1")); + Assert.Equal("0.12 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s2")); + Assert.Equal("0.123 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s3")); + Assert.Equal("0.1235 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s4")); + } + + [Fact] + public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture() + { + var culture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s1", culture)); + Assert.Equal("0.12 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s2", culture)); + Assert.Equal("0.123 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s3", culture)); + Assert.Equal("0.1235 n/cm²", new Fluence(0.123456, FluenceUnit.NeutronPerSquareCentimeter).ToString("s4", culture)); + } + + [Theory] + [InlineData(null)] + [InlineData("en-US")] + public void ToString_NullFormat_DefaultsToGeneralFormat(string cultureName) + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(1.0); + CultureInfo formatProvider = cultureName == null + ? null + : CultureInfo.GetCultureInfo(cultureName); + + Assert.Equal(quantity.ToString("G", formatProvider), quantity.ToString(null, formatProvider)); + } + + [Theory] + [InlineData(null)] + [InlineData("g")] + public void ToString_NullProvider_EqualsCurrentCulture(string format) + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(1.0); + Assert.Equal(quantity.ToString(format, CultureInfo.CurrentCulture), quantity.ToString(format, null)); + } + + [Fact] + public void GetHashCode_Equals() + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(1.0); + Assert.Equal(Comparison.GetHashCode(quantity.Unit, quantity.Value), quantity.GetHashCode()); + } + + [Theory] + [InlineData(1.0)] + [InlineData(-1.0)] + public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) + { + var quantity = Fluence.FromNeutronsPerSquareCentimeter(value); + Assert.Equal(Fluence.FromNeutronsPerSquareCentimeter(-value), -quantity); + } + } +} diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs index 1920ba333f..00e260f957 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PowerTestsBase.g.cs @@ -42,28 +42,41 @@ public abstract partial class PowerTestsBase : QuantityTestsBase { protected abstract double BoilerHorsepowerInOneWatt { get; } protected abstract double BritishThermalUnitsPerHourInOneWatt { get; } + protected abstract double DecapascalCubicMeterPerSecondInOneWatt { get; } protected abstract double DecawattsInOneWatt { get; } + protected abstract double DecipascalCubicMeterPerSecondInOneWatt { get; } protected abstract double DeciwattsInOneWatt { get; } protected abstract double ElectricalHorsepowerInOneWatt { get; } + protected abstract double FemtopascalCubicMeterPerSecondInOneWatt { get; } protected abstract double FemtowattsInOneWatt { get; } protected abstract double GigajoulesPerHourInOneWatt { get; } + protected abstract double GigapascalCubicMeterPerSecondInOneWatt { get; } protected abstract double GigawattsInOneWatt { get; } protected abstract double HydraulicHorsepowerInOneWatt { get; } protected abstract double JoulesPerHourInOneWatt { get; } protected abstract double KilobritishThermalUnitsPerHourInOneWatt { get; } protected abstract double KilojoulesPerHourInOneWatt { get; } + protected abstract double KilopascalCubicMeterPerSecondInOneWatt { get; } protected abstract double KilowattsInOneWatt { get; } protected abstract double MechanicalHorsepowerInOneWatt { get; } protected abstract double MegabritishThermalUnitsPerHourInOneWatt { get; } protected abstract double MegajoulesPerHourInOneWatt { get; } + protected abstract double MegapascalCubicMeterPerSecondInOneWatt { get; } protected abstract double MegawattsInOneWatt { get; } protected abstract double MetricHorsepowerInOneWatt { get; } + protected abstract double MicropascalCubicMeterPerSecondInOneWatt { get; } protected abstract double MicrowattsInOneWatt { get; } protected abstract double MillijoulesPerHourInOneWatt { get; } + protected abstract double MillipascalCubicMeterPerSecondInOneWatt { get; } protected abstract double MilliwattsInOneWatt { get; } + protected abstract double NanopascalCubicMeterPerSecondInOneWatt { get; } protected abstract double NanowattsInOneWatt { get; } + protected abstract double PascalCubicMeterPerSecondInOneWatt { get; } + protected abstract double PetapascalCubicMeterPerSecondInOneWatt { get; } protected abstract double PetawattsInOneWatt { get; } + protected abstract double PicopascalCubicMeterPerSecondInOneWatt { get; } protected abstract double PicowattsInOneWatt { get; } + protected abstract double TerapascalCubicMeterPerSecondInOneWatt { get; } protected abstract double TerawattsInOneWatt { get; } protected abstract double TonsOfRefrigerationInOneWatt { get; } protected abstract double WattsInOneWatt { get; } @@ -71,28 +84,41 @@ public abstract partial class PowerTestsBase : QuantityTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double BoilerHorsepowerTolerance { get { return 1e-5; } } protected virtual double BritishThermalUnitsPerHourTolerance { get { return 1e-5; } } + protected virtual double DecapascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double DecawattsTolerance { get { return 1e-5; } } + protected virtual double DecipascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double DeciwattsTolerance { get { return 1e-5; } } protected virtual double ElectricalHorsepowerTolerance { get { return 1e-5; } } + protected virtual double FemtopascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double FemtowattsTolerance { get { return 1e-5; } } protected virtual double GigajoulesPerHourTolerance { get { return 1e-5; } } + protected virtual double GigapascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double GigawattsTolerance { get { return 1e-5; } } protected virtual double HydraulicHorsepowerTolerance { get { return 1e-5; } } protected virtual double JoulesPerHourTolerance { get { return 1e-5; } } protected virtual double KilobritishThermalUnitsPerHourTolerance { get { return 1e-5; } } protected virtual double KilojoulesPerHourTolerance { get { return 1e-5; } } + protected virtual double KilopascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double KilowattsTolerance { get { return 1e-5; } } protected virtual double MechanicalHorsepowerTolerance { get { return 1e-5; } } protected virtual double MegabritishThermalUnitsPerHourTolerance { get { return 1e-5; } } protected virtual double MegajoulesPerHourTolerance { get { return 1e-5; } } + protected virtual double MegapascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double MegawattsTolerance { get { return 1e-5; } } protected virtual double MetricHorsepowerTolerance { get { return 1e-5; } } + protected virtual double MicropascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double MicrowattsTolerance { get { return 1e-5; } } protected virtual double MillijoulesPerHourTolerance { get { return 1e-5; } } + protected virtual double MillipascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double MilliwattsTolerance { get { return 1e-5; } } + protected virtual double NanopascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double NanowattsTolerance { get { return 1e-5; } } + protected virtual double PascalCubicMeterPerSecondTolerance { get { return 1e-5; } } + protected virtual double PetapascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double PetawattsTolerance { get { return 1e-5; } } + protected virtual double PicopascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double PicowattsTolerance { get { return 1e-5; } } + protected virtual double TerapascalCubicMeterPerSecondTolerance { get { return 1e-5; } } protected virtual double TerawattsTolerance { get { return 1e-5; } } protected virtual double TonsOfRefrigerationTolerance { get { return 1e-5; } } protected virtual double WattsTolerance { get { return 1e-5; } } @@ -104,28 +130,41 @@ public abstract partial class PowerTestsBase : QuantityTestsBase { PowerUnit.BoilerHorsepower => (BoilerHorsepowerInOneWatt, BoilerHorsepowerTolerance), PowerUnit.BritishThermalUnitPerHour => (BritishThermalUnitsPerHourInOneWatt, BritishThermalUnitsPerHourTolerance), + PowerUnit.DecapascalCubicMeterPerSecond => (DecapascalCubicMeterPerSecondInOneWatt, DecapascalCubicMeterPerSecondTolerance), PowerUnit.Decawatt => (DecawattsInOneWatt, DecawattsTolerance), + PowerUnit.DecipascalCubicMeterPerSecond => (DecipascalCubicMeterPerSecondInOneWatt, DecipascalCubicMeterPerSecondTolerance), PowerUnit.Deciwatt => (DeciwattsInOneWatt, DeciwattsTolerance), PowerUnit.ElectricalHorsepower => (ElectricalHorsepowerInOneWatt, ElectricalHorsepowerTolerance), + PowerUnit.FemtopascalCubicMeterPerSecond => (FemtopascalCubicMeterPerSecondInOneWatt, FemtopascalCubicMeterPerSecondTolerance), PowerUnit.Femtowatt => (FemtowattsInOneWatt, FemtowattsTolerance), PowerUnit.GigajoulePerHour => (GigajoulesPerHourInOneWatt, GigajoulesPerHourTolerance), + PowerUnit.GigapascalCubicMeterPerSecond => (GigapascalCubicMeterPerSecondInOneWatt, GigapascalCubicMeterPerSecondTolerance), PowerUnit.Gigawatt => (GigawattsInOneWatt, GigawattsTolerance), PowerUnit.HydraulicHorsepower => (HydraulicHorsepowerInOneWatt, HydraulicHorsepowerTolerance), PowerUnit.JoulePerHour => (JoulesPerHourInOneWatt, JoulesPerHourTolerance), PowerUnit.KilobritishThermalUnitPerHour => (KilobritishThermalUnitsPerHourInOneWatt, KilobritishThermalUnitsPerHourTolerance), PowerUnit.KilojoulePerHour => (KilojoulesPerHourInOneWatt, KilojoulesPerHourTolerance), + PowerUnit.KilopascalCubicMeterPerSecond => (KilopascalCubicMeterPerSecondInOneWatt, KilopascalCubicMeterPerSecondTolerance), PowerUnit.Kilowatt => (KilowattsInOneWatt, KilowattsTolerance), PowerUnit.MechanicalHorsepower => (MechanicalHorsepowerInOneWatt, MechanicalHorsepowerTolerance), PowerUnit.MegabritishThermalUnitPerHour => (MegabritishThermalUnitsPerHourInOneWatt, MegabritishThermalUnitsPerHourTolerance), PowerUnit.MegajoulePerHour => (MegajoulesPerHourInOneWatt, MegajoulesPerHourTolerance), + PowerUnit.MegapascalCubicMeterPerSecond => (MegapascalCubicMeterPerSecondInOneWatt, MegapascalCubicMeterPerSecondTolerance), PowerUnit.Megawatt => (MegawattsInOneWatt, MegawattsTolerance), PowerUnit.MetricHorsepower => (MetricHorsepowerInOneWatt, MetricHorsepowerTolerance), + PowerUnit.MicropascalCubicMeterPerSecond => (MicropascalCubicMeterPerSecondInOneWatt, MicropascalCubicMeterPerSecondTolerance), PowerUnit.Microwatt => (MicrowattsInOneWatt, MicrowattsTolerance), PowerUnit.MillijoulePerHour => (MillijoulesPerHourInOneWatt, MillijoulesPerHourTolerance), + PowerUnit.MillipascalCubicMeterPerSecond => (MillipascalCubicMeterPerSecondInOneWatt, MillipascalCubicMeterPerSecondTolerance), PowerUnit.Milliwatt => (MilliwattsInOneWatt, MilliwattsTolerance), + PowerUnit.NanopascalCubicMeterPerSecond => (NanopascalCubicMeterPerSecondInOneWatt, NanopascalCubicMeterPerSecondTolerance), PowerUnit.Nanowatt => (NanowattsInOneWatt, NanowattsTolerance), + PowerUnit.PascalCubicMeterPerSecond => (PascalCubicMeterPerSecondInOneWatt, PascalCubicMeterPerSecondTolerance), + PowerUnit.PetapascalCubicMeterPerSecond => (PetapascalCubicMeterPerSecondInOneWatt, PetapascalCubicMeterPerSecondTolerance), PowerUnit.Petawatt => (PetawattsInOneWatt, PetawattsTolerance), + PowerUnit.PicopascalCubicMeterPerSecond => (PicopascalCubicMeterPerSecondInOneWatt, PicopascalCubicMeterPerSecondTolerance), PowerUnit.Picowatt => (PicowattsInOneWatt, PicowattsTolerance), + PowerUnit.TerapascalCubicMeterPerSecond => (TerapascalCubicMeterPerSecondInOneWatt, TerapascalCubicMeterPerSecondTolerance), PowerUnit.Terawatt => (TerawattsInOneWatt, TerawattsTolerance), PowerUnit.TonOfRefrigeration => (TonsOfRefrigerationInOneWatt, TonsOfRefrigerationTolerance), PowerUnit.Watt => (WattsInOneWatt, WattsTolerance), @@ -137,28 +176,41 @@ public abstract partial class PowerTestsBase : QuantityTestsBase { new object[] { PowerUnit.BoilerHorsepower }, new object[] { PowerUnit.BritishThermalUnitPerHour }, + new object[] { PowerUnit.DecapascalCubicMeterPerSecond }, new object[] { PowerUnit.Decawatt }, + new object[] { PowerUnit.DecipascalCubicMeterPerSecond }, new object[] { PowerUnit.Deciwatt }, new object[] { PowerUnit.ElectricalHorsepower }, + new object[] { PowerUnit.FemtopascalCubicMeterPerSecond }, new object[] { PowerUnit.Femtowatt }, new object[] { PowerUnit.GigajoulePerHour }, + new object[] { PowerUnit.GigapascalCubicMeterPerSecond }, new object[] { PowerUnit.Gigawatt }, new object[] { PowerUnit.HydraulicHorsepower }, new object[] { PowerUnit.JoulePerHour }, new object[] { PowerUnit.KilobritishThermalUnitPerHour }, new object[] { PowerUnit.KilojoulePerHour }, + new object[] { PowerUnit.KilopascalCubicMeterPerSecond }, new object[] { PowerUnit.Kilowatt }, new object[] { PowerUnit.MechanicalHorsepower }, new object[] { PowerUnit.MegabritishThermalUnitPerHour }, new object[] { PowerUnit.MegajoulePerHour }, + new object[] { PowerUnit.MegapascalCubicMeterPerSecond }, new object[] { PowerUnit.Megawatt }, new object[] { PowerUnit.MetricHorsepower }, + new object[] { PowerUnit.MicropascalCubicMeterPerSecond }, new object[] { PowerUnit.Microwatt }, new object[] { PowerUnit.MillijoulePerHour }, + new object[] { PowerUnit.MillipascalCubicMeterPerSecond }, new object[] { PowerUnit.Milliwatt }, + new object[] { PowerUnit.NanopascalCubicMeterPerSecond }, new object[] { PowerUnit.Nanowatt }, + new object[] { PowerUnit.PascalCubicMeterPerSecond }, + new object[] { PowerUnit.PetapascalCubicMeterPerSecond }, new object[] { PowerUnit.Petawatt }, + new object[] { PowerUnit.PicopascalCubicMeterPerSecond }, new object[] { PowerUnit.Picowatt }, + new object[] { PowerUnit.TerapascalCubicMeterPerSecond }, new object[] { PowerUnit.Terawatt }, new object[] { PowerUnit.TonOfRefrigeration }, new object[] { PowerUnit.Watt }, @@ -235,28 +287,41 @@ public void WattToPowerUnits() Power watt = Power.FromWatts(1); AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.BoilerHorsepower, BoilerHorsepowerTolerance); AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.BritishThermalUnitsPerHour, BritishThermalUnitsPerHourTolerance); + AssertEx.EqualTolerance(DecapascalCubicMeterPerSecondInOneWatt, watt.DecapascalCubicMeterPerSecond, DecapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(DecawattsInOneWatt, watt.Decawatts, DecawattsTolerance); + AssertEx.EqualTolerance(DecipascalCubicMeterPerSecondInOneWatt, watt.DecipascalCubicMeterPerSecond, DecipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.Deciwatts, DeciwattsTolerance); AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, watt.ElectricalHorsepower, ElectricalHorsepowerTolerance); + AssertEx.EqualTolerance(FemtopascalCubicMeterPerSecondInOneWatt, watt.FemtopascalCubicMeterPerSecond, FemtopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.Femtowatts, FemtowattsTolerance); AssertEx.EqualTolerance(GigajoulesPerHourInOneWatt, watt.GigajoulesPerHour, GigajoulesPerHourTolerance); + AssertEx.EqualTolerance(GigapascalCubicMeterPerSecondInOneWatt, watt.GigapascalCubicMeterPerSecond, GigapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(GigawattsInOneWatt, watt.Gigawatts, GigawattsTolerance); AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, watt.HydraulicHorsepower, HydraulicHorsepowerTolerance); AssertEx.EqualTolerance(JoulesPerHourInOneWatt, watt.JoulesPerHour, JoulesPerHourTolerance); AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, watt.KilobritishThermalUnitsPerHour, KilobritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(KilojoulesPerHourInOneWatt, watt.KilojoulesPerHour, KilojoulesPerHourTolerance); + AssertEx.EqualTolerance(KilopascalCubicMeterPerSecondInOneWatt, watt.KilopascalCubicMeterPerSecond, KilopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(KilowattsInOneWatt, watt.Kilowatts, KilowattsTolerance); AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, watt.MechanicalHorsepower, MechanicalHorsepowerTolerance); AssertEx.EqualTolerance(MegabritishThermalUnitsPerHourInOneWatt, watt.MegabritishThermalUnitsPerHour, MegabritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(MegajoulesPerHourInOneWatt, watt.MegajoulesPerHour, MegajoulesPerHourTolerance); + AssertEx.EqualTolerance(MegapascalCubicMeterPerSecondInOneWatt, watt.MegapascalCubicMeterPerSecond, MegapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MegawattsInOneWatt, watt.Megawatts, MegawattsTolerance); AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, watt.MetricHorsepower, MetricHorsepowerTolerance); + AssertEx.EqualTolerance(MicropascalCubicMeterPerSecondInOneWatt, watt.MicropascalCubicMeterPerSecond, MicropascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.Microwatts, MicrowattsTolerance); AssertEx.EqualTolerance(MillijoulesPerHourInOneWatt, watt.MillijoulesPerHour, MillijoulesPerHourTolerance); + AssertEx.EqualTolerance(MillipascalCubicMeterPerSecondInOneWatt, watt.MillipascalCubicMeterPerSecond, MillipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.Milliwatts, MilliwattsTolerance); + AssertEx.EqualTolerance(NanopascalCubicMeterPerSecondInOneWatt, watt.NanopascalCubicMeterPerSecond, NanopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(NanowattsInOneWatt, watt.Nanowatts, NanowattsTolerance); + AssertEx.EqualTolerance(PascalCubicMeterPerSecondInOneWatt, watt.PascalCubicMeterPerSecond, PascalCubicMeterPerSecondTolerance); + AssertEx.EqualTolerance(PetapascalCubicMeterPerSecondInOneWatt, watt.PetapascalCubicMeterPerSecond, PetapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(PetawattsInOneWatt, watt.Petawatts, PetawattsTolerance); + AssertEx.EqualTolerance(PicopascalCubicMeterPerSecondInOneWatt, watt.PicopascalCubicMeterPerSecond, PicopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(PicowattsInOneWatt, watt.Picowatts, PicowattsTolerance); + AssertEx.EqualTolerance(TerapascalCubicMeterPerSecondInOneWatt, watt.TerapascalCubicMeterPerSecond, TerapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(TerawattsInOneWatt, watt.Terawatts, TerawattsTolerance); AssertEx.EqualTolerance(TonsOfRefrigerationInOneWatt, watt.TonsOfRefrigeration, TonsOfRefrigerationTolerance); AssertEx.EqualTolerance(WattsInOneWatt, watt.Watts, WattsTolerance); @@ -297,28 +362,41 @@ public void As() var watt = Power.FromWatts(1); AssertEx.EqualTolerance(BoilerHorsepowerInOneWatt, watt.As(PowerUnit.BoilerHorsepower), BoilerHorsepowerTolerance); AssertEx.EqualTolerance(BritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.BritishThermalUnitPerHour), BritishThermalUnitsPerHourTolerance); + AssertEx.EqualTolerance(DecapascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.DecapascalCubicMeterPerSecond), DecapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(DecawattsInOneWatt, watt.As(PowerUnit.Decawatt), DecawattsTolerance); + AssertEx.EqualTolerance(DecipascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.DecipascalCubicMeterPerSecond), DecipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(DeciwattsInOneWatt, watt.As(PowerUnit.Deciwatt), DeciwattsTolerance); AssertEx.EqualTolerance(ElectricalHorsepowerInOneWatt, watt.As(PowerUnit.ElectricalHorsepower), ElectricalHorsepowerTolerance); + AssertEx.EqualTolerance(FemtopascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.FemtopascalCubicMeterPerSecond), FemtopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(FemtowattsInOneWatt, watt.As(PowerUnit.Femtowatt), FemtowattsTolerance); AssertEx.EqualTolerance(GigajoulesPerHourInOneWatt, watt.As(PowerUnit.GigajoulePerHour), GigajoulesPerHourTolerance); + AssertEx.EqualTolerance(GigapascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.GigapascalCubicMeterPerSecond), GigapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(GigawattsInOneWatt, watt.As(PowerUnit.Gigawatt), GigawattsTolerance); AssertEx.EqualTolerance(HydraulicHorsepowerInOneWatt, watt.As(PowerUnit.HydraulicHorsepower), HydraulicHorsepowerTolerance); AssertEx.EqualTolerance(JoulesPerHourInOneWatt, watt.As(PowerUnit.JoulePerHour), JoulesPerHourTolerance); AssertEx.EqualTolerance(KilobritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.KilobritishThermalUnitPerHour), KilobritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(KilojoulesPerHourInOneWatt, watt.As(PowerUnit.KilojoulePerHour), KilojoulesPerHourTolerance); + AssertEx.EqualTolerance(KilopascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.KilopascalCubicMeterPerSecond), KilopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(KilowattsInOneWatt, watt.As(PowerUnit.Kilowatt), KilowattsTolerance); AssertEx.EqualTolerance(MechanicalHorsepowerInOneWatt, watt.As(PowerUnit.MechanicalHorsepower), MechanicalHorsepowerTolerance); AssertEx.EqualTolerance(MegabritishThermalUnitsPerHourInOneWatt, watt.As(PowerUnit.MegabritishThermalUnitPerHour), MegabritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(MegajoulesPerHourInOneWatt, watt.As(PowerUnit.MegajoulePerHour), MegajoulesPerHourTolerance); + AssertEx.EqualTolerance(MegapascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.MegapascalCubicMeterPerSecond), MegapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MegawattsInOneWatt, watt.As(PowerUnit.Megawatt), MegawattsTolerance); AssertEx.EqualTolerance(MetricHorsepowerInOneWatt, watt.As(PowerUnit.MetricHorsepower), MetricHorsepowerTolerance); + AssertEx.EqualTolerance(MicropascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.MicropascalCubicMeterPerSecond), MicropascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MicrowattsInOneWatt, watt.As(PowerUnit.Microwatt), MicrowattsTolerance); AssertEx.EqualTolerance(MillijoulesPerHourInOneWatt, watt.As(PowerUnit.MillijoulePerHour), MillijoulesPerHourTolerance); + AssertEx.EqualTolerance(MillipascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.MillipascalCubicMeterPerSecond), MillipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(MilliwattsInOneWatt, watt.As(PowerUnit.Milliwatt), MilliwattsTolerance); + AssertEx.EqualTolerance(NanopascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.NanopascalCubicMeterPerSecond), NanopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(NanowattsInOneWatt, watt.As(PowerUnit.Nanowatt), NanowattsTolerance); + AssertEx.EqualTolerance(PascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.PascalCubicMeterPerSecond), PascalCubicMeterPerSecondTolerance); + AssertEx.EqualTolerance(PetapascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.PetapascalCubicMeterPerSecond), PetapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(PetawattsInOneWatt, watt.As(PowerUnit.Petawatt), PetawattsTolerance); + AssertEx.EqualTolerance(PicopascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.PicopascalCubicMeterPerSecond), PicopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(PicowattsInOneWatt, watt.As(PowerUnit.Picowatt), PicowattsTolerance); + AssertEx.EqualTolerance(TerapascalCubicMeterPerSecondInOneWatt, watt.As(PowerUnit.TerapascalCubicMeterPerSecond), TerapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(TerawattsInOneWatt, watt.As(PowerUnit.Terawatt), TerawattsTolerance); AssertEx.EqualTolerance(TonsOfRefrigerationInOneWatt, watt.As(PowerUnit.TonOfRefrigeration), TonsOfRefrigerationTolerance); AssertEx.EqualTolerance(WattsInOneWatt, watt.As(PowerUnit.Watt), WattsTolerance); @@ -391,30 +469,43 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() [InlineData("en-US", "4.2 hp(S)", PowerUnit.BoilerHorsepower, 4.2)] [InlineData("en-US", "4.2 Btu/h", PowerUnit.BritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 Btu/hr", PowerUnit.BritishThermalUnitPerHour, 4.2)] + [InlineData("en-US", "4.2 daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 daW", PowerUnit.Decawatt, 4.2)] + [InlineData("en-US", "4.2 dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 dW", PowerUnit.Deciwatt, 4.2)] [InlineData("en-US", "4.2 hp(E)", PowerUnit.ElectricalHorsepower, 4.2)] + [InlineData("en-US", "4.2 fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 fW", PowerUnit.Femtowatt, 4.2)] [InlineData("en-US", "4.2 GJ/h", PowerUnit.GigajoulePerHour, 4.2)] + [InlineData("en-US", "4.2 GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 GW", PowerUnit.Gigawatt, 4.2)] [InlineData("en-US", "4.2 hp(H)", PowerUnit.HydraulicHorsepower, 4.2)] [InlineData("en-US", "4.2 J/h", PowerUnit.JoulePerHour, 4.2)] [InlineData("en-US", "4.2 kBtu/h", PowerUnit.KilobritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 kJ/h", PowerUnit.KilojoulePerHour, 4.2)] + [InlineData("en-US", "4.2 kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 kW", PowerUnit.Kilowatt, 4.2)] [InlineData("en-US", "4.2 hp(I)", PowerUnit.MechanicalHorsepower, 4.2)] [InlineData("en-US", "4.2 MBtu/h", PowerUnit.MegabritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 MJ/h", PowerUnit.MegajoulePerHour, 4.2)] + [InlineData("en-US", "4.2 MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 MW", PowerUnit.Megawatt, 4.2)] [InlineData("en-US", "4.2 hp(M)", PowerUnit.MetricHorsepower, 4.2)] + [InlineData("en-US", "4.2 µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 µW", PowerUnit.Microwatt, 4.2)] [InlineData("en-US", "4.2 mJ/h", PowerUnit.MillijoulePerHour, 4.2)] + [InlineData("en-US", "4.2 mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 mW", PowerUnit.Milliwatt, 4.2)] + [InlineData("en-US", "4.2 nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 nW", PowerUnit.Nanowatt, 4.2)] + [InlineData("en-US", "4.2 Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond, 4.2)] + [InlineData("en-US", "4.2 PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 PW", PowerUnit.Petawatt, 4.2)] + [InlineData("en-US", "4.2 pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 pW", PowerUnit.Picowatt, 4.2)] + [InlineData("en-US", "4.2 TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 TW", PowerUnit.Terawatt, 4.2)] [InlineData("en-US", "4.2 TR", PowerUnit.TonOfRefrigeration, 4.2)] [InlineData("en-US", "4.2 W", PowerUnit.Watt, 4.2)] @@ -430,30 +521,43 @@ public void Parse(string culture, string quantityString, PowerUnit expectedUnit, [InlineData("en-US", "4.2 hp(S)", PowerUnit.BoilerHorsepower, 4.2)] [InlineData("en-US", "4.2 Btu/h", PowerUnit.BritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 Btu/hr", PowerUnit.BritishThermalUnitPerHour, 4.2)] + [InlineData("en-US", "4.2 daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 daW", PowerUnit.Decawatt, 4.2)] + [InlineData("en-US", "4.2 dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 dW", PowerUnit.Deciwatt, 4.2)] [InlineData("en-US", "4.2 hp(E)", PowerUnit.ElectricalHorsepower, 4.2)] + [InlineData("en-US", "4.2 fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 fW", PowerUnit.Femtowatt, 4.2)] [InlineData("en-US", "4.2 GJ/h", PowerUnit.GigajoulePerHour, 4.2)] + [InlineData("en-US", "4.2 GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 GW", PowerUnit.Gigawatt, 4.2)] [InlineData("en-US", "4.2 hp(H)", PowerUnit.HydraulicHorsepower, 4.2)] [InlineData("en-US", "4.2 J/h", PowerUnit.JoulePerHour, 4.2)] [InlineData("en-US", "4.2 kBtu/h", PowerUnit.KilobritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 kJ/h", PowerUnit.KilojoulePerHour, 4.2)] + [InlineData("en-US", "4.2 kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 kW", PowerUnit.Kilowatt, 4.2)] [InlineData("en-US", "4.2 hp(I)", PowerUnit.MechanicalHorsepower, 4.2)] [InlineData("en-US", "4.2 MBtu/h", PowerUnit.MegabritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour, 4.2)] [InlineData("en-US", "4.2 MJ/h", PowerUnit.MegajoulePerHour, 4.2)] + [InlineData("en-US", "4.2 MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 MW", PowerUnit.Megawatt, 4.2)] [InlineData("en-US", "4.2 hp(M)", PowerUnit.MetricHorsepower, 4.2)] + [InlineData("en-US", "4.2 µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 µW", PowerUnit.Microwatt, 4.2)] [InlineData("en-US", "4.2 mJ/h", PowerUnit.MillijoulePerHour, 4.2)] + [InlineData("en-US", "4.2 mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 mW", PowerUnit.Milliwatt, 4.2)] + [InlineData("en-US", "4.2 nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 nW", PowerUnit.Nanowatt, 4.2)] + [InlineData("en-US", "4.2 Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond, 4.2)] + [InlineData("en-US", "4.2 PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 PW", PowerUnit.Petawatt, 4.2)] + [InlineData("en-US", "4.2 pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 pW", PowerUnit.Picowatt, 4.2)] + [InlineData("en-US", "4.2 TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond, 4.2)] [InlineData("en-US", "4.2 TW", PowerUnit.Terawatt, 4.2)] [InlineData("en-US", "4.2 TR", PowerUnit.TonOfRefrigeration, 4.2)] [InlineData("en-US", "4.2 W", PowerUnit.Watt, 4.2)] @@ -469,30 +573,43 @@ public void TryParse(string culture, string quantityString, PowerUnit expectedUn [InlineData("hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("daW", PowerUnit.Decawatt)] + [InlineData("dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("dW", PowerUnit.Deciwatt)] [InlineData("hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("fW", PowerUnit.Femtowatt)] [InlineData("GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("GW", PowerUnit.Gigawatt)] [InlineData("hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("J/h", PowerUnit.JoulePerHour)] [InlineData("kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("kW", PowerUnit.Kilowatt)] [InlineData("hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("MW", PowerUnit.Megawatt)] [InlineData("hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("µW", PowerUnit.Microwatt)] [InlineData("mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("mW", PowerUnit.Milliwatt)] + [InlineData("nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("nW", PowerUnit.Nanowatt)] + [InlineData("Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("PW", PowerUnit.Petawatt)] + [InlineData("pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("pW", PowerUnit.Picowatt)] + [InlineData("TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("TW", PowerUnit.Terawatt)] [InlineData("TR", PowerUnit.TonOfRefrigeration)] [InlineData("W", PowerUnit.Watt)] @@ -508,30 +625,43 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PowerUnit [InlineData("hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("daW", PowerUnit.Decawatt)] + [InlineData("dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("dW", PowerUnit.Deciwatt)] [InlineData("hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("fW", PowerUnit.Femtowatt)] [InlineData("GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("GW", PowerUnit.Gigawatt)] [InlineData("hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("J/h", PowerUnit.JoulePerHour)] [InlineData("kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("kW", PowerUnit.Kilowatt)] [InlineData("hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("MW", PowerUnit.Megawatt)] [InlineData("hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("µW", PowerUnit.Microwatt)] [InlineData("mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("mW", PowerUnit.Milliwatt)] + [InlineData("nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("nW", PowerUnit.Nanowatt)] + [InlineData("Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("PW", PowerUnit.Petawatt)] + [InlineData("pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("pW", PowerUnit.Picowatt)] + [InlineData("TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("TW", PowerUnit.Terawatt)] [InlineData("TR", PowerUnit.TonOfRefrigeration)] [InlineData("W", PowerUnit.Watt)] @@ -547,30 +677,43 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("en-US", "hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("en-US", "Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("en-US", "Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("en-US", "daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("en-US", "daW", PowerUnit.Decawatt)] + [InlineData("en-US", "dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("en-US", "dW", PowerUnit.Deciwatt)] [InlineData("en-US", "hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("en-US", "fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("en-US", "fW", PowerUnit.Femtowatt)] [InlineData("en-US", "GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("en-US", "GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("en-US", "GW", PowerUnit.Gigawatt)] [InlineData("en-US", "hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("en-US", "J/h", PowerUnit.JoulePerHour)] [InlineData("en-US", "kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("en-US", "kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("en-US", "kW", PowerUnit.Kilowatt)] [InlineData("en-US", "hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("en-US", "MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("en-US", "MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("en-US", "MW", PowerUnit.Megawatt)] [InlineData("en-US", "hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("en-US", "µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("en-US", "µW", PowerUnit.Microwatt)] [InlineData("en-US", "mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("en-US", "mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("en-US", "mW", PowerUnit.Milliwatt)] + [InlineData("en-US", "nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("en-US", "nW", PowerUnit.Nanowatt)] + [InlineData("en-US", "Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("en-US", "PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("en-US", "PW", PowerUnit.Petawatt)] + [InlineData("en-US", "pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("en-US", "pW", PowerUnit.Picowatt)] + [InlineData("en-US", "TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("en-US", "TW", PowerUnit.Terawatt)] [InlineData("en-US", "TR", PowerUnit.TonOfRefrigeration)] [InlineData("en-US", "W", PowerUnit.Watt)] @@ -585,30 +728,43 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Po [InlineData("en-US", "hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("en-US", "Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("en-US", "Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("en-US", "daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("en-US", "daW", PowerUnit.Decawatt)] + [InlineData("en-US", "dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("en-US", "dW", PowerUnit.Deciwatt)] [InlineData("en-US", "hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("en-US", "fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("en-US", "fW", PowerUnit.Femtowatt)] [InlineData("en-US", "GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("en-US", "GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("en-US", "GW", PowerUnit.Gigawatt)] [InlineData("en-US", "hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("en-US", "J/h", PowerUnit.JoulePerHour)] [InlineData("en-US", "kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("en-US", "kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("en-US", "kW", PowerUnit.Kilowatt)] [InlineData("en-US", "hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("en-US", "MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("en-US", "MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("en-US", "MW", PowerUnit.Megawatt)] [InlineData("en-US", "hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("en-US", "µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("en-US", "µW", PowerUnit.Microwatt)] [InlineData("en-US", "mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("en-US", "mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("en-US", "mW", PowerUnit.Milliwatt)] + [InlineData("en-US", "nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("en-US", "nW", PowerUnit.Nanowatt)] + [InlineData("en-US", "Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("en-US", "PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("en-US", "PW", PowerUnit.Petawatt)] + [InlineData("en-US", "pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("en-US", "pW", PowerUnit.Picowatt)] + [InlineData("en-US", "TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("en-US", "TW", PowerUnit.Terawatt)] [InlineData("en-US", "TR", PowerUnit.TonOfRefrigeration)] [InlineData("en-US", "W", PowerUnit.Watt)] @@ -622,30 +778,43 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, PowerUnit [InlineData("hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("daW", PowerUnit.Decawatt)] + [InlineData("dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("dW", PowerUnit.Deciwatt)] [InlineData("hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("fW", PowerUnit.Femtowatt)] [InlineData("GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("GW", PowerUnit.Gigawatt)] [InlineData("hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("J/h", PowerUnit.JoulePerHour)] [InlineData("kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("kW", PowerUnit.Kilowatt)] [InlineData("hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("MW", PowerUnit.Megawatt)] [InlineData("hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("µW", PowerUnit.Microwatt)] [InlineData("mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("mW", PowerUnit.Milliwatt)] + [InlineData("nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("nW", PowerUnit.Nanowatt)] + [InlineData("Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("PW", PowerUnit.Petawatt)] + [InlineData("pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("pW", PowerUnit.Picowatt)] + [InlineData("TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("TW", PowerUnit.Terawatt)] [InlineData("TR", PowerUnit.TonOfRefrigeration)] [InlineData("W", PowerUnit.Watt)] @@ -661,30 +830,43 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PowerU [InlineData("hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("daW", PowerUnit.Decawatt)] + [InlineData("dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("dW", PowerUnit.Deciwatt)] [InlineData("hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("fW", PowerUnit.Femtowatt)] [InlineData("GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("GW", PowerUnit.Gigawatt)] [InlineData("hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("J/h", PowerUnit.JoulePerHour)] [InlineData("kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("kW", PowerUnit.Kilowatt)] [InlineData("hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("MW", PowerUnit.Megawatt)] [InlineData("hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("µW", PowerUnit.Microwatt)] [InlineData("mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("mW", PowerUnit.Milliwatt)] + [InlineData("nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("nW", PowerUnit.Nanowatt)] + [InlineData("Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("PW", PowerUnit.Petawatt)] + [InlineData("pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("pW", PowerUnit.Picowatt)] + [InlineData("TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("TW", PowerUnit.Terawatt)] [InlineData("TR", PowerUnit.TonOfRefrigeration)] [InlineData("W", PowerUnit.Watt)] @@ -700,30 +882,43 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("en-US", "hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("en-US", "Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("en-US", "Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("en-US", "daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("en-US", "daW", PowerUnit.Decawatt)] + [InlineData("en-US", "dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("en-US", "dW", PowerUnit.Deciwatt)] [InlineData("en-US", "hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("en-US", "fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("en-US", "fW", PowerUnit.Femtowatt)] [InlineData("en-US", "GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("en-US", "GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("en-US", "GW", PowerUnit.Gigawatt)] [InlineData("en-US", "hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("en-US", "J/h", PowerUnit.JoulePerHour)] [InlineData("en-US", "kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("en-US", "kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("en-US", "kW", PowerUnit.Kilowatt)] [InlineData("en-US", "hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("en-US", "MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("en-US", "MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("en-US", "MW", PowerUnit.Megawatt)] [InlineData("en-US", "hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("en-US", "µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("en-US", "µW", PowerUnit.Microwatt)] [InlineData("en-US", "mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("en-US", "mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("en-US", "mW", PowerUnit.Milliwatt)] + [InlineData("en-US", "nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("en-US", "nW", PowerUnit.Nanowatt)] + [InlineData("en-US", "Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("en-US", "PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("en-US", "PW", PowerUnit.Petawatt)] + [InlineData("en-US", "pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("en-US", "pW", PowerUnit.Picowatt)] + [InlineData("en-US", "TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("en-US", "TW", PowerUnit.Terawatt)] [InlineData("en-US", "TR", PowerUnit.TonOfRefrigeration)] [InlineData("en-US", "W", PowerUnit.Watt)] @@ -738,30 +933,43 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("en-US", "hp(S)", PowerUnit.BoilerHorsepower)] [InlineData("en-US", "Btu/h", PowerUnit.BritishThermalUnitPerHour)] [InlineData("en-US", "Btu/hr", PowerUnit.BritishThermalUnitPerHour)] + [InlineData("en-US", "daPa.m³/s", PowerUnit.DecapascalCubicMeterPerSecond)] [InlineData("en-US", "daW", PowerUnit.Decawatt)] + [InlineData("en-US", "dPa.m³/s", PowerUnit.DecipascalCubicMeterPerSecond)] [InlineData("en-US", "dW", PowerUnit.Deciwatt)] [InlineData("en-US", "hp(E)", PowerUnit.ElectricalHorsepower)] + [InlineData("en-US", "fPa.m³/s", PowerUnit.FemtopascalCubicMeterPerSecond)] [InlineData("en-US", "fW", PowerUnit.Femtowatt)] [InlineData("en-US", "GJ/h", PowerUnit.GigajoulePerHour)] + [InlineData("en-US", "GPa.m³/s", PowerUnit.GigapascalCubicMeterPerSecond)] [InlineData("en-US", "GW", PowerUnit.Gigawatt)] [InlineData("en-US", "hp(H)", PowerUnit.HydraulicHorsepower)] [InlineData("en-US", "J/h", PowerUnit.JoulePerHour)] [InlineData("en-US", "kBtu/h", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kBtu/hr", PowerUnit.KilobritishThermalUnitPerHour)] [InlineData("en-US", "kJ/h", PowerUnit.KilojoulePerHour)] + [InlineData("en-US", "kPa.m³/s", PowerUnit.KilopascalCubicMeterPerSecond)] [InlineData("en-US", "kW", PowerUnit.Kilowatt)] [InlineData("en-US", "hp(I)", PowerUnit.MechanicalHorsepower)] [InlineData("en-US", "MBtu/h", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MBtu/hr", PowerUnit.MegabritishThermalUnitPerHour)] [InlineData("en-US", "MJ/h", PowerUnit.MegajoulePerHour)] + [InlineData("en-US", "MPa.m³/s", PowerUnit.MegapascalCubicMeterPerSecond)] [InlineData("en-US", "MW", PowerUnit.Megawatt)] [InlineData("en-US", "hp(M)", PowerUnit.MetricHorsepower)] + [InlineData("en-US", "µPa.m³/s", PowerUnit.MicropascalCubicMeterPerSecond)] [InlineData("en-US", "µW", PowerUnit.Microwatt)] [InlineData("en-US", "mJ/h", PowerUnit.MillijoulePerHour)] + [InlineData("en-US", "mPa.m³/s", PowerUnit.MillipascalCubicMeterPerSecond)] [InlineData("en-US", "mW", PowerUnit.Milliwatt)] + [InlineData("en-US", "nPa.m³/s", PowerUnit.NanopascalCubicMeterPerSecond)] [InlineData("en-US", "nW", PowerUnit.Nanowatt)] + [InlineData("en-US", "Pa.m³/s", PowerUnit.PascalCubicMeterPerSecond)] + [InlineData("en-US", "PPa.m³/s", PowerUnit.PetapascalCubicMeterPerSecond)] [InlineData("en-US", "PW", PowerUnit.Petawatt)] + [InlineData("en-US", "pPa.m³/s", PowerUnit.PicopascalCubicMeterPerSecond)] [InlineData("en-US", "pW", PowerUnit.Picowatt)] + [InlineData("en-US", "TPa.m³/s", PowerUnit.TerapascalCubicMeterPerSecond)] [InlineData("en-US", "TW", PowerUnit.Terawatt)] [InlineData("en-US", "TR", PowerUnit.TonOfRefrigeration)] [InlineData("en-US", "W", PowerUnit.Watt)] @@ -774,28 +982,41 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, PowerU [Theory] [InlineData("en-US", PowerUnit.BoilerHorsepower, "hp(S)")] [InlineData("en-US", PowerUnit.BritishThermalUnitPerHour, "Btu/h")] + [InlineData("en-US", PowerUnit.DecapascalCubicMeterPerSecond, "daPa.m³/s")] [InlineData("en-US", PowerUnit.Decawatt, "daW")] + [InlineData("en-US", PowerUnit.DecipascalCubicMeterPerSecond, "dPa.m³/s")] [InlineData("en-US", PowerUnit.Deciwatt, "dW")] [InlineData("en-US", PowerUnit.ElectricalHorsepower, "hp(E)")] + [InlineData("en-US", PowerUnit.FemtopascalCubicMeterPerSecond, "fPa.m³/s")] [InlineData("en-US", PowerUnit.Femtowatt, "fW")] [InlineData("en-US", PowerUnit.GigajoulePerHour, "GJ/h")] + [InlineData("en-US", PowerUnit.GigapascalCubicMeterPerSecond, "GPa.m³/s")] [InlineData("en-US", PowerUnit.Gigawatt, "GW")] [InlineData("en-US", PowerUnit.HydraulicHorsepower, "hp(H)")] [InlineData("en-US", PowerUnit.JoulePerHour, "J/h")] [InlineData("en-US", PowerUnit.KilobritishThermalUnitPerHour, "kBtu/h")] [InlineData("en-US", PowerUnit.KilojoulePerHour, "kJ/h")] + [InlineData("en-US", PowerUnit.KilopascalCubicMeterPerSecond, "kPa.m³/s")] [InlineData("en-US", PowerUnit.Kilowatt, "kW")] [InlineData("en-US", PowerUnit.MechanicalHorsepower, "hp(I)")] [InlineData("en-US", PowerUnit.MegabritishThermalUnitPerHour, "MBtu/h")] [InlineData("en-US", PowerUnit.MegajoulePerHour, "MJ/h")] + [InlineData("en-US", PowerUnit.MegapascalCubicMeterPerSecond, "MPa.m³/s")] [InlineData("en-US", PowerUnit.Megawatt, "MW")] [InlineData("en-US", PowerUnit.MetricHorsepower, "hp(M)")] + [InlineData("en-US", PowerUnit.MicropascalCubicMeterPerSecond, "µPa.m³/s")] [InlineData("en-US", PowerUnit.Microwatt, "µW")] [InlineData("en-US", PowerUnit.MillijoulePerHour, "mJ/h")] + [InlineData("en-US", PowerUnit.MillipascalCubicMeterPerSecond, "mPa.m³/s")] [InlineData("en-US", PowerUnit.Milliwatt, "mW")] + [InlineData("en-US", PowerUnit.NanopascalCubicMeterPerSecond, "nPa.m³/s")] [InlineData("en-US", PowerUnit.Nanowatt, "nW")] + [InlineData("en-US", PowerUnit.PascalCubicMeterPerSecond, "Pa.m³/s")] + [InlineData("en-US", PowerUnit.PetapascalCubicMeterPerSecond, "PPa.m³/s")] [InlineData("en-US", PowerUnit.Petawatt, "PW")] + [InlineData("en-US", PowerUnit.PicopascalCubicMeterPerSecond, "pPa.m³/s")] [InlineData("en-US", PowerUnit.Picowatt, "pW")] + [InlineData("en-US", PowerUnit.TerapascalCubicMeterPerSecond, "TPa.m³/s")] [InlineData("en-US", PowerUnit.Terawatt, "TW")] [InlineData("en-US", PowerUnit.TonOfRefrigeration, "TR")] [InlineData("en-US", PowerUnit.Watt, "W")] @@ -885,28 +1106,41 @@ public void ConversionRoundTrip() Power watt = Power.FromWatts(1); AssertEx.EqualTolerance(1, Power.FromBoilerHorsepower(watt.BoilerHorsepower).Watts, BoilerHorsepowerTolerance); AssertEx.EqualTolerance(1, Power.FromBritishThermalUnitsPerHour(watt.BritishThermalUnitsPerHour).Watts, BritishThermalUnitsPerHourTolerance); + AssertEx.EqualTolerance(1, Power.FromDecapascalCubicMeterPerSecond(watt.DecapascalCubicMeterPerSecond).Watts, DecapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromDecawatts(watt.Decawatts).Watts, DecawattsTolerance); + AssertEx.EqualTolerance(1, Power.FromDecipascalCubicMeterPerSecond(watt.DecipascalCubicMeterPerSecond).Watts, DecipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromDeciwatts(watt.Deciwatts).Watts, DeciwattsTolerance); AssertEx.EqualTolerance(1, Power.FromElectricalHorsepower(watt.ElectricalHorsepower).Watts, ElectricalHorsepowerTolerance); + AssertEx.EqualTolerance(1, Power.FromFemtopascalCubicMeterPerSecond(watt.FemtopascalCubicMeterPerSecond).Watts, FemtopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromFemtowatts(watt.Femtowatts).Watts, FemtowattsTolerance); AssertEx.EqualTolerance(1, Power.FromGigajoulesPerHour(watt.GigajoulesPerHour).Watts, GigajoulesPerHourTolerance); + AssertEx.EqualTolerance(1, Power.FromGigapascalCubicMeterPerSecond(watt.GigapascalCubicMeterPerSecond).Watts, GigapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromGigawatts(watt.Gigawatts).Watts, GigawattsTolerance); AssertEx.EqualTolerance(1, Power.FromHydraulicHorsepower(watt.HydraulicHorsepower).Watts, HydraulicHorsepowerTolerance); AssertEx.EqualTolerance(1, Power.FromJoulesPerHour(watt.JoulesPerHour).Watts, JoulesPerHourTolerance); AssertEx.EqualTolerance(1, Power.FromKilobritishThermalUnitsPerHour(watt.KilobritishThermalUnitsPerHour).Watts, KilobritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(1, Power.FromKilojoulesPerHour(watt.KilojoulesPerHour).Watts, KilojoulesPerHourTolerance); + AssertEx.EqualTolerance(1, Power.FromKilopascalCubicMeterPerSecond(watt.KilopascalCubicMeterPerSecond).Watts, KilopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromKilowatts(watt.Kilowatts).Watts, KilowattsTolerance); AssertEx.EqualTolerance(1, Power.FromMechanicalHorsepower(watt.MechanicalHorsepower).Watts, MechanicalHorsepowerTolerance); AssertEx.EqualTolerance(1, Power.FromMegabritishThermalUnitsPerHour(watt.MegabritishThermalUnitsPerHour).Watts, MegabritishThermalUnitsPerHourTolerance); AssertEx.EqualTolerance(1, Power.FromMegajoulesPerHour(watt.MegajoulesPerHour).Watts, MegajoulesPerHourTolerance); + AssertEx.EqualTolerance(1, Power.FromMegapascalCubicMeterPerSecond(watt.MegapascalCubicMeterPerSecond).Watts, MegapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromMegawatts(watt.Megawatts).Watts, MegawattsTolerance); AssertEx.EqualTolerance(1, Power.FromMetricHorsepower(watt.MetricHorsepower).Watts, MetricHorsepowerTolerance); + AssertEx.EqualTolerance(1, Power.FromMicropascalCubicMeterPerSecond(watt.MicropascalCubicMeterPerSecond).Watts, MicropascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromMicrowatts(watt.Microwatts).Watts, MicrowattsTolerance); AssertEx.EqualTolerance(1, Power.FromMillijoulesPerHour(watt.MillijoulesPerHour).Watts, MillijoulesPerHourTolerance); + AssertEx.EqualTolerance(1, Power.FromMillipascalCubicMeterPerSecond(watt.MillipascalCubicMeterPerSecond).Watts, MillipascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromMilliwatts(watt.Milliwatts).Watts, MilliwattsTolerance); + AssertEx.EqualTolerance(1, Power.FromNanopascalCubicMeterPerSecond(watt.NanopascalCubicMeterPerSecond).Watts, NanopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromNanowatts(watt.Nanowatts).Watts, NanowattsTolerance); + AssertEx.EqualTolerance(1, Power.FromPascalCubicMeterPerSecond(watt.PascalCubicMeterPerSecond).Watts, PascalCubicMeterPerSecondTolerance); + AssertEx.EqualTolerance(1, Power.FromPetapascalCubicMeterPerSecond(watt.PetapascalCubicMeterPerSecond).Watts, PetapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromPetawatts(watt.Petawatts).Watts, PetawattsTolerance); + AssertEx.EqualTolerance(1, Power.FromPicopascalCubicMeterPerSecond(watt.PicopascalCubicMeterPerSecond).Watts, PicopascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromPicowatts(watt.Picowatts).Watts, PicowattsTolerance); + AssertEx.EqualTolerance(1, Power.FromTerapascalCubicMeterPerSecond(watt.TerapascalCubicMeterPerSecond).Watts, TerapascalCubicMeterPerSecondTolerance); AssertEx.EqualTolerance(1, Power.FromTerawatts(watt.Terawatts).Watts, TerawattsTolerance); AssertEx.EqualTolerance(1, Power.FromTonsOfRefrigeration(watt.TonsOfRefrigeration).Watts, TonsOfRefrigerationTolerance); AssertEx.EqualTolerance(1, Power.FromWatts(watt.Watts).Watts, WattsTolerance); @@ -1068,28 +1302,41 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() using var _ = new CultureScope("en-US"); Assert.Equal("1 hp(S)", new Power(1, PowerUnit.BoilerHorsepower).ToString()); Assert.Equal("1 Btu/h", new Power(1, PowerUnit.BritishThermalUnitPerHour).ToString()); + Assert.Equal("1 daPa.m³/s", new Power(1, PowerUnit.DecapascalCubicMeterPerSecond).ToString()); Assert.Equal("1 daW", new Power(1, PowerUnit.Decawatt).ToString()); + Assert.Equal("1 dPa.m³/s", new Power(1, PowerUnit.DecipascalCubicMeterPerSecond).ToString()); Assert.Equal("1 dW", new Power(1, PowerUnit.Deciwatt).ToString()); Assert.Equal("1 hp(E)", new Power(1, PowerUnit.ElectricalHorsepower).ToString()); + Assert.Equal("1 fPa.m³/s", new Power(1, PowerUnit.FemtopascalCubicMeterPerSecond).ToString()); Assert.Equal("1 fW", new Power(1, PowerUnit.Femtowatt).ToString()); Assert.Equal("1 GJ/h", new Power(1, PowerUnit.GigajoulePerHour).ToString()); + Assert.Equal("1 GPa.m³/s", new Power(1, PowerUnit.GigapascalCubicMeterPerSecond).ToString()); Assert.Equal("1 GW", new Power(1, PowerUnit.Gigawatt).ToString()); Assert.Equal("1 hp(H)", new Power(1, PowerUnit.HydraulicHorsepower).ToString()); Assert.Equal("1 J/h", new Power(1, PowerUnit.JoulePerHour).ToString()); Assert.Equal("1 kBtu/h", new Power(1, PowerUnit.KilobritishThermalUnitPerHour).ToString()); Assert.Equal("1 kJ/h", new Power(1, PowerUnit.KilojoulePerHour).ToString()); + Assert.Equal("1 kPa.m³/s", new Power(1, PowerUnit.KilopascalCubicMeterPerSecond).ToString()); Assert.Equal("1 kW", new Power(1, PowerUnit.Kilowatt).ToString()); Assert.Equal("1 hp(I)", new Power(1, PowerUnit.MechanicalHorsepower).ToString()); Assert.Equal("1 MBtu/h", new Power(1, PowerUnit.MegabritishThermalUnitPerHour).ToString()); Assert.Equal("1 MJ/h", new Power(1, PowerUnit.MegajoulePerHour).ToString()); + Assert.Equal("1 MPa.m³/s", new Power(1, PowerUnit.MegapascalCubicMeterPerSecond).ToString()); Assert.Equal("1 MW", new Power(1, PowerUnit.Megawatt).ToString()); Assert.Equal("1 hp(M)", new Power(1, PowerUnit.MetricHorsepower).ToString()); + Assert.Equal("1 µPa.m³/s", new Power(1, PowerUnit.MicropascalCubicMeterPerSecond).ToString()); Assert.Equal("1 µW", new Power(1, PowerUnit.Microwatt).ToString()); Assert.Equal("1 mJ/h", new Power(1, PowerUnit.MillijoulePerHour).ToString()); + Assert.Equal("1 mPa.m³/s", new Power(1, PowerUnit.MillipascalCubicMeterPerSecond).ToString()); Assert.Equal("1 mW", new Power(1, PowerUnit.Milliwatt).ToString()); + Assert.Equal("1 nPa.m³/s", new Power(1, PowerUnit.NanopascalCubicMeterPerSecond).ToString()); Assert.Equal("1 nW", new Power(1, PowerUnit.Nanowatt).ToString()); + Assert.Equal("1 Pa.m³/s", new Power(1, PowerUnit.PascalCubicMeterPerSecond).ToString()); + Assert.Equal("1 PPa.m³/s", new Power(1, PowerUnit.PetapascalCubicMeterPerSecond).ToString()); Assert.Equal("1 PW", new Power(1, PowerUnit.Petawatt).ToString()); + Assert.Equal("1 pPa.m³/s", new Power(1, PowerUnit.PicopascalCubicMeterPerSecond).ToString()); Assert.Equal("1 pW", new Power(1, PowerUnit.Picowatt).ToString()); + Assert.Equal("1 TPa.m³/s", new Power(1, PowerUnit.TerapascalCubicMeterPerSecond).ToString()); Assert.Equal("1 TW", new Power(1, PowerUnit.Terawatt).ToString()); Assert.Equal("1 TR", new Power(1, PowerUnit.TonOfRefrigeration).ToString()); Assert.Equal("1 W", new Power(1, PowerUnit.Watt).ToString()); @@ -1103,28 +1350,41 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 hp(S)", new Power(1, PowerUnit.BoilerHorsepower).ToString(swedishCulture)); Assert.Equal("1 Btu/h", new Power(1, PowerUnit.BritishThermalUnitPerHour).ToString(swedishCulture)); + Assert.Equal("1 daPa.m³/s", new Power(1, PowerUnit.DecapascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 daW", new Power(1, PowerUnit.Decawatt).ToString(swedishCulture)); + Assert.Equal("1 dPa.m³/s", new Power(1, PowerUnit.DecipascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 dW", new Power(1, PowerUnit.Deciwatt).ToString(swedishCulture)); Assert.Equal("1 hp(E)", new Power(1, PowerUnit.ElectricalHorsepower).ToString(swedishCulture)); + Assert.Equal("1 fPa.m³/s", new Power(1, PowerUnit.FemtopascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 fW", new Power(1, PowerUnit.Femtowatt).ToString(swedishCulture)); Assert.Equal("1 GJ/h", new Power(1, PowerUnit.GigajoulePerHour).ToString(swedishCulture)); + Assert.Equal("1 GPa.m³/s", new Power(1, PowerUnit.GigapascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 GW", new Power(1, PowerUnit.Gigawatt).ToString(swedishCulture)); Assert.Equal("1 hp(H)", new Power(1, PowerUnit.HydraulicHorsepower).ToString(swedishCulture)); Assert.Equal("1 J/h", new Power(1, PowerUnit.JoulePerHour).ToString(swedishCulture)); Assert.Equal("1 kBtu/h", new Power(1, PowerUnit.KilobritishThermalUnitPerHour).ToString(swedishCulture)); Assert.Equal("1 kJ/h", new Power(1, PowerUnit.KilojoulePerHour).ToString(swedishCulture)); + Assert.Equal("1 kPa.m³/s", new Power(1, PowerUnit.KilopascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 kW", new Power(1, PowerUnit.Kilowatt).ToString(swedishCulture)); Assert.Equal("1 hp(I)", new Power(1, PowerUnit.MechanicalHorsepower).ToString(swedishCulture)); Assert.Equal("1 MBtu/h", new Power(1, PowerUnit.MegabritishThermalUnitPerHour).ToString(swedishCulture)); Assert.Equal("1 MJ/h", new Power(1, PowerUnit.MegajoulePerHour).ToString(swedishCulture)); + Assert.Equal("1 MPa.m³/s", new Power(1, PowerUnit.MegapascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 MW", new Power(1, PowerUnit.Megawatt).ToString(swedishCulture)); Assert.Equal("1 hp(M)", new Power(1, PowerUnit.MetricHorsepower).ToString(swedishCulture)); + Assert.Equal("1 µPa.m³/s", new Power(1, PowerUnit.MicropascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 µW", new Power(1, PowerUnit.Microwatt).ToString(swedishCulture)); Assert.Equal("1 mJ/h", new Power(1, PowerUnit.MillijoulePerHour).ToString(swedishCulture)); + Assert.Equal("1 mPa.m³/s", new Power(1, PowerUnit.MillipascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 mW", new Power(1, PowerUnit.Milliwatt).ToString(swedishCulture)); + Assert.Equal("1 nPa.m³/s", new Power(1, PowerUnit.NanopascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 nW", new Power(1, PowerUnit.Nanowatt).ToString(swedishCulture)); + Assert.Equal("1 Pa.m³/s", new Power(1, PowerUnit.PascalCubicMeterPerSecond).ToString(swedishCulture)); + Assert.Equal("1 PPa.m³/s", new Power(1, PowerUnit.PetapascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 PW", new Power(1, PowerUnit.Petawatt).ToString(swedishCulture)); + Assert.Equal("1 pPa.m³/s", new Power(1, PowerUnit.PicopascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 pW", new Power(1, PowerUnit.Picowatt).ToString(swedishCulture)); + Assert.Equal("1 TPa.m³/s", new Power(1, PowerUnit.TerapascalCubicMeterPerSecond).ToString(swedishCulture)); Assert.Equal("1 TW", new Power(1, PowerUnit.Terawatt).ToString(swedishCulture)); Assert.Equal("1 TR", new Power(1, PowerUnit.TonOfRefrigeration).ToString(swedishCulture)); Assert.Equal("1 W", new Power(1, PowerUnit.Watt).ToString(swedishCulture)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs index fbb8444297..18d4cc0fd6 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureTestsBase.g.cs @@ -42,17 +42,24 @@ public abstract partial class PressureTestsBase : QuantityTestsBase { protected abstract double AtmospheresInOnePascal { get; } protected abstract double BarsInOnePascal { get; } + protected abstract double BarsGInOnePascal { get; } protected abstract double CentibarsInOnePascal { get; } + protected abstract double CentibarsGInOnePascal { get; } protected abstract double CentimetersOfWaterColumnInOnePascal { get; } protected abstract double DecapascalsInOnePascal { get; } + protected abstract double DecapascalsGInOnePascal { get; } protected abstract double DecibarsInOnePascal { get; } + protected abstract double DecibarsGInOnePascal { get; } protected abstract double DynesPerSquareCentimeterInOnePascal { get; } protected abstract double FeetOfHeadInOnePascal { get; } protected abstract double GigapascalsInOnePascal { get; } + protected abstract double GigapascalsGInOnePascal { get; } protected abstract double HectopascalsInOnePascal { get; } + protected abstract double HectopascalsGInOnePascal { get; } protected abstract double InchesOfMercuryInOnePascal { get; } protected abstract double InchesOfWaterColumnInOnePascal { get; } protected abstract double KilobarsInOnePascal { get; } + protected abstract double KilobarsGInOnePascal { get; } protected abstract double KilogramsForcePerSquareCentimeterInOnePascal { get; } protected abstract double KilogramsForcePerSquareMeterInOnePascal { get; } protected abstract double KilogramsForcePerSquareMillimeterInOnePascal { get; } @@ -60,25 +67,33 @@ public abstract partial class PressureTestsBase : QuantityTestsBase protected abstract double KilonewtonsPerSquareMeterInOnePascal { get; } protected abstract double KilonewtonsPerSquareMillimeterInOnePascal { get; } protected abstract double KilopascalsInOnePascal { get; } + protected abstract double KilopascalsGInOnePascal { get; } protected abstract double KilopoundsForcePerSquareFootInOnePascal { get; } protected abstract double KilopoundsForcePerSquareInchInOnePascal { get; } protected abstract double KilopoundsForcePerSquareMilInOnePascal { get; } protected abstract double MegabarsInOnePascal { get; } + protected abstract double MegabarsGInOnePascal { get; } protected abstract double MeganewtonsPerSquareMeterInOnePascal { get; } protected abstract double MegapascalsInOnePascal { get; } + protected abstract double MegapascalsGInOnePascal { get; } protected abstract double MetersOfHeadInOnePascal { get; } protected abstract double MetersOfWaterColumnInOnePascal { get; } protected abstract double MicrobarsInOnePascal { get; } + protected abstract double MicrobarsGInOnePascal { get; } protected abstract double MicropascalsInOnePascal { get; } + protected abstract double MicropascalsGInOnePascal { get; } protected abstract double MillibarsInOnePascal { get; } + protected abstract double MillibarsGInOnePascal { get; } protected abstract double MillimetersOfMercuryInOnePascal { get; } protected abstract double MillimetersOfWaterColumnInOnePascal { get; } protected abstract double MillipascalsInOnePascal { get; } + protected abstract double MillipascalsGInOnePascal { get; } protected abstract double MillitorrsInOnePascal { get; } protected abstract double NewtonsPerSquareCentimeterInOnePascal { get; } protected abstract double NewtonsPerSquareMeterInOnePascal { get; } protected abstract double NewtonsPerSquareMillimeterInOnePascal { get; } protected abstract double PascalsInOnePascal { get; } + protected abstract double PascalsGInOnePascal { get; } protected abstract double PoundsForcePerSquareFootInOnePascal { get; } protected abstract double PoundsForcePerSquareInchInOnePascal { get; } protected abstract double PoundsForcePerSquareMilInOnePascal { get; } @@ -92,17 +107,24 @@ public abstract partial class PressureTestsBase : QuantityTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double AtmospheresTolerance { get { return 1e-5; } } protected virtual double BarsTolerance { get { return 1e-5; } } + protected virtual double BarsGTolerance { get { return 1e-5; } } protected virtual double CentibarsTolerance { get { return 1e-5; } } + protected virtual double CentibarsGTolerance { get { return 1e-5; } } protected virtual double CentimetersOfWaterColumnTolerance { get { return 1e-5; } } protected virtual double DecapascalsTolerance { get { return 1e-5; } } + protected virtual double DecapascalsGTolerance { get { return 1e-5; } } protected virtual double DecibarsTolerance { get { return 1e-5; } } + protected virtual double DecibarsGTolerance { get { return 1e-5; } } protected virtual double DynesPerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double FeetOfHeadTolerance { get { return 1e-5; } } protected virtual double GigapascalsTolerance { get { return 1e-5; } } + protected virtual double GigapascalsGTolerance { get { return 1e-5; } } protected virtual double HectopascalsTolerance { get { return 1e-5; } } + protected virtual double HectopascalsGTolerance { get { return 1e-5; } } protected virtual double InchesOfMercuryTolerance { get { return 1e-5; } } protected virtual double InchesOfWaterColumnTolerance { get { return 1e-5; } } protected virtual double KilobarsTolerance { get { return 1e-5; } } + protected virtual double KilobarsGTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareMeterTolerance { get { return 1e-5; } } protected virtual double KilogramsForcePerSquareMillimeterTolerance { get { return 1e-5; } } @@ -110,25 +132,33 @@ public abstract partial class PressureTestsBase : QuantityTestsBase protected virtual double KilonewtonsPerSquareMeterTolerance { get { return 1e-5; } } protected virtual double KilonewtonsPerSquareMillimeterTolerance { get { return 1e-5; } } protected virtual double KilopascalsTolerance { get { return 1e-5; } } + protected virtual double KilopascalsGTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareFootTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareInchTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareMilTolerance { get { return 1e-5; } } protected virtual double MegabarsTolerance { get { return 1e-5; } } + protected virtual double MegabarsGTolerance { get { return 1e-5; } } protected virtual double MeganewtonsPerSquareMeterTolerance { get { return 1e-5; } } protected virtual double MegapascalsTolerance { get { return 1e-5; } } + protected virtual double MegapascalsGTolerance { get { return 1e-5; } } protected virtual double MetersOfHeadTolerance { get { return 1e-5; } } protected virtual double MetersOfWaterColumnTolerance { get { return 1e-5; } } protected virtual double MicrobarsTolerance { get { return 1e-5; } } + protected virtual double MicrobarsGTolerance { get { return 1e-5; } } protected virtual double MicropascalsTolerance { get { return 1e-5; } } + protected virtual double MicropascalsGTolerance { get { return 1e-5; } } protected virtual double MillibarsTolerance { get { return 1e-5; } } + protected virtual double MillibarsGTolerance { get { return 1e-5; } } protected virtual double MillimetersOfMercuryTolerance { get { return 1e-5; } } protected virtual double MillimetersOfWaterColumnTolerance { get { return 1e-5; } } protected virtual double MillipascalsTolerance { get { return 1e-5; } } + protected virtual double MillipascalsGTolerance { get { return 1e-5; } } protected virtual double MillitorrsTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareCentimeterTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareMeterTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSquareMillimeterTolerance { get { return 1e-5; } } protected virtual double PascalsTolerance { get { return 1e-5; } } + protected virtual double PascalsGTolerance { get { return 1e-5; } } protected virtual double PoundsForcePerSquareFootTolerance { get { return 1e-5; } } protected virtual double PoundsForcePerSquareInchTolerance { get { return 1e-5; } } protected virtual double PoundsForcePerSquareMilTolerance { get { return 1e-5; } } @@ -146,17 +176,24 @@ public abstract partial class PressureTestsBase : QuantityTestsBase { PressureUnit.Atmosphere => (AtmospheresInOnePascal, AtmospheresTolerance), PressureUnit.Bar => (BarsInOnePascal, BarsTolerance), + PressureUnit.BarG => (BarsGInOnePascal, BarsGTolerance), PressureUnit.Centibar => (CentibarsInOnePascal, CentibarsTolerance), + PressureUnit.CentibarG => (CentibarsGInOnePascal, CentibarsGTolerance), PressureUnit.CentimeterOfWaterColumn => (CentimetersOfWaterColumnInOnePascal, CentimetersOfWaterColumnTolerance), PressureUnit.Decapascal => (DecapascalsInOnePascal, DecapascalsTolerance), + PressureUnit.DecapascalG => (DecapascalsGInOnePascal, DecapascalsGTolerance), PressureUnit.Decibar => (DecibarsInOnePascal, DecibarsTolerance), + PressureUnit.DecibarG => (DecibarsGInOnePascal, DecibarsGTolerance), PressureUnit.DynePerSquareCentimeter => (DynesPerSquareCentimeterInOnePascal, DynesPerSquareCentimeterTolerance), PressureUnit.FootOfHead => (FeetOfHeadInOnePascal, FeetOfHeadTolerance), PressureUnit.Gigapascal => (GigapascalsInOnePascal, GigapascalsTolerance), + PressureUnit.GigapascalG => (GigapascalsGInOnePascal, GigapascalsGTolerance), PressureUnit.Hectopascal => (HectopascalsInOnePascal, HectopascalsTolerance), + PressureUnit.HectopascalG => (HectopascalsGInOnePascal, HectopascalsGTolerance), PressureUnit.InchOfMercury => (InchesOfMercuryInOnePascal, InchesOfMercuryTolerance), PressureUnit.InchOfWaterColumn => (InchesOfWaterColumnInOnePascal, InchesOfWaterColumnTolerance), PressureUnit.Kilobar => (KilobarsInOnePascal, KilobarsTolerance), + PressureUnit.KilobarG => (KilobarsGInOnePascal, KilobarsGTolerance), PressureUnit.KilogramForcePerSquareCentimeter => (KilogramsForcePerSquareCentimeterInOnePascal, KilogramsForcePerSquareCentimeterTolerance), PressureUnit.KilogramForcePerSquareMeter => (KilogramsForcePerSquareMeterInOnePascal, KilogramsForcePerSquareMeterTolerance), PressureUnit.KilogramForcePerSquareMillimeter => (KilogramsForcePerSquareMillimeterInOnePascal, KilogramsForcePerSquareMillimeterTolerance), @@ -164,25 +201,33 @@ public abstract partial class PressureTestsBase : QuantityTestsBase PressureUnit.KilonewtonPerSquareMeter => (KilonewtonsPerSquareMeterInOnePascal, KilonewtonsPerSquareMeterTolerance), PressureUnit.KilonewtonPerSquareMillimeter => (KilonewtonsPerSquareMillimeterInOnePascal, KilonewtonsPerSquareMillimeterTolerance), PressureUnit.Kilopascal => (KilopascalsInOnePascal, KilopascalsTolerance), + PressureUnit.KilopascalG => (KilopascalsGInOnePascal, KilopascalsGTolerance), PressureUnit.KilopoundForcePerSquareFoot => (KilopoundsForcePerSquareFootInOnePascal, KilopoundsForcePerSquareFootTolerance), PressureUnit.KilopoundForcePerSquareInch => (KilopoundsForcePerSquareInchInOnePascal, KilopoundsForcePerSquareInchTolerance), PressureUnit.KilopoundForcePerSquareMil => (KilopoundsForcePerSquareMilInOnePascal, KilopoundsForcePerSquareMilTolerance), PressureUnit.Megabar => (MegabarsInOnePascal, MegabarsTolerance), + PressureUnit.MegabarG => (MegabarsGInOnePascal, MegabarsGTolerance), PressureUnit.MeganewtonPerSquareMeter => (MeganewtonsPerSquareMeterInOnePascal, MeganewtonsPerSquareMeterTolerance), PressureUnit.Megapascal => (MegapascalsInOnePascal, MegapascalsTolerance), + PressureUnit.MegapascalG => (MegapascalsGInOnePascal, MegapascalsGTolerance), PressureUnit.MeterOfHead => (MetersOfHeadInOnePascal, MetersOfHeadTolerance), PressureUnit.MeterOfWaterColumn => (MetersOfWaterColumnInOnePascal, MetersOfWaterColumnTolerance), PressureUnit.Microbar => (MicrobarsInOnePascal, MicrobarsTolerance), + PressureUnit.MicrobarG => (MicrobarsGInOnePascal, MicrobarsGTolerance), PressureUnit.Micropascal => (MicropascalsInOnePascal, MicropascalsTolerance), + PressureUnit.MicropascalG => (MicropascalsGInOnePascal, MicropascalsGTolerance), PressureUnit.Millibar => (MillibarsInOnePascal, MillibarsTolerance), + PressureUnit.MillibarG => (MillibarsGInOnePascal, MillibarsGTolerance), PressureUnit.MillimeterOfMercury => (MillimetersOfMercuryInOnePascal, MillimetersOfMercuryTolerance), PressureUnit.MillimeterOfWaterColumn => (MillimetersOfWaterColumnInOnePascal, MillimetersOfWaterColumnTolerance), PressureUnit.Millipascal => (MillipascalsInOnePascal, MillipascalsTolerance), + PressureUnit.MillipascalG => (MillipascalsGInOnePascal, MillipascalsGTolerance), PressureUnit.Millitorr => (MillitorrsInOnePascal, MillitorrsTolerance), PressureUnit.NewtonPerSquareCentimeter => (NewtonsPerSquareCentimeterInOnePascal, NewtonsPerSquareCentimeterTolerance), PressureUnit.NewtonPerSquareMeter => (NewtonsPerSquareMeterInOnePascal, NewtonsPerSquareMeterTolerance), PressureUnit.NewtonPerSquareMillimeter => (NewtonsPerSquareMillimeterInOnePascal, NewtonsPerSquareMillimeterTolerance), PressureUnit.Pascal => (PascalsInOnePascal, PascalsTolerance), + PressureUnit.PascalG => (PascalsGInOnePascal, PascalsGTolerance), PressureUnit.PoundForcePerSquareFoot => (PoundsForcePerSquareFootInOnePascal, PoundsForcePerSquareFootTolerance), PressureUnit.PoundForcePerSquareInch => (PoundsForcePerSquareInchInOnePascal, PoundsForcePerSquareInchTolerance), PressureUnit.PoundForcePerSquareMil => (PoundsForcePerSquareMilInOnePascal, PoundsForcePerSquareMilTolerance), @@ -200,17 +245,24 @@ public abstract partial class PressureTestsBase : QuantityTestsBase { new object[] { PressureUnit.Atmosphere }, new object[] { PressureUnit.Bar }, + new object[] { PressureUnit.BarG }, new object[] { PressureUnit.Centibar }, + new object[] { PressureUnit.CentibarG }, new object[] { PressureUnit.CentimeterOfWaterColumn }, new object[] { PressureUnit.Decapascal }, + new object[] { PressureUnit.DecapascalG }, new object[] { PressureUnit.Decibar }, + new object[] { PressureUnit.DecibarG }, new object[] { PressureUnit.DynePerSquareCentimeter }, new object[] { PressureUnit.FootOfHead }, new object[] { PressureUnit.Gigapascal }, + new object[] { PressureUnit.GigapascalG }, new object[] { PressureUnit.Hectopascal }, + new object[] { PressureUnit.HectopascalG }, new object[] { PressureUnit.InchOfMercury }, new object[] { PressureUnit.InchOfWaterColumn }, new object[] { PressureUnit.Kilobar }, + new object[] { PressureUnit.KilobarG }, new object[] { PressureUnit.KilogramForcePerSquareCentimeter }, new object[] { PressureUnit.KilogramForcePerSquareMeter }, new object[] { PressureUnit.KilogramForcePerSquareMillimeter }, @@ -218,25 +270,33 @@ public abstract partial class PressureTestsBase : QuantityTestsBase new object[] { PressureUnit.KilonewtonPerSquareMeter }, new object[] { PressureUnit.KilonewtonPerSquareMillimeter }, new object[] { PressureUnit.Kilopascal }, + new object[] { PressureUnit.KilopascalG }, new object[] { PressureUnit.KilopoundForcePerSquareFoot }, new object[] { PressureUnit.KilopoundForcePerSquareInch }, new object[] { PressureUnit.KilopoundForcePerSquareMil }, new object[] { PressureUnit.Megabar }, + new object[] { PressureUnit.MegabarG }, new object[] { PressureUnit.MeganewtonPerSquareMeter }, new object[] { PressureUnit.Megapascal }, + new object[] { PressureUnit.MegapascalG }, new object[] { PressureUnit.MeterOfHead }, new object[] { PressureUnit.MeterOfWaterColumn }, new object[] { PressureUnit.Microbar }, + new object[] { PressureUnit.MicrobarG }, new object[] { PressureUnit.Micropascal }, + new object[] { PressureUnit.MicropascalG }, new object[] { PressureUnit.Millibar }, + new object[] { PressureUnit.MillibarG }, new object[] { PressureUnit.MillimeterOfMercury }, new object[] { PressureUnit.MillimeterOfWaterColumn }, new object[] { PressureUnit.Millipascal }, + new object[] { PressureUnit.MillipascalG }, new object[] { PressureUnit.Millitorr }, new object[] { PressureUnit.NewtonPerSquareCentimeter }, new object[] { PressureUnit.NewtonPerSquareMeter }, new object[] { PressureUnit.NewtonPerSquareMillimeter }, new object[] { PressureUnit.Pascal }, + new object[] { PressureUnit.PascalG }, new object[] { PressureUnit.PoundForcePerSquareFoot }, new object[] { PressureUnit.PoundForcePerSquareInch }, new object[] { PressureUnit.PoundForcePerSquareMil }, @@ -319,17 +379,24 @@ public void PascalToPressureUnits() Pressure pascal = Pressure.FromPascals(1); AssertEx.EqualTolerance(AtmospheresInOnePascal, pascal.Atmospheres, AtmospheresTolerance); AssertEx.EqualTolerance(BarsInOnePascal, pascal.Bars, BarsTolerance); + AssertEx.EqualTolerance(BarsGInOnePascal, pascal.BarsG, BarsGTolerance); AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.Centibars, CentibarsTolerance); + AssertEx.EqualTolerance(CentibarsGInOnePascal, pascal.CentibarsG, CentibarsGTolerance); AssertEx.EqualTolerance(CentimetersOfWaterColumnInOnePascal, pascal.CentimetersOfWaterColumn, CentimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(DecapascalsInOnePascal, pascal.Decapascals, DecapascalsTolerance); + AssertEx.EqualTolerance(DecapascalsGInOnePascal, pascal.DecapascalsG, DecapascalsGTolerance); AssertEx.EqualTolerance(DecibarsInOnePascal, pascal.Decibars, DecibarsTolerance); + AssertEx.EqualTolerance(DecibarsGInOnePascal, pascal.DecibarsG, DecibarsGTolerance); AssertEx.EqualTolerance(DynesPerSquareCentimeterInOnePascal, pascal.DynesPerSquareCentimeter, DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(FeetOfHeadInOnePascal, pascal.FeetOfHead, FeetOfHeadTolerance); AssertEx.EqualTolerance(GigapascalsInOnePascal, pascal.Gigapascals, GigapascalsTolerance); + AssertEx.EqualTolerance(GigapascalsGInOnePascal, pascal.GigapascalsG, GigapascalsGTolerance); AssertEx.EqualTolerance(HectopascalsInOnePascal, pascal.Hectopascals, HectopascalsTolerance); + AssertEx.EqualTolerance(HectopascalsGInOnePascal, pascal.HectopascalsG, HectopascalsGTolerance); AssertEx.EqualTolerance(InchesOfMercuryInOnePascal, pascal.InchesOfMercury, InchesOfMercuryTolerance); AssertEx.EqualTolerance(InchesOfWaterColumnInOnePascal, pascal.InchesOfWaterColumn, InchesOfWaterColumnTolerance); AssertEx.EqualTolerance(KilobarsInOnePascal, pascal.Kilobars, KilobarsTolerance); + AssertEx.EqualTolerance(KilobarsGInOnePascal, pascal.KilobarsG, KilobarsGTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareCentimeterInOnePascal, pascal.KilogramsForcePerSquareCentimeter, KilogramsForcePerSquareCentimeterTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareMeterInOnePascal, pascal.KilogramsForcePerSquareMeter, KilogramsForcePerSquareMeterTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareMillimeterInOnePascal, pascal.KilogramsForcePerSquareMillimeter, KilogramsForcePerSquareMillimeterTolerance); @@ -337,25 +404,33 @@ public void PascalToPressureUnits() AssertEx.EqualTolerance(KilonewtonsPerSquareMeterInOnePascal, pascal.KilonewtonsPerSquareMeter, KilonewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(KilonewtonsPerSquareMillimeterInOnePascal, pascal.KilonewtonsPerSquareMillimeter, KilonewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(KilopascalsInOnePascal, pascal.Kilopascals, KilopascalsTolerance); + AssertEx.EqualTolerance(KilopascalsGInOnePascal, pascal.KilopascalsG, KilopascalsGTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareFootInOnePascal, pascal.KilopoundsForcePerSquareFoot, KilopoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareInchInOnePascal, pascal.KilopoundsForcePerSquareInch, KilopoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareMilInOnePascal, pascal.KilopoundsForcePerSquareMil, KilopoundsForcePerSquareMilTolerance); AssertEx.EqualTolerance(MegabarsInOnePascal, pascal.Megabars, MegabarsTolerance); + AssertEx.EqualTolerance(MegabarsGInOnePascal, pascal.MegabarsG, MegabarsGTolerance); AssertEx.EqualTolerance(MeganewtonsPerSquareMeterInOnePascal, pascal.MeganewtonsPerSquareMeter, MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(MegapascalsInOnePascal, pascal.Megapascals, MegapascalsTolerance); + AssertEx.EqualTolerance(MegapascalsGInOnePascal, pascal.MegapascalsG, MegapascalsGTolerance); AssertEx.EqualTolerance(MetersOfHeadInOnePascal, pascal.MetersOfHead, MetersOfHeadTolerance); AssertEx.EqualTolerance(MetersOfWaterColumnInOnePascal, pascal.MetersOfWaterColumn, MetersOfWaterColumnTolerance); AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.Microbars, MicrobarsTolerance); + AssertEx.EqualTolerance(MicrobarsGInOnePascal, pascal.MicrobarsG, MicrobarsGTolerance); AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.Micropascals, MicropascalsTolerance); + AssertEx.EqualTolerance(MicropascalsGInOnePascal, pascal.MicropascalsG, MicropascalsGTolerance); AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.Millibars, MillibarsTolerance); + AssertEx.EqualTolerance(MillibarsGInOnePascal, pascal.MillibarsG, MillibarsGTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.MillimetersOfMercury, MillimetersOfMercuryTolerance); AssertEx.EqualTolerance(MillimetersOfWaterColumnInOnePascal, pascal.MillimetersOfWaterColumn, MillimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(MillipascalsInOnePascal, pascal.Millipascals, MillipascalsTolerance); + AssertEx.EqualTolerance(MillipascalsGInOnePascal, pascal.MillipascalsG, MillipascalsGTolerance); AssertEx.EqualTolerance(MillitorrsInOnePascal, pascal.Millitorrs, MillitorrsTolerance); AssertEx.EqualTolerance(NewtonsPerSquareCentimeterInOnePascal, pascal.NewtonsPerSquareCentimeter, NewtonsPerSquareCentimeterTolerance); AssertEx.EqualTolerance(NewtonsPerSquareMeterInOnePascal, pascal.NewtonsPerSquareMeter, NewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(NewtonsPerSquareMillimeterInOnePascal, pascal.NewtonsPerSquareMillimeter, NewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(PascalsInOnePascal, pascal.Pascals, PascalsTolerance); + AssertEx.EqualTolerance(PascalsGInOnePascal, pascal.PascalsG, PascalsGTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareFootInOnePascal, pascal.PoundsForcePerSquareFoot, PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareInchInOnePascal, pascal.PoundsForcePerSquareInch, PoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareMilInOnePascal, pascal.PoundsForcePerSquareMil, PoundsForcePerSquareMilTolerance); @@ -402,17 +477,24 @@ public void As() var pascal = Pressure.FromPascals(1); AssertEx.EqualTolerance(AtmospheresInOnePascal, pascal.As(PressureUnit.Atmosphere), AtmospheresTolerance); AssertEx.EqualTolerance(BarsInOnePascal, pascal.As(PressureUnit.Bar), BarsTolerance); + AssertEx.EqualTolerance(BarsGInOnePascal, pascal.As(PressureUnit.BarG), BarsGTolerance); AssertEx.EqualTolerance(CentibarsInOnePascal, pascal.As(PressureUnit.Centibar), CentibarsTolerance); + AssertEx.EqualTolerance(CentibarsGInOnePascal, pascal.As(PressureUnit.CentibarG), CentibarsGTolerance); AssertEx.EqualTolerance(CentimetersOfWaterColumnInOnePascal, pascal.As(PressureUnit.CentimeterOfWaterColumn), CentimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(DecapascalsInOnePascal, pascal.As(PressureUnit.Decapascal), DecapascalsTolerance); + AssertEx.EqualTolerance(DecapascalsGInOnePascal, pascal.As(PressureUnit.DecapascalG), DecapascalsGTolerance); AssertEx.EqualTolerance(DecibarsInOnePascal, pascal.As(PressureUnit.Decibar), DecibarsTolerance); + AssertEx.EqualTolerance(DecibarsGInOnePascal, pascal.As(PressureUnit.DecibarG), DecibarsGTolerance); AssertEx.EqualTolerance(DynesPerSquareCentimeterInOnePascal, pascal.As(PressureUnit.DynePerSquareCentimeter), DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(FeetOfHeadInOnePascal, pascal.As(PressureUnit.FootOfHead), FeetOfHeadTolerance); AssertEx.EqualTolerance(GigapascalsInOnePascal, pascal.As(PressureUnit.Gigapascal), GigapascalsTolerance); + AssertEx.EqualTolerance(GigapascalsGInOnePascal, pascal.As(PressureUnit.GigapascalG), GigapascalsGTolerance); AssertEx.EqualTolerance(HectopascalsInOnePascal, pascal.As(PressureUnit.Hectopascal), HectopascalsTolerance); + AssertEx.EqualTolerance(HectopascalsGInOnePascal, pascal.As(PressureUnit.HectopascalG), HectopascalsGTolerance); AssertEx.EqualTolerance(InchesOfMercuryInOnePascal, pascal.As(PressureUnit.InchOfMercury), InchesOfMercuryTolerance); AssertEx.EqualTolerance(InchesOfWaterColumnInOnePascal, pascal.As(PressureUnit.InchOfWaterColumn), InchesOfWaterColumnTolerance); AssertEx.EqualTolerance(KilobarsInOnePascal, pascal.As(PressureUnit.Kilobar), KilobarsTolerance); + AssertEx.EqualTolerance(KilobarsGInOnePascal, pascal.As(PressureUnit.KilobarG), KilobarsGTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareCentimeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareCentimeter), KilogramsForcePerSquareCentimeterTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareMeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareMeter), KilogramsForcePerSquareMeterTolerance); AssertEx.EqualTolerance(KilogramsForcePerSquareMillimeterInOnePascal, pascal.As(PressureUnit.KilogramForcePerSquareMillimeter), KilogramsForcePerSquareMillimeterTolerance); @@ -420,25 +502,33 @@ public void As() AssertEx.EqualTolerance(KilonewtonsPerSquareMeterInOnePascal, pascal.As(PressureUnit.KilonewtonPerSquareMeter), KilonewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(KilonewtonsPerSquareMillimeterInOnePascal, pascal.As(PressureUnit.KilonewtonPerSquareMillimeter), KilonewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(KilopascalsInOnePascal, pascal.As(PressureUnit.Kilopascal), KilopascalsTolerance); + AssertEx.EqualTolerance(KilopascalsGInOnePascal, pascal.As(PressureUnit.KilopascalG), KilopascalsGTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareFootInOnePascal, pascal.As(PressureUnit.KilopoundForcePerSquareFoot), KilopoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareInchInOnePascal, pascal.As(PressureUnit.KilopoundForcePerSquareInch), KilopoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareMilInOnePascal, pascal.As(PressureUnit.KilopoundForcePerSquareMil), KilopoundsForcePerSquareMilTolerance); AssertEx.EqualTolerance(MegabarsInOnePascal, pascal.As(PressureUnit.Megabar), MegabarsTolerance); + AssertEx.EqualTolerance(MegabarsGInOnePascal, pascal.As(PressureUnit.MegabarG), MegabarsGTolerance); AssertEx.EqualTolerance(MeganewtonsPerSquareMeterInOnePascal, pascal.As(PressureUnit.MeganewtonPerSquareMeter), MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(MegapascalsInOnePascal, pascal.As(PressureUnit.Megapascal), MegapascalsTolerance); + AssertEx.EqualTolerance(MegapascalsGInOnePascal, pascal.As(PressureUnit.MegapascalG), MegapascalsGTolerance); AssertEx.EqualTolerance(MetersOfHeadInOnePascal, pascal.As(PressureUnit.MeterOfHead), MetersOfHeadTolerance); AssertEx.EqualTolerance(MetersOfWaterColumnInOnePascal, pascal.As(PressureUnit.MeterOfWaterColumn), MetersOfWaterColumnTolerance); AssertEx.EqualTolerance(MicrobarsInOnePascal, pascal.As(PressureUnit.Microbar), MicrobarsTolerance); + AssertEx.EqualTolerance(MicrobarsGInOnePascal, pascal.As(PressureUnit.MicrobarG), MicrobarsGTolerance); AssertEx.EqualTolerance(MicropascalsInOnePascal, pascal.As(PressureUnit.Micropascal), MicropascalsTolerance); + AssertEx.EqualTolerance(MicropascalsGInOnePascal, pascal.As(PressureUnit.MicropascalG), MicropascalsGTolerance); AssertEx.EqualTolerance(MillibarsInOnePascal, pascal.As(PressureUnit.Millibar), MillibarsTolerance); + AssertEx.EqualTolerance(MillibarsGInOnePascal, pascal.As(PressureUnit.MillibarG), MillibarsGTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryInOnePascal, pascal.As(PressureUnit.MillimeterOfMercury), MillimetersOfMercuryTolerance); AssertEx.EqualTolerance(MillimetersOfWaterColumnInOnePascal, pascal.As(PressureUnit.MillimeterOfWaterColumn), MillimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(MillipascalsInOnePascal, pascal.As(PressureUnit.Millipascal), MillipascalsTolerance); + AssertEx.EqualTolerance(MillipascalsGInOnePascal, pascal.As(PressureUnit.MillipascalG), MillipascalsGTolerance); AssertEx.EqualTolerance(MillitorrsInOnePascal, pascal.As(PressureUnit.Millitorr), MillitorrsTolerance); AssertEx.EqualTolerance(NewtonsPerSquareCentimeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareCentimeter), NewtonsPerSquareCentimeterTolerance); AssertEx.EqualTolerance(NewtonsPerSquareMeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareMeter), NewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(NewtonsPerSquareMillimeterInOnePascal, pascal.As(PressureUnit.NewtonPerSquareMillimeter), NewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(PascalsInOnePascal, pascal.As(PressureUnit.Pascal), PascalsTolerance); + AssertEx.EqualTolerance(PascalsGInOnePascal, pascal.As(PressureUnit.PascalG), PascalsGTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareFootInOnePascal, pascal.As(PressureUnit.PoundForcePerSquareFoot), PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareInchInOnePascal, pascal.As(PressureUnit.PoundForcePerSquareInch), PoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(PoundsForcePerSquareMilInOnePascal, pascal.As(PressureUnit.PoundForcePerSquareMil), PoundsForcePerSquareMilTolerance); @@ -516,22 +606,29 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() [Theory] [InlineData("en-US", "4.2 atm", PressureUnit.Atmosphere, 4.2)] [InlineData("en-US", "4.2 bar", PressureUnit.Bar, 4.2)] + [InlineData("en-US", "4.2 bar(g)", PressureUnit.BarG, 4.2)] [InlineData("en-US", "4.2 cbar", PressureUnit.Centibar, 4.2)] + [InlineData("en-US", "4.2 cbar(g)", PressureUnit.CentibarG, 4.2)] [InlineData("en-US", "4.2 cmH₂O", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cmH2O", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cm wc", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cm wg", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 daPa", PressureUnit.Decapascal, 4.2)] + [InlineData("en-US", "4.2 daPa(g)", PressureUnit.DecapascalG, 4.2)] [InlineData("en-US", "4.2 dbar", PressureUnit.Decibar, 4.2)] + [InlineData("en-US", "4.2 dbar(g)", PressureUnit.DecibarG, 4.2)] [InlineData("en-US", "4.2 dyn/cm²", PressureUnit.DynePerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 ft of head", PressureUnit.FootOfHead, 4.2)] [InlineData("en-US", "4.2 GPa", PressureUnit.Gigapascal, 4.2)] + [InlineData("en-US", "4.2 GPa(g)", PressureUnit.GigapascalG, 4.2)] [InlineData("en-US", "4.2 hPa", PressureUnit.Hectopascal, 4.2)] + [InlineData("en-US", "4.2 hPa(g)", PressureUnit.HectopascalG, 4.2)] [InlineData("en-US", "4.2 inHg", PressureUnit.InchOfMercury, 4.2)] [InlineData("en-US", "4.2 inH2O", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 inch wc", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 wc", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 kbar", PressureUnit.Kilobar, 4.2)] + [InlineData("en-US", "4.2 kbar(g)", PressureUnit.KilobarG, 4.2)] [InlineData("en-US", "4.2 kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 kgf/m²", PressureUnit.KilogramForcePerSquareMeter, 4.2)] [InlineData("en-US", "4.2 kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter, 4.2)] @@ -539,32 +636,40 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() [InlineData("en-US", "4.2 kN/m²", PressureUnit.KilonewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter, 4.2)] [InlineData("en-US", "4.2 kPa", PressureUnit.Kilopascal, 4.2)] + [InlineData("en-US", "4.2 kPa(g)", PressureUnit.KilopascalG, 4.2)] [InlineData("en-US", "4.2 kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot, 4.2)] [InlineData("en-US", "4.2 ksi", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 kipf/in²", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 kipf/mil²", PressureUnit.KilopoundForcePerSquareMil, 4.2)] [InlineData("en-US", "4.2 Mbar", PressureUnit.Megabar, 4.2)] + [InlineData("en-US", "4.2 Mbar(g)", PressureUnit.MegabarG, 4.2)] [InlineData("en-US", "4.2 MN/m²", PressureUnit.MeganewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 MPa", PressureUnit.Megapascal, 4.2)] + [InlineData("en-US", "4.2 MPa(g)", PressureUnit.MegapascalG, 4.2)] [InlineData("en-US", "4.2 m of head", PressureUnit.MeterOfHead, 4.2)] [InlineData("en-US", "4.2 mH₂O", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mH2O", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 m wc", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 m wg", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 µbar", PressureUnit.Microbar, 4.2)] + [InlineData("en-US", "4.2 µbar(g)", PressureUnit.MicrobarG, 4.2)] [InlineData("en-US", "4.2 µPa", PressureUnit.Micropascal, 4.2)] + [InlineData("en-US", "4.2 µPa(g)", PressureUnit.MicropascalG, 4.2)] [InlineData("en-US", "4.2 mbar", PressureUnit.Millibar, 4.2)] + [InlineData("en-US", "4.2 mbar(g)", PressureUnit.MillibarG, 4.2)] [InlineData("en-US", "4.2 mmHg", PressureUnit.MillimeterOfMercury, 4.2)] [InlineData("en-US", "4.2 mmH₂O", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mmH2O", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mm wc", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mm wg", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mPa", PressureUnit.Millipascal, 4.2)] + [InlineData("en-US", "4.2 mPa(g)", PressureUnit.MillipascalG, 4.2)] [InlineData("en-US", "4.2 mtorr", PressureUnit.Millitorr, 4.2)] [InlineData("en-US", "4.2 N/cm²", PressureUnit.NewtonPerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 N/m²", PressureUnit.NewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 N/mm²", PressureUnit.NewtonPerSquareMillimeter, 4.2)] [InlineData("en-US", "4.2 Pa", PressureUnit.Pascal, 4.2)] + [InlineData("en-US", "4.2 Pa(g)", PressureUnit.PascalG, 4.2)] [InlineData("en-US", "4.2 lb/ft²", PressureUnit.PoundForcePerSquareFoot, 4.2)] [InlineData("en-US", "4.2 psi", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)] @@ -579,12 +684,19 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() [InlineData("en-US", "4.2 torr", PressureUnit.Torr, 4.2)] [InlineData("ru-RU", "4,2 атм", PressureUnit.Atmosphere, 4.2)] [InlineData("ru-RU", "4,2 бар", PressureUnit.Bar, 4.2)] + [InlineData("ru-RU", "4,2 бар(g)", PressureUnit.BarG, 4.2)] [InlineData("ru-RU", "4,2 сбар", PressureUnit.Centibar, 4.2)] + [InlineData("ru-RU", "4,2 сбар(g)", PressureUnit.CentibarG, 4.2)] [InlineData("ru-RU", "4,2 даПа", PressureUnit.Decapascal, 4.2)] + [InlineData("ru-RU", "4,2 даПа(g)", PressureUnit.DecapascalG, 4.2)] [InlineData("ru-RU", "4,2 дбар", PressureUnit.Decibar, 4.2)] + [InlineData("ru-RU", "4,2 дбар(g)", PressureUnit.DecibarG, 4.2)] [InlineData("ru-RU", "4,2 ГПа", PressureUnit.Gigapascal, 4.2)] + [InlineData("ru-RU", "4,2 ГПа(g)", PressureUnit.GigapascalG, 4.2)] [InlineData("ru-RU", "4,2 гПа", PressureUnit.Hectopascal, 4.2)] + [InlineData("ru-RU", "4,2 гПа(g)", PressureUnit.HectopascalG, 4.2)] [InlineData("ru-RU", "4,2 кбар", PressureUnit.Kilobar, 4.2)] + [InlineData("ru-RU", "4,2 кбар(g)", PressureUnit.KilobarG, 4.2)] [InlineData("ru-RU", "4,2 кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter, 4.2)] [InlineData("ru-RU", "4,2 кгс/м²", PressureUnit.KilogramForcePerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter, 4.2)] @@ -592,21 +704,29 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported() [InlineData("ru-RU", "4,2 кН/м²", PressureUnit.KilonewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter, 4.2)] [InlineData("ru-RU", "4,2 кПа", PressureUnit.Kilopascal, 4.2)] + [InlineData("ru-RU", "4,2 кПа(g)", PressureUnit.KilopascalG, 4.2)] [InlineData("ru-RU", "4,2 ksi", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 kipf/in²", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 Мбар", PressureUnit.Megabar, 4.2)] + [InlineData("ru-RU", "4,2 Мбар(g)", PressureUnit.MegabarG, 4.2)] [InlineData("ru-RU", "4,2 МН/м²", PressureUnit.MeganewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 МПа", PressureUnit.Megapascal, 4.2)] + [InlineData("ru-RU", "4,2 МПа(g)", PressureUnit.MegapascalG, 4.2)] [InlineData("ru-RU", "4,2 мкбар", PressureUnit.Microbar, 4.2)] + [InlineData("ru-RU", "4,2 мкбар(g)", PressureUnit.MicrobarG, 4.2)] [InlineData("ru-RU", "4,2 мкПа", PressureUnit.Micropascal, 4.2)] + [InlineData("ru-RU", "4,2 мкПа(g)", PressureUnit.MicropascalG, 4.2)] [InlineData("ru-RU", "4,2 мбар", PressureUnit.Millibar, 4.2)] + [InlineData("ru-RU", "4,2 мбар(g)", PressureUnit.MillibarG, 4.2)] [InlineData("ru-RU", "4,2 мм рт.ст.", PressureUnit.MillimeterOfMercury, 4.2)] [InlineData("ru-RU", "4,2 мПа", PressureUnit.Millipascal, 4.2)] + [InlineData("ru-RU", "4,2 мПа(g)", PressureUnit.MillipascalG, 4.2)] [InlineData("ru-RU", "4,2 мторр", PressureUnit.Millitorr, 4.2)] [InlineData("ru-RU", "4,2 Н/см²", PressureUnit.NewtonPerSquareCentimeter, 4.2)] [InlineData("ru-RU", "4,2 Н/м²", PressureUnit.NewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 Н/мм²", PressureUnit.NewtonPerSquareMillimeter, 4.2)] [InlineData("ru-RU", "4,2 Па", PressureUnit.Pascal, 4.2)] + [InlineData("ru-RU", "4,2 Па(g)", PressureUnit.PascalG, 4.2)] [InlineData("ru-RU", "4,2 psi", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 ат", PressureUnit.TechnicalAtmosphere, 4.2)] @@ -622,22 +742,29 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn [Theory] [InlineData("en-US", "4.2 atm", PressureUnit.Atmosphere, 4.2)] [InlineData("en-US", "4.2 bar", PressureUnit.Bar, 4.2)] + [InlineData("en-US", "4.2 bar(g)", PressureUnit.BarG, 4.2)] [InlineData("en-US", "4.2 cbar", PressureUnit.Centibar, 4.2)] + [InlineData("en-US", "4.2 cbar(g)", PressureUnit.CentibarG, 4.2)] [InlineData("en-US", "4.2 cmH₂O", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cmH2O", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cm wc", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 cm wg", PressureUnit.CentimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 daPa", PressureUnit.Decapascal, 4.2)] + [InlineData("en-US", "4.2 daPa(g)", PressureUnit.DecapascalG, 4.2)] [InlineData("en-US", "4.2 dbar", PressureUnit.Decibar, 4.2)] + [InlineData("en-US", "4.2 dbar(g)", PressureUnit.DecibarG, 4.2)] [InlineData("en-US", "4.2 dyn/cm²", PressureUnit.DynePerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 ft of head", PressureUnit.FootOfHead, 4.2)] [InlineData("en-US", "4.2 GPa", PressureUnit.Gigapascal, 4.2)] + [InlineData("en-US", "4.2 GPa(g)", PressureUnit.GigapascalG, 4.2)] [InlineData("en-US", "4.2 hPa", PressureUnit.Hectopascal, 4.2)] + [InlineData("en-US", "4.2 hPa(g)", PressureUnit.HectopascalG, 4.2)] [InlineData("en-US", "4.2 inHg", PressureUnit.InchOfMercury, 4.2)] [InlineData("en-US", "4.2 inH2O", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 inch wc", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 wc", PressureUnit.InchOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 kbar", PressureUnit.Kilobar, 4.2)] + [InlineData("en-US", "4.2 kbar(g)", PressureUnit.KilobarG, 4.2)] [InlineData("en-US", "4.2 kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 kgf/m²", PressureUnit.KilogramForcePerSquareMeter, 4.2)] [InlineData("en-US", "4.2 kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter, 4.2)] @@ -645,32 +772,40 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn [InlineData("en-US", "4.2 kN/m²", PressureUnit.KilonewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter, 4.2)] [InlineData("en-US", "4.2 kPa", PressureUnit.Kilopascal, 4.2)] + [InlineData("en-US", "4.2 kPa(g)", PressureUnit.KilopascalG, 4.2)] [InlineData("en-US", "4.2 kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot, 4.2)] [InlineData("en-US", "4.2 ksi", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 kipf/in²", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 kipf/mil²", PressureUnit.KilopoundForcePerSquareMil, 4.2)] [InlineData("en-US", "4.2 Mbar", PressureUnit.Megabar, 4.2)] + [InlineData("en-US", "4.2 Mbar(g)", PressureUnit.MegabarG, 4.2)] [InlineData("en-US", "4.2 MN/m²", PressureUnit.MeganewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 MPa", PressureUnit.Megapascal, 4.2)] + [InlineData("en-US", "4.2 MPa(g)", PressureUnit.MegapascalG, 4.2)] [InlineData("en-US", "4.2 m of head", PressureUnit.MeterOfHead, 4.2)] [InlineData("en-US", "4.2 mH₂O", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mH2O", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 m wc", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 m wg", PressureUnit.MeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 µbar", PressureUnit.Microbar, 4.2)] + [InlineData("en-US", "4.2 µbar(g)", PressureUnit.MicrobarG, 4.2)] [InlineData("en-US", "4.2 µPa", PressureUnit.Micropascal, 4.2)] + [InlineData("en-US", "4.2 µPa(g)", PressureUnit.MicropascalG, 4.2)] [InlineData("en-US", "4.2 mbar", PressureUnit.Millibar, 4.2)] + [InlineData("en-US", "4.2 mbar(g)", PressureUnit.MillibarG, 4.2)] [InlineData("en-US", "4.2 mmHg", PressureUnit.MillimeterOfMercury, 4.2)] [InlineData("en-US", "4.2 mmH₂O", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mmH2O", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mm wc", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mm wg", PressureUnit.MillimeterOfWaterColumn, 4.2)] [InlineData("en-US", "4.2 mPa", PressureUnit.Millipascal, 4.2)] + [InlineData("en-US", "4.2 mPa(g)", PressureUnit.MillipascalG, 4.2)] [InlineData("en-US", "4.2 mtorr", PressureUnit.Millitorr, 4.2)] [InlineData("en-US", "4.2 N/cm²", PressureUnit.NewtonPerSquareCentimeter, 4.2)] [InlineData("en-US", "4.2 N/m²", PressureUnit.NewtonPerSquareMeter, 4.2)] [InlineData("en-US", "4.2 N/mm²", PressureUnit.NewtonPerSquareMillimeter, 4.2)] [InlineData("en-US", "4.2 Pa", PressureUnit.Pascal, 4.2)] + [InlineData("en-US", "4.2 Pa(g)", PressureUnit.PascalG, 4.2)] [InlineData("en-US", "4.2 lb/ft²", PressureUnit.PoundForcePerSquareFoot, 4.2)] [InlineData("en-US", "4.2 psi", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("en-US", "4.2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)] @@ -685,12 +820,19 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn [InlineData("en-US", "4.2 torr", PressureUnit.Torr, 4.2)] [InlineData("ru-RU", "4,2 атм", PressureUnit.Atmosphere, 4.2)] [InlineData("ru-RU", "4,2 бар", PressureUnit.Bar, 4.2)] + [InlineData("ru-RU", "4,2 бар(g)", PressureUnit.BarG, 4.2)] [InlineData("ru-RU", "4,2 сбар", PressureUnit.Centibar, 4.2)] + [InlineData("ru-RU", "4,2 сбар(g)", PressureUnit.CentibarG, 4.2)] [InlineData("ru-RU", "4,2 даПа", PressureUnit.Decapascal, 4.2)] + [InlineData("ru-RU", "4,2 даПа(g)", PressureUnit.DecapascalG, 4.2)] [InlineData("ru-RU", "4,2 дбар", PressureUnit.Decibar, 4.2)] + [InlineData("ru-RU", "4,2 дбар(g)", PressureUnit.DecibarG, 4.2)] [InlineData("ru-RU", "4,2 ГПа", PressureUnit.Gigapascal, 4.2)] + [InlineData("ru-RU", "4,2 ГПа(g)", PressureUnit.GigapascalG, 4.2)] [InlineData("ru-RU", "4,2 гПа", PressureUnit.Hectopascal, 4.2)] + [InlineData("ru-RU", "4,2 гПа(g)", PressureUnit.HectopascalG, 4.2)] [InlineData("ru-RU", "4,2 кбар", PressureUnit.Kilobar, 4.2)] + [InlineData("ru-RU", "4,2 кбар(g)", PressureUnit.KilobarG, 4.2)] [InlineData("ru-RU", "4,2 кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter, 4.2)] [InlineData("ru-RU", "4,2 кгс/м²", PressureUnit.KilogramForcePerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter, 4.2)] @@ -698,21 +840,29 @@ public void Parse(string culture, string quantityString, PressureUnit expectedUn [InlineData("ru-RU", "4,2 кН/м²", PressureUnit.KilonewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter, 4.2)] [InlineData("ru-RU", "4,2 кПа", PressureUnit.Kilopascal, 4.2)] + [InlineData("ru-RU", "4,2 кПа(g)", PressureUnit.KilopascalG, 4.2)] [InlineData("ru-RU", "4,2 ksi", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 kipf/in²", PressureUnit.KilopoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 Мбар", PressureUnit.Megabar, 4.2)] + [InlineData("ru-RU", "4,2 Мбар(g)", PressureUnit.MegabarG, 4.2)] [InlineData("ru-RU", "4,2 МН/м²", PressureUnit.MeganewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 МПа", PressureUnit.Megapascal, 4.2)] + [InlineData("ru-RU", "4,2 МПа(g)", PressureUnit.MegapascalG, 4.2)] [InlineData("ru-RU", "4,2 мкбар", PressureUnit.Microbar, 4.2)] + [InlineData("ru-RU", "4,2 мкбар(g)", PressureUnit.MicrobarG, 4.2)] [InlineData("ru-RU", "4,2 мкПа", PressureUnit.Micropascal, 4.2)] + [InlineData("ru-RU", "4,2 мкПа(g)", PressureUnit.MicropascalG, 4.2)] [InlineData("ru-RU", "4,2 мбар", PressureUnit.Millibar, 4.2)] + [InlineData("ru-RU", "4,2 мбар(g)", PressureUnit.MillibarG, 4.2)] [InlineData("ru-RU", "4,2 мм рт.ст.", PressureUnit.MillimeterOfMercury, 4.2)] [InlineData("ru-RU", "4,2 мПа", PressureUnit.Millipascal, 4.2)] + [InlineData("ru-RU", "4,2 мПа(g)", PressureUnit.MillipascalG, 4.2)] [InlineData("ru-RU", "4,2 мторр", PressureUnit.Millitorr, 4.2)] [InlineData("ru-RU", "4,2 Н/см²", PressureUnit.NewtonPerSquareCentimeter, 4.2)] [InlineData("ru-RU", "4,2 Н/м²", PressureUnit.NewtonPerSquareMeter, 4.2)] [InlineData("ru-RU", "4,2 Н/мм²", PressureUnit.NewtonPerSquareMillimeter, 4.2)] [InlineData("ru-RU", "4,2 Па", PressureUnit.Pascal, 4.2)] + [InlineData("ru-RU", "4,2 Па(g)", PressureUnit.PascalG, 4.2)] [InlineData("ru-RU", "4,2 psi", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 lb/in²", PressureUnit.PoundForcePerSquareInch, 4.2)] [InlineData("ru-RU", "4,2 ат", PressureUnit.TechnicalAtmosphere, 4.2)] @@ -728,22 +878,29 @@ public void TryParse(string culture, string quantityString, PressureUnit expecte [Theory] [InlineData("atm", PressureUnit.Atmosphere)] [InlineData("bar", PressureUnit.Bar)] + [InlineData("bar(g)", PressureUnit.BarG)] [InlineData("cbar", PressureUnit.Centibar)] + [InlineData("cbar(g)", PressureUnit.CentibarG)] [InlineData("cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("daPa", PressureUnit.Decapascal)] + [InlineData("daPa(g)", PressureUnit.DecapascalG)] [InlineData("dbar", PressureUnit.Decibar)] + [InlineData("dbar(g)", PressureUnit.DecibarG)] [InlineData("dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("ft of head", PressureUnit.FootOfHead)] [InlineData("GPa", PressureUnit.Gigapascal)] + [InlineData("GPa(g)", PressureUnit.GigapascalG)] [InlineData("hPa", PressureUnit.Hectopascal)] + [InlineData("hPa(g)", PressureUnit.HectopascalG)] [InlineData("inHg", PressureUnit.InchOfMercury)] [InlineData("inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("wc", PressureUnit.InchOfWaterColumn)] [InlineData("kbar", PressureUnit.Kilobar)] + [InlineData("kbar(g)", PressureUnit.KilobarG)] [InlineData("kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -751,32 +908,40 @@ public void TryParse(string culture, string quantityString, PressureUnit expecte [InlineData("kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("kPa", PressureUnit.Kilopascal)] + [InlineData("kPa(g)", PressureUnit.KilopascalG)] [InlineData("kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("Mbar", PressureUnit.Megabar)] + [InlineData("Mbar(g)", PressureUnit.MegabarG)] [InlineData("MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("MPa", PressureUnit.Megapascal)] + [InlineData("MPa(g)", PressureUnit.MegapascalG)] [InlineData("m of head", PressureUnit.MeterOfHead)] [InlineData("mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("µbar", PressureUnit.Microbar)] + [InlineData("µbar(g)", PressureUnit.MicrobarG)] [InlineData("µPa", PressureUnit.Micropascal)] + [InlineData("µPa(g)", PressureUnit.MicropascalG)] [InlineData("mbar", PressureUnit.Millibar)] + [InlineData("mbar(g)", PressureUnit.MillibarG)] [InlineData("mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mPa", PressureUnit.Millipascal)] + [InlineData("mPa(g)", PressureUnit.MillipascalG)] [InlineData("mtorr", PressureUnit.Millitorr)] [InlineData("N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("Pa", PressureUnit.Pascal)] + [InlineData("Pa(g)", PressureUnit.PascalG)] [InlineData("lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -800,22 +965,29 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PressureU [Theory] [InlineData("atm", PressureUnit.Atmosphere)] [InlineData("bar", PressureUnit.Bar)] + [InlineData("bar(g)", PressureUnit.BarG)] [InlineData("cbar", PressureUnit.Centibar)] + [InlineData("cbar(g)", PressureUnit.CentibarG)] [InlineData("cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("daPa", PressureUnit.Decapascal)] + [InlineData("daPa(g)", PressureUnit.DecapascalG)] [InlineData("dbar", PressureUnit.Decibar)] + [InlineData("dbar(g)", PressureUnit.DecibarG)] [InlineData("dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("ft of head", PressureUnit.FootOfHead)] [InlineData("GPa", PressureUnit.Gigapascal)] + [InlineData("GPa(g)", PressureUnit.GigapascalG)] [InlineData("hPa", PressureUnit.Hectopascal)] + [InlineData("hPa(g)", PressureUnit.HectopascalG)] [InlineData("inHg", PressureUnit.InchOfMercury)] [InlineData("inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("wc", PressureUnit.InchOfWaterColumn)] [InlineData("kbar", PressureUnit.Kilobar)] + [InlineData("kbar(g)", PressureUnit.KilobarG)] [InlineData("kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -823,32 +995,40 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, PressureU [InlineData("kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("kPa", PressureUnit.Kilopascal)] + [InlineData("kPa(g)", PressureUnit.KilopascalG)] [InlineData("kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("Mbar", PressureUnit.Megabar)] + [InlineData("Mbar(g)", PressureUnit.MegabarG)] [InlineData("MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("MPa", PressureUnit.Megapascal)] + [InlineData("MPa(g)", PressureUnit.MegapascalG)] [InlineData("m of head", PressureUnit.MeterOfHead)] [InlineData("mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("µbar", PressureUnit.Microbar)] + [InlineData("µbar(g)", PressureUnit.MicrobarG)] [InlineData("µPa", PressureUnit.Micropascal)] + [InlineData("µPa(g)", PressureUnit.MicropascalG)] [InlineData("mbar", PressureUnit.Millibar)] + [InlineData("mbar(g)", PressureUnit.MillibarG)] [InlineData("mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mPa", PressureUnit.Millipascal)] + [InlineData("mPa(g)", PressureUnit.MillipascalG)] [InlineData("mtorr", PressureUnit.Millitorr)] [InlineData("N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("Pa", PressureUnit.Pascal)] + [InlineData("Pa(g)", PressureUnit.PascalG)] [InlineData("lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -872,22 +1052,29 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [Theory] [InlineData("en-US", "atm", PressureUnit.Atmosphere)] [InlineData("en-US", "bar", PressureUnit.Bar)] + [InlineData("en-US", "bar(g)", PressureUnit.BarG)] [InlineData("en-US", "cbar", PressureUnit.Centibar)] + [InlineData("en-US", "cbar(g)", PressureUnit.CentibarG)] [InlineData("en-US", "cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "daPa", PressureUnit.Decapascal)] + [InlineData("en-US", "daPa(g)", PressureUnit.DecapascalG)] [InlineData("en-US", "dbar", PressureUnit.Decibar)] + [InlineData("en-US", "dbar(g)", PressureUnit.DecibarG)] [InlineData("en-US", "dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("en-US", "ft of head", PressureUnit.FootOfHead)] [InlineData("en-US", "GPa", PressureUnit.Gigapascal)] + [InlineData("en-US", "GPa(g)", PressureUnit.GigapascalG)] [InlineData("en-US", "hPa", PressureUnit.Hectopascal)] + [InlineData("en-US", "hPa(g)", PressureUnit.HectopascalG)] [InlineData("en-US", "inHg", PressureUnit.InchOfMercury)] [InlineData("en-US", "inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "kbar", PressureUnit.Kilobar)] + [InlineData("en-US", "kbar(g)", PressureUnit.KilobarG)] [InlineData("en-US", "kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("en-US", "kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("en-US", "kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -895,32 +1082,40 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("en-US", "kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("en-US", "kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("en-US", "kPa", PressureUnit.Kilopascal)] + [InlineData("en-US", "kPa(g)", PressureUnit.KilopascalG)] [InlineData("en-US", "kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("en-US", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("en-US", "Mbar", PressureUnit.Megabar)] + [InlineData("en-US", "Mbar(g)", PressureUnit.MegabarG)] [InlineData("en-US", "MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("en-US", "MPa", PressureUnit.Megapascal)] + [InlineData("en-US", "MPa(g)", PressureUnit.MegapascalG)] [InlineData("en-US", "m of head", PressureUnit.MeterOfHead)] [InlineData("en-US", "mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "µbar", PressureUnit.Microbar)] + [InlineData("en-US", "µbar(g)", PressureUnit.MicrobarG)] [InlineData("en-US", "µPa", PressureUnit.Micropascal)] + [InlineData("en-US", "µPa(g)", PressureUnit.MicropascalG)] [InlineData("en-US", "mbar", PressureUnit.Millibar)] + [InlineData("en-US", "mbar(g)", PressureUnit.MillibarG)] [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mPa", PressureUnit.Millipascal)] + [InlineData("en-US", "mPa(g)", PressureUnit.MillipascalG)] [InlineData("en-US", "mtorr", PressureUnit.Millitorr)] [InlineData("en-US", "N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("en-US", "N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("en-US", "N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("en-US", "Pa", PressureUnit.Pascal)] + [InlineData("en-US", "Pa(g)", PressureUnit.PascalG)] [InlineData("en-US", "lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("en-US", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("en-US", "lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -935,12 +1130,19 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("en-US", "torr", PressureUnit.Torr)] [InlineData("ru-RU", "атм", PressureUnit.Atmosphere)] [InlineData("ru-RU", "бар", PressureUnit.Bar)] + [InlineData("ru-RU", "бар(g)", PressureUnit.BarG)] [InlineData("ru-RU", "сбар", PressureUnit.Centibar)] + [InlineData("ru-RU", "сбар(g)", PressureUnit.CentibarG)] [InlineData("ru-RU", "даПа", PressureUnit.Decapascal)] + [InlineData("ru-RU", "даПа(g)", PressureUnit.DecapascalG)] [InlineData("ru-RU", "дбар", PressureUnit.Decibar)] + [InlineData("ru-RU", "дбар(g)", PressureUnit.DecibarG)] [InlineData("ru-RU", "ГПа", PressureUnit.Gigapascal)] + [InlineData("ru-RU", "ГПа(g)", PressureUnit.GigapascalG)] [InlineData("ru-RU", "гПа", PressureUnit.Hectopascal)] + [InlineData("ru-RU", "гПа(g)", PressureUnit.HectopascalG)] [InlineData("ru-RU", "кбар", PressureUnit.Kilobar)] + [InlineData("ru-RU", "кбар(g)", PressureUnit.KilobarG)] [InlineData("ru-RU", "кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("ru-RU", "кгс/м²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("ru-RU", "кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -948,21 +1150,29 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("ru-RU", "кН/м²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("ru-RU", "кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("ru-RU", "кПа", PressureUnit.Kilopascal)] + [InlineData("ru-RU", "кПа(g)", PressureUnit.KilopascalG)] [InlineData("ru-RU", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "Мбар", PressureUnit.Megabar)] + [InlineData("ru-RU", "Мбар(g)", PressureUnit.MegabarG)] [InlineData("ru-RU", "МН/м²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("ru-RU", "МПа", PressureUnit.Megapascal)] + [InlineData("ru-RU", "МПа(g)", PressureUnit.MegapascalG)] [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)] + [InlineData("ru-RU", "мкбар(g)", PressureUnit.MicrobarG)] [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)] + [InlineData("ru-RU", "мкПа(g)", PressureUnit.MicropascalG)] [InlineData("ru-RU", "мбар", PressureUnit.Millibar)] + [InlineData("ru-RU", "мбар(g)", PressureUnit.MillibarG)] [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)] [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)] + [InlineData("ru-RU", "мПа(g)", PressureUnit.MillipascalG)] [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)] [InlineData("ru-RU", "Н/см²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("ru-RU", "Н/м²", PressureUnit.NewtonPerSquareMeter)] [InlineData("ru-RU", "Н/мм²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("ru-RU", "Па", PressureUnit.Pascal)] + [InlineData("ru-RU", "Па(g)", PressureUnit.PascalG)] [InlineData("ru-RU", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "lb/in²", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "ат", PressureUnit.TechnicalAtmosphere)] @@ -977,22 +1187,29 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr [Theory] [InlineData("en-US", "atm", PressureUnit.Atmosphere)] [InlineData("en-US", "bar", PressureUnit.Bar)] + [InlineData("en-US", "bar(g)", PressureUnit.BarG)] [InlineData("en-US", "cbar", PressureUnit.Centibar)] + [InlineData("en-US", "cbar(g)", PressureUnit.CentibarG)] [InlineData("en-US", "cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "daPa", PressureUnit.Decapascal)] + [InlineData("en-US", "daPa(g)", PressureUnit.DecapascalG)] [InlineData("en-US", "dbar", PressureUnit.Decibar)] + [InlineData("en-US", "dbar(g)", PressureUnit.DecibarG)] [InlineData("en-US", "dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("en-US", "ft of head", PressureUnit.FootOfHead)] [InlineData("en-US", "GPa", PressureUnit.Gigapascal)] + [InlineData("en-US", "GPa(g)", PressureUnit.GigapascalG)] [InlineData("en-US", "hPa", PressureUnit.Hectopascal)] + [InlineData("en-US", "hPa(g)", PressureUnit.HectopascalG)] [InlineData("en-US", "inHg", PressureUnit.InchOfMercury)] [InlineData("en-US", "inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "kbar", PressureUnit.Kilobar)] + [InlineData("en-US", "kbar(g)", PressureUnit.KilobarG)] [InlineData("en-US", "kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("en-US", "kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("en-US", "kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1000,32 +1217,40 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr [InlineData("en-US", "kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("en-US", "kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("en-US", "kPa", PressureUnit.Kilopascal)] + [InlineData("en-US", "kPa(g)", PressureUnit.KilopascalG)] [InlineData("en-US", "kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("en-US", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("en-US", "Mbar", PressureUnit.Megabar)] + [InlineData("en-US", "Mbar(g)", PressureUnit.MegabarG)] [InlineData("en-US", "MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("en-US", "MPa", PressureUnit.Megapascal)] + [InlineData("en-US", "MPa(g)", PressureUnit.MegapascalG)] [InlineData("en-US", "m of head", PressureUnit.MeterOfHead)] [InlineData("en-US", "mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "µbar", PressureUnit.Microbar)] + [InlineData("en-US", "µbar(g)", PressureUnit.MicrobarG)] [InlineData("en-US", "µPa", PressureUnit.Micropascal)] + [InlineData("en-US", "µPa(g)", PressureUnit.MicropascalG)] [InlineData("en-US", "mbar", PressureUnit.Millibar)] + [InlineData("en-US", "mbar(g)", PressureUnit.MillibarG)] [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mPa", PressureUnit.Millipascal)] + [InlineData("en-US", "mPa(g)", PressureUnit.MillipascalG)] [InlineData("en-US", "mtorr", PressureUnit.Millitorr)] [InlineData("en-US", "N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("en-US", "N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("en-US", "N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("en-US", "Pa", PressureUnit.Pascal)] + [InlineData("en-US", "Pa(g)", PressureUnit.PascalG)] [InlineData("en-US", "lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("en-US", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("en-US", "lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -1040,12 +1265,19 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr [InlineData("en-US", "torr", PressureUnit.Torr)] [InlineData("ru-RU", "атм", PressureUnit.Atmosphere)] [InlineData("ru-RU", "бар", PressureUnit.Bar)] + [InlineData("ru-RU", "бар(g)", PressureUnit.BarG)] [InlineData("ru-RU", "сбар", PressureUnit.Centibar)] + [InlineData("ru-RU", "сбар(g)", PressureUnit.CentibarG)] [InlineData("ru-RU", "даПа", PressureUnit.Decapascal)] + [InlineData("ru-RU", "даПа(g)", PressureUnit.DecapascalG)] [InlineData("ru-RU", "дбар", PressureUnit.Decibar)] + [InlineData("ru-RU", "дбар(g)", PressureUnit.DecibarG)] [InlineData("ru-RU", "ГПа", PressureUnit.Gigapascal)] + [InlineData("ru-RU", "ГПа(g)", PressureUnit.GigapascalG)] [InlineData("ru-RU", "гПа", PressureUnit.Hectopascal)] + [InlineData("ru-RU", "гПа(g)", PressureUnit.HectopascalG)] [InlineData("ru-RU", "кбар", PressureUnit.Kilobar)] + [InlineData("ru-RU", "кбар(g)", PressureUnit.KilobarG)] [InlineData("ru-RU", "кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("ru-RU", "кгс/м²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("ru-RU", "кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1053,21 +1285,29 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Pr [InlineData("ru-RU", "кН/м²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("ru-RU", "кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("ru-RU", "кПа", PressureUnit.Kilopascal)] + [InlineData("ru-RU", "кПа(g)", PressureUnit.KilopascalG)] [InlineData("ru-RU", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "Мбар", PressureUnit.Megabar)] + [InlineData("ru-RU", "Мбар(g)", PressureUnit.MegabarG)] [InlineData("ru-RU", "МН/м²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("ru-RU", "МПа", PressureUnit.Megapascal)] + [InlineData("ru-RU", "МПа(g)", PressureUnit.MegapascalG)] [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)] + [InlineData("ru-RU", "мкбар(g)", PressureUnit.MicrobarG)] [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)] + [InlineData("ru-RU", "мкПа(g)", PressureUnit.MicropascalG)] [InlineData("ru-RU", "мбар", PressureUnit.Millibar)] + [InlineData("ru-RU", "мбар(g)", PressureUnit.MillibarG)] [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)] [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)] + [InlineData("ru-RU", "мПа(g)", PressureUnit.MillipascalG)] [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)] [InlineData("ru-RU", "Н/см²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("ru-RU", "Н/м²", PressureUnit.NewtonPerSquareMeter)] [InlineData("ru-RU", "Н/мм²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("ru-RU", "Па", PressureUnit.Pascal)] + [InlineData("ru-RU", "Па(g)", PressureUnit.PascalG)] [InlineData("ru-RU", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "lb/in²", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "ат", PressureUnit.TechnicalAtmosphere)] @@ -1081,22 +1321,29 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, PressureU [Theory] [InlineData("atm", PressureUnit.Atmosphere)] [InlineData("bar", PressureUnit.Bar)] + [InlineData("bar(g)", PressureUnit.BarG)] [InlineData("cbar", PressureUnit.Centibar)] + [InlineData("cbar(g)", PressureUnit.CentibarG)] [InlineData("cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("daPa", PressureUnit.Decapascal)] + [InlineData("daPa(g)", PressureUnit.DecapascalG)] [InlineData("dbar", PressureUnit.Decibar)] + [InlineData("dbar(g)", PressureUnit.DecibarG)] [InlineData("dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("ft of head", PressureUnit.FootOfHead)] [InlineData("GPa", PressureUnit.Gigapascal)] + [InlineData("GPa(g)", PressureUnit.GigapascalG)] [InlineData("hPa", PressureUnit.Hectopascal)] + [InlineData("hPa(g)", PressureUnit.HectopascalG)] [InlineData("inHg", PressureUnit.InchOfMercury)] [InlineData("inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("wc", PressureUnit.InchOfWaterColumn)] [InlineData("kbar", PressureUnit.Kilobar)] + [InlineData("kbar(g)", PressureUnit.KilobarG)] [InlineData("kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1104,32 +1351,40 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, PressureU [InlineData("kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("kPa", PressureUnit.Kilopascal)] + [InlineData("kPa(g)", PressureUnit.KilopascalG)] [InlineData("kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("Mbar", PressureUnit.Megabar)] + [InlineData("Mbar(g)", PressureUnit.MegabarG)] [InlineData("MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("MPa", PressureUnit.Megapascal)] + [InlineData("MPa(g)", PressureUnit.MegapascalG)] [InlineData("m of head", PressureUnit.MeterOfHead)] [InlineData("mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("µbar", PressureUnit.Microbar)] + [InlineData("µbar(g)", PressureUnit.MicrobarG)] [InlineData("µPa", PressureUnit.Micropascal)] + [InlineData("µPa(g)", PressureUnit.MicropascalG)] [InlineData("mbar", PressureUnit.Millibar)] + [InlineData("mbar(g)", PressureUnit.MillibarG)] [InlineData("mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mPa", PressureUnit.Millipascal)] + [InlineData("mPa(g)", PressureUnit.MillipascalG)] [InlineData("mtorr", PressureUnit.Millitorr)] [InlineData("N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("Pa", PressureUnit.Pascal)] + [InlineData("Pa(g)", PressureUnit.PascalG)] [InlineData("lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -1153,22 +1408,29 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Pressu [Theory] [InlineData("atm", PressureUnit.Atmosphere)] [InlineData("bar", PressureUnit.Bar)] + [InlineData("bar(g)", PressureUnit.BarG)] [InlineData("cbar", PressureUnit.Centibar)] + [InlineData("cbar(g)", PressureUnit.CentibarG)] [InlineData("cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("daPa", PressureUnit.Decapascal)] + [InlineData("daPa(g)", PressureUnit.DecapascalG)] [InlineData("dbar", PressureUnit.Decibar)] + [InlineData("dbar(g)", PressureUnit.DecibarG)] [InlineData("dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("ft of head", PressureUnit.FootOfHead)] [InlineData("GPa", PressureUnit.Gigapascal)] + [InlineData("GPa(g)", PressureUnit.GigapascalG)] [InlineData("hPa", PressureUnit.Hectopascal)] + [InlineData("hPa(g)", PressureUnit.HectopascalG)] [InlineData("inHg", PressureUnit.InchOfMercury)] [InlineData("inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("wc", PressureUnit.InchOfWaterColumn)] [InlineData("kbar", PressureUnit.Kilobar)] + [InlineData("kbar(g)", PressureUnit.KilobarG)] [InlineData("kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1176,32 +1438,40 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Pressu [InlineData("kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("kPa", PressureUnit.Kilopascal)] + [InlineData("kPa(g)", PressureUnit.KilopascalG)] [InlineData("kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("Mbar", PressureUnit.Megabar)] + [InlineData("Mbar(g)", PressureUnit.MegabarG)] [InlineData("MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("MPa", PressureUnit.Megapascal)] + [InlineData("MPa(g)", PressureUnit.MegapascalG)] [InlineData("m of head", PressureUnit.MeterOfHead)] [InlineData("mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("µbar", PressureUnit.Microbar)] + [InlineData("µbar(g)", PressureUnit.MicrobarG)] [InlineData("µPa", PressureUnit.Micropascal)] + [InlineData("µPa(g)", PressureUnit.MicropascalG)] [InlineData("mbar", PressureUnit.Millibar)] + [InlineData("mbar(g)", PressureUnit.MillibarG)] [InlineData("mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("mPa", PressureUnit.Millipascal)] + [InlineData("mPa(g)", PressureUnit.MillipascalG)] [InlineData("mtorr", PressureUnit.Millitorr)] [InlineData("N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("Pa", PressureUnit.Pascal)] + [InlineData("Pa(g)", PressureUnit.PascalG)] [InlineData("lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -1225,22 +1495,29 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [Theory] [InlineData("en-US", "atm", PressureUnit.Atmosphere)] [InlineData("en-US", "bar", PressureUnit.Bar)] + [InlineData("en-US", "bar(g)", PressureUnit.BarG)] [InlineData("en-US", "cbar", PressureUnit.Centibar)] + [InlineData("en-US", "cbar(g)", PressureUnit.CentibarG)] [InlineData("en-US", "cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "daPa", PressureUnit.Decapascal)] + [InlineData("en-US", "daPa(g)", PressureUnit.DecapascalG)] [InlineData("en-US", "dbar", PressureUnit.Decibar)] + [InlineData("en-US", "dbar(g)", PressureUnit.DecibarG)] [InlineData("en-US", "dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("en-US", "ft of head", PressureUnit.FootOfHead)] [InlineData("en-US", "GPa", PressureUnit.Gigapascal)] + [InlineData("en-US", "GPa(g)", PressureUnit.GigapascalG)] [InlineData("en-US", "hPa", PressureUnit.Hectopascal)] + [InlineData("en-US", "hPa(g)", PressureUnit.HectopascalG)] [InlineData("en-US", "inHg", PressureUnit.InchOfMercury)] [InlineData("en-US", "inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "kbar", PressureUnit.Kilobar)] + [InlineData("en-US", "kbar(g)", PressureUnit.KilobarG)] [InlineData("en-US", "kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("en-US", "kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("en-US", "kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1248,32 +1525,40 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("en-US", "kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("en-US", "kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("en-US", "kPa", PressureUnit.Kilopascal)] + [InlineData("en-US", "kPa(g)", PressureUnit.KilopascalG)] [InlineData("en-US", "kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("en-US", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("en-US", "Mbar", PressureUnit.Megabar)] + [InlineData("en-US", "Mbar(g)", PressureUnit.MegabarG)] [InlineData("en-US", "MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("en-US", "MPa", PressureUnit.Megapascal)] + [InlineData("en-US", "MPa(g)", PressureUnit.MegapascalG)] [InlineData("en-US", "m of head", PressureUnit.MeterOfHead)] [InlineData("en-US", "mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "µbar", PressureUnit.Microbar)] + [InlineData("en-US", "µbar(g)", PressureUnit.MicrobarG)] [InlineData("en-US", "µPa", PressureUnit.Micropascal)] + [InlineData("en-US", "µPa(g)", PressureUnit.MicropascalG)] [InlineData("en-US", "mbar", PressureUnit.Millibar)] + [InlineData("en-US", "mbar(g)", PressureUnit.MillibarG)] [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mPa", PressureUnit.Millipascal)] + [InlineData("en-US", "mPa(g)", PressureUnit.MillipascalG)] [InlineData("en-US", "mtorr", PressureUnit.Millitorr)] [InlineData("en-US", "N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("en-US", "N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("en-US", "N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("en-US", "Pa", PressureUnit.Pascal)] + [InlineData("en-US", "Pa(g)", PressureUnit.PascalG)] [InlineData("en-US", "lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("en-US", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("en-US", "lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -1288,12 +1573,19 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("en-US", "torr", PressureUnit.Torr)] [InlineData("ru-RU", "атм", PressureUnit.Atmosphere)] [InlineData("ru-RU", "бар", PressureUnit.Bar)] + [InlineData("ru-RU", "бар(g)", PressureUnit.BarG)] [InlineData("ru-RU", "сбар", PressureUnit.Centibar)] + [InlineData("ru-RU", "сбар(g)", PressureUnit.CentibarG)] [InlineData("ru-RU", "даПа", PressureUnit.Decapascal)] + [InlineData("ru-RU", "даПа(g)", PressureUnit.DecapascalG)] [InlineData("ru-RU", "дбар", PressureUnit.Decibar)] + [InlineData("ru-RU", "дбар(g)", PressureUnit.DecibarG)] [InlineData("ru-RU", "ГПа", PressureUnit.Gigapascal)] + [InlineData("ru-RU", "ГПа(g)", PressureUnit.GigapascalG)] [InlineData("ru-RU", "гПа", PressureUnit.Hectopascal)] + [InlineData("ru-RU", "гПа(g)", PressureUnit.HectopascalG)] [InlineData("ru-RU", "кбар", PressureUnit.Kilobar)] + [InlineData("ru-RU", "кбар(g)", PressureUnit.KilobarG)] [InlineData("ru-RU", "кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("ru-RU", "кгс/м²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("ru-RU", "кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1301,21 +1593,29 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("ru-RU", "кН/м²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("ru-RU", "кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("ru-RU", "кПа", PressureUnit.Kilopascal)] + [InlineData("ru-RU", "кПа(g)", PressureUnit.KilopascalG)] [InlineData("ru-RU", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "Мбар", PressureUnit.Megabar)] + [InlineData("ru-RU", "Мбар(g)", PressureUnit.MegabarG)] [InlineData("ru-RU", "МН/м²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("ru-RU", "МПа", PressureUnit.Megapascal)] + [InlineData("ru-RU", "МПа(g)", PressureUnit.MegapascalG)] [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)] + [InlineData("ru-RU", "мкбар(g)", PressureUnit.MicrobarG)] [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)] + [InlineData("ru-RU", "мкПа(g)", PressureUnit.MicropascalG)] [InlineData("ru-RU", "мбар", PressureUnit.Millibar)] + [InlineData("ru-RU", "мбар(g)", PressureUnit.MillibarG)] [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)] [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)] + [InlineData("ru-RU", "мПа(g)", PressureUnit.MillipascalG)] [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)] [InlineData("ru-RU", "Н/см²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("ru-RU", "Н/м²", PressureUnit.NewtonPerSquareMeter)] [InlineData("ru-RU", "Н/мм²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("ru-RU", "Па", PressureUnit.Pascal)] + [InlineData("ru-RU", "Па(g)", PressureUnit.PascalG)] [InlineData("ru-RU", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "lb/in²", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "ат", PressureUnit.TechnicalAtmosphere)] @@ -1330,22 +1630,29 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [Theory] [InlineData("en-US", "atm", PressureUnit.Atmosphere)] [InlineData("en-US", "bar", PressureUnit.Bar)] + [InlineData("en-US", "bar(g)", PressureUnit.BarG)] [InlineData("en-US", "cbar", PressureUnit.Centibar)] + [InlineData("en-US", "cbar(g)", PressureUnit.CentibarG)] [InlineData("en-US", "cmH₂O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cmH2O", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wc", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "cm wg", PressureUnit.CentimeterOfWaterColumn)] [InlineData("en-US", "daPa", PressureUnit.Decapascal)] + [InlineData("en-US", "daPa(g)", PressureUnit.DecapascalG)] [InlineData("en-US", "dbar", PressureUnit.Decibar)] + [InlineData("en-US", "dbar(g)", PressureUnit.DecibarG)] [InlineData("en-US", "dyn/cm²", PressureUnit.DynePerSquareCentimeter)] [InlineData("en-US", "ft of head", PressureUnit.FootOfHead)] [InlineData("en-US", "GPa", PressureUnit.Gigapascal)] + [InlineData("en-US", "GPa(g)", PressureUnit.GigapascalG)] [InlineData("en-US", "hPa", PressureUnit.Hectopascal)] + [InlineData("en-US", "hPa(g)", PressureUnit.HectopascalG)] [InlineData("en-US", "inHg", PressureUnit.InchOfMercury)] [InlineData("en-US", "inH2O", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "inch wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "wc", PressureUnit.InchOfWaterColumn)] [InlineData("en-US", "kbar", PressureUnit.Kilobar)] + [InlineData("en-US", "kbar(g)", PressureUnit.KilobarG)] [InlineData("en-US", "kgf/cm²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("en-US", "kgf/m²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("en-US", "kgf/mm²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1353,32 +1660,40 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("en-US", "kN/m²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("en-US", "kN/mm²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("en-US", "kPa", PressureUnit.Kilopascal)] + [InlineData("en-US", "kPa(g)", PressureUnit.KilopascalG)] [InlineData("en-US", "kipf/ft²", PressureUnit.KilopoundForcePerSquareFoot)] [InlineData("en-US", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("en-US", "kipf/mil²", PressureUnit.KilopoundForcePerSquareMil)] [InlineData("en-US", "Mbar", PressureUnit.Megabar)] + [InlineData("en-US", "Mbar(g)", PressureUnit.MegabarG)] [InlineData("en-US", "MN/m²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("en-US", "MPa", PressureUnit.Megapascal)] + [InlineData("en-US", "MPa(g)", PressureUnit.MegapascalG)] [InlineData("en-US", "m of head", PressureUnit.MeterOfHead)] [InlineData("en-US", "mH₂O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "mH2O", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wc", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "m wg", PressureUnit.MeterOfWaterColumn)] [InlineData("en-US", "µbar", PressureUnit.Microbar)] + [InlineData("en-US", "µbar(g)", PressureUnit.MicrobarG)] [InlineData("en-US", "µPa", PressureUnit.Micropascal)] + [InlineData("en-US", "µPa(g)", PressureUnit.MicropascalG)] [InlineData("en-US", "mbar", PressureUnit.Millibar)] + [InlineData("en-US", "mbar(g)", PressureUnit.MillibarG)] [InlineData("en-US", "mmHg", PressureUnit.MillimeterOfMercury)] [InlineData("en-US", "mmH₂O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mmH2O", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wc", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mm wg", PressureUnit.MillimeterOfWaterColumn)] [InlineData("en-US", "mPa", PressureUnit.Millipascal)] + [InlineData("en-US", "mPa(g)", PressureUnit.MillipascalG)] [InlineData("en-US", "mtorr", PressureUnit.Millitorr)] [InlineData("en-US", "N/cm²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("en-US", "N/m²", PressureUnit.NewtonPerSquareMeter)] [InlineData("en-US", "N/mm²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("en-US", "Pa", PressureUnit.Pascal)] + [InlineData("en-US", "Pa(g)", PressureUnit.PascalG)] [InlineData("en-US", "lb/ft²", PressureUnit.PoundForcePerSquareFoot)] [InlineData("en-US", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("en-US", "lb/in²", PressureUnit.PoundForcePerSquareInch)] @@ -1393,12 +1708,19 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("en-US", "torr", PressureUnit.Torr)] [InlineData("ru-RU", "атм", PressureUnit.Atmosphere)] [InlineData("ru-RU", "бар", PressureUnit.Bar)] + [InlineData("ru-RU", "бар(g)", PressureUnit.BarG)] [InlineData("ru-RU", "сбар", PressureUnit.Centibar)] + [InlineData("ru-RU", "сбар(g)", PressureUnit.CentibarG)] [InlineData("ru-RU", "даПа", PressureUnit.Decapascal)] + [InlineData("ru-RU", "даПа(g)", PressureUnit.DecapascalG)] [InlineData("ru-RU", "дбар", PressureUnit.Decibar)] + [InlineData("ru-RU", "дбар(g)", PressureUnit.DecibarG)] [InlineData("ru-RU", "ГПа", PressureUnit.Gigapascal)] + [InlineData("ru-RU", "ГПа(g)", PressureUnit.GigapascalG)] [InlineData("ru-RU", "гПа", PressureUnit.Hectopascal)] + [InlineData("ru-RU", "гПа(g)", PressureUnit.HectopascalG)] [InlineData("ru-RU", "кбар", PressureUnit.Kilobar)] + [InlineData("ru-RU", "кбар(g)", PressureUnit.KilobarG)] [InlineData("ru-RU", "кгс/см²", PressureUnit.KilogramForcePerSquareCentimeter)] [InlineData("ru-RU", "кгс/м²", PressureUnit.KilogramForcePerSquareMeter)] [InlineData("ru-RU", "кгс/мм²", PressureUnit.KilogramForcePerSquareMillimeter)] @@ -1406,21 +1728,29 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("ru-RU", "кН/м²", PressureUnit.KilonewtonPerSquareMeter)] [InlineData("ru-RU", "кН/мм²", PressureUnit.KilonewtonPerSquareMillimeter)] [InlineData("ru-RU", "кПа", PressureUnit.Kilopascal)] + [InlineData("ru-RU", "кПа(g)", PressureUnit.KilopascalG)] [InlineData("ru-RU", "ksi", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "kipf/in²", PressureUnit.KilopoundForcePerSquareInch)] [InlineData("ru-RU", "Мбар", PressureUnit.Megabar)] + [InlineData("ru-RU", "Мбар(g)", PressureUnit.MegabarG)] [InlineData("ru-RU", "МН/м²", PressureUnit.MeganewtonPerSquareMeter)] [InlineData("ru-RU", "МПа", PressureUnit.Megapascal)] + [InlineData("ru-RU", "МПа(g)", PressureUnit.MegapascalG)] [InlineData("ru-RU", "мкбар", PressureUnit.Microbar)] + [InlineData("ru-RU", "мкбар(g)", PressureUnit.MicrobarG)] [InlineData("ru-RU", "мкПа", PressureUnit.Micropascal)] + [InlineData("ru-RU", "мкПа(g)", PressureUnit.MicropascalG)] [InlineData("ru-RU", "мбар", PressureUnit.Millibar)] + [InlineData("ru-RU", "мбар(g)", PressureUnit.MillibarG)] [InlineData("ru-RU", "мм рт.ст.", PressureUnit.MillimeterOfMercury)] [InlineData("ru-RU", "мПа", PressureUnit.Millipascal)] + [InlineData("ru-RU", "мПа(g)", PressureUnit.MillipascalG)] [InlineData("ru-RU", "мторр", PressureUnit.Millitorr)] [InlineData("ru-RU", "Н/см²", PressureUnit.NewtonPerSquareCentimeter)] [InlineData("ru-RU", "Н/м²", PressureUnit.NewtonPerSquareMeter)] [InlineData("ru-RU", "Н/мм²", PressureUnit.NewtonPerSquareMillimeter)] [InlineData("ru-RU", "Па", PressureUnit.Pascal)] + [InlineData("ru-RU", "Па(g)", PressureUnit.PascalG)] [InlineData("ru-RU", "psi", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "lb/in²", PressureUnit.PoundForcePerSquareInch)] [InlineData("ru-RU", "ат", PressureUnit.TechnicalAtmosphere)] @@ -1434,17 +1764,24 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu [Theory] [InlineData("en-US", PressureUnit.Atmosphere, "atm")] [InlineData("en-US", PressureUnit.Bar, "bar")] + [InlineData("en-US", PressureUnit.BarG, "bar(g)")] [InlineData("en-US", PressureUnit.Centibar, "cbar")] + [InlineData("en-US", PressureUnit.CentibarG, "cbar(g)")] [InlineData("en-US", PressureUnit.CentimeterOfWaterColumn, "cmH₂O")] [InlineData("en-US", PressureUnit.Decapascal, "daPa")] + [InlineData("en-US", PressureUnit.DecapascalG, "daPa(g)")] [InlineData("en-US", PressureUnit.Decibar, "dbar")] + [InlineData("en-US", PressureUnit.DecibarG, "dbar(g)")] [InlineData("en-US", PressureUnit.DynePerSquareCentimeter, "dyn/cm²")] [InlineData("en-US", PressureUnit.FootOfHead, "ft of head")] [InlineData("en-US", PressureUnit.Gigapascal, "GPa")] + [InlineData("en-US", PressureUnit.GigapascalG, "GPa(g)")] [InlineData("en-US", PressureUnit.Hectopascal, "hPa")] + [InlineData("en-US", PressureUnit.HectopascalG, "hPa(g)")] [InlineData("en-US", PressureUnit.InchOfMercury, "inHg")] [InlineData("en-US", PressureUnit.InchOfWaterColumn, "inH2O")] [InlineData("en-US", PressureUnit.Kilobar, "kbar")] + [InlineData("en-US", PressureUnit.KilobarG, "kbar(g)")] [InlineData("en-US", PressureUnit.KilogramForcePerSquareCentimeter, "kgf/cm²")] [InlineData("en-US", PressureUnit.KilogramForcePerSquareMeter, "kgf/m²")] [InlineData("en-US", PressureUnit.KilogramForcePerSquareMillimeter, "kgf/mm²")] @@ -1452,25 +1789,33 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu [InlineData("en-US", PressureUnit.KilonewtonPerSquareMeter, "kN/m²")] [InlineData("en-US", PressureUnit.KilonewtonPerSquareMillimeter, "kN/mm²")] [InlineData("en-US", PressureUnit.Kilopascal, "kPa")] + [InlineData("en-US", PressureUnit.KilopascalG, "kPa(g)")] [InlineData("en-US", PressureUnit.KilopoundForcePerSquareFoot, "kipf/ft²")] [InlineData("en-US", PressureUnit.KilopoundForcePerSquareInch, "ksi")] [InlineData("en-US", PressureUnit.KilopoundForcePerSquareMil, "kipf/mil²")] [InlineData("en-US", PressureUnit.Megabar, "Mbar")] + [InlineData("en-US", PressureUnit.MegabarG, "Mbar(g)")] [InlineData("en-US", PressureUnit.MeganewtonPerSquareMeter, "MN/m²")] [InlineData("en-US", PressureUnit.Megapascal, "MPa")] + [InlineData("en-US", PressureUnit.MegapascalG, "MPa(g)")] [InlineData("en-US", PressureUnit.MeterOfHead, "m of head")] [InlineData("en-US", PressureUnit.MeterOfWaterColumn, "mH₂O")] [InlineData("en-US", PressureUnit.Microbar, "µbar")] + [InlineData("en-US", PressureUnit.MicrobarG, "µbar(g)")] [InlineData("en-US", PressureUnit.Micropascal, "µPa")] + [InlineData("en-US", PressureUnit.MicropascalG, "µPa(g)")] [InlineData("en-US", PressureUnit.Millibar, "mbar")] + [InlineData("en-US", PressureUnit.MillibarG, "mbar(g)")] [InlineData("en-US", PressureUnit.MillimeterOfMercury, "mmHg")] [InlineData("en-US", PressureUnit.MillimeterOfWaterColumn, "mmH₂O")] [InlineData("en-US", PressureUnit.Millipascal, "mPa")] + [InlineData("en-US", PressureUnit.MillipascalG, "mPa(g)")] [InlineData("en-US", PressureUnit.Millitorr, "mtorr")] [InlineData("en-US", PressureUnit.NewtonPerSquareCentimeter, "N/cm²")] [InlineData("en-US", PressureUnit.NewtonPerSquareMeter, "N/m²")] [InlineData("en-US", PressureUnit.NewtonPerSquareMillimeter, "N/mm²")] [InlineData("en-US", PressureUnit.Pascal, "Pa")] + [InlineData("en-US", PressureUnit.PascalG, "Pa(g)")] [InlineData("en-US", PressureUnit.PoundForcePerSquareFoot, "lb/ft²")] [InlineData("en-US", PressureUnit.PoundForcePerSquareInch, "psi")] [InlineData("en-US", PressureUnit.PoundForcePerSquareMil, "lb/mil²")] @@ -1482,12 +1827,19 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu [InlineData("en-US", PressureUnit.Torr, "torr")] [InlineData("ru-RU", PressureUnit.Atmosphere, "атм")] [InlineData("ru-RU", PressureUnit.Bar, "бар")] + [InlineData("ru-RU", PressureUnit.BarG, "бар(g)")] [InlineData("ru-RU", PressureUnit.Centibar, "сбар")] + [InlineData("ru-RU", PressureUnit.CentibarG, "сбар(g)")] [InlineData("ru-RU", PressureUnit.Decapascal, "даПа")] + [InlineData("ru-RU", PressureUnit.DecapascalG, "даПа(g)")] [InlineData("ru-RU", PressureUnit.Decibar, "дбар")] + [InlineData("ru-RU", PressureUnit.DecibarG, "дбар(g)")] [InlineData("ru-RU", PressureUnit.Gigapascal, "ГПа")] + [InlineData("ru-RU", PressureUnit.GigapascalG, "ГПа(g)")] [InlineData("ru-RU", PressureUnit.Hectopascal, "гПа")] + [InlineData("ru-RU", PressureUnit.HectopascalG, "гПа(g)")] [InlineData("ru-RU", PressureUnit.Kilobar, "кбар")] + [InlineData("ru-RU", PressureUnit.KilobarG, "кбар(g)")] [InlineData("ru-RU", PressureUnit.KilogramForcePerSquareCentimeter, "кгс/см²")] [InlineData("ru-RU", PressureUnit.KilogramForcePerSquareMeter, "кгс/м²")] [InlineData("ru-RU", PressureUnit.KilogramForcePerSquareMillimeter, "кгс/мм²")] @@ -1495,20 +1847,28 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Pressu [InlineData("ru-RU", PressureUnit.KilonewtonPerSquareMeter, "кН/м²")] [InlineData("ru-RU", PressureUnit.KilonewtonPerSquareMillimeter, "кН/мм²")] [InlineData("ru-RU", PressureUnit.Kilopascal, "кПа")] + [InlineData("ru-RU", PressureUnit.KilopascalG, "кПа(g)")] [InlineData("ru-RU", PressureUnit.KilopoundForcePerSquareInch, "ksi")] [InlineData("ru-RU", PressureUnit.Megabar, "Мбар")] + [InlineData("ru-RU", PressureUnit.MegabarG, "Мбар(g)")] [InlineData("ru-RU", PressureUnit.MeganewtonPerSquareMeter, "МН/м²")] [InlineData("ru-RU", PressureUnit.Megapascal, "МПа")] + [InlineData("ru-RU", PressureUnit.MegapascalG, "МПа(g)")] [InlineData("ru-RU", PressureUnit.Microbar, "мкбар")] + [InlineData("ru-RU", PressureUnit.MicrobarG, "мкбар(g)")] [InlineData("ru-RU", PressureUnit.Micropascal, "мкПа")] + [InlineData("ru-RU", PressureUnit.MicropascalG, "мкПа(g)")] [InlineData("ru-RU", PressureUnit.Millibar, "мбар")] + [InlineData("ru-RU", PressureUnit.MillibarG, "мбар(g)")] [InlineData("ru-RU", PressureUnit.MillimeterOfMercury, "мм рт.ст.")] [InlineData("ru-RU", PressureUnit.Millipascal, "мПа")] + [InlineData("ru-RU", PressureUnit.MillipascalG, "мПа(g)")] [InlineData("ru-RU", PressureUnit.Millitorr, "мторр")] [InlineData("ru-RU", PressureUnit.NewtonPerSquareCentimeter, "Н/см²")] [InlineData("ru-RU", PressureUnit.NewtonPerSquareMeter, "Н/м²")] [InlineData("ru-RU", PressureUnit.NewtonPerSquareMillimeter, "Н/мм²")] [InlineData("ru-RU", PressureUnit.Pascal, "Па")] + [InlineData("ru-RU", PressureUnit.PascalG, "Па(g)")] [InlineData("ru-RU", PressureUnit.PoundForcePerSquareInch, "psi")] [InlineData("ru-RU", PressureUnit.TechnicalAtmosphere, "ат")] [InlineData("ru-RU", PressureUnit.Torr, "торр")] @@ -1598,17 +1958,24 @@ public void ConversionRoundTrip() Pressure pascal = Pressure.FromPascals(1); AssertEx.EqualTolerance(1, Pressure.FromAtmospheres(pascal.Atmospheres).Pascals, AtmospheresTolerance); AssertEx.EqualTolerance(1, Pressure.FromBars(pascal.Bars).Pascals, BarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromBarsG(pascal.BarsG).Pascals, BarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromCentibars(pascal.Centibars).Pascals, CentibarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromCentibarsG(pascal.CentibarsG).Pascals, CentibarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromCentimetersOfWaterColumn(pascal.CentimetersOfWaterColumn).Pascals, CentimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(1, Pressure.FromDecapascals(pascal.Decapascals).Pascals, DecapascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromDecapascalsG(pascal.DecapascalsG).Pascals, DecapascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromDecibars(pascal.Decibars).Pascals, DecibarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromDecibarsG(pascal.DecibarsG).Pascals, DecibarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromDynesPerSquareCentimeter(pascal.DynesPerSquareCentimeter).Pascals, DynesPerSquareCentimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromFeetOfHead(pascal.FeetOfHead).Pascals, FeetOfHeadTolerance); AssertEx.EqualTolerance(1, Pressure.FromGigapascals(pascal.Gigapascals).Pascals, GigapascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromGigapascalsG(pascal.GigapascalsG).Pascals, GigapascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromHectopascals(pascal.Hectopascals).Pascals, HectopascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromHectopascalsG(pascal.HectopascalsG).Pascals, HectopascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromInchesOfMercury(pascal.InchesOfMercury).Pascals, InchesOfMercuryTolerance); AssertEx.EqualTolerance(1, Pressure.FromInchesOfWaterColumn(pascal.InchesOfWaterColumn).Pascals, InchesOfWaterColumnTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilobars(pascal.Kilobars).Pascals, KilobarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromKilobarsG(pascal.KilobarsG).Pascals, KilobarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareCentimeter(pascal.KilogramsForcePerSquareCentimeter).Pascals, KilogramsForcePerSquareCentimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMeter(pascal.KilogramsForcePerSquareMeter).Pascals, KilogramsForcePerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilogramsForcePerSquareMillimeter(pascal.KilogramsForcePerSquareMillimeter).Pascals, KilogramsForcePerSquareMillimeterTolerance); @@ -1616,25 +1983,33 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMeter(pascal.KilonewtonsPerSquareMeter).Pascals, KilonewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilonewtonsPerSquareMillimeter(pascal.KilonewtonsPerSquareMillimeter).Pascals, KilonewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilopascals(pascal.Kilopascals).Pascals, KilopascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromKilopascalsG(pascal.KilopascalsG).Pascals, KilopascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareFoot(pascal.KilopoundsForcePerSquareFoot).Pascals, KilopoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareInch(pascal.KilopoundsForcePerSquareInch).Pascals, KilopoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(1, Pressure.FromKilopoundsForcePerSquareMil(pascal.KilopoundsForcePerSquareMil).Pascals, KilopoundsForcePerSquareMilTolerance); AssertEx.EqualTolerance(1, Pressure.FromMegabars(pascal.Megabars).Pascals, MegabarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMegabarsG(pascal.MegabarsG).Pascals, MegabarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMeganewtonsPerSquareMeter(pascal.MeganewtonsPerSquareMeter).Pascals, MeganewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromMegapascals(pascal.Megapascals).Pascals, MegapascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMegapascalsG(pascal.MegapascalsG).Pascals, MegapascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMetersOfHead(pascal.MetersOfHead).Pascals, MetersOfHeadTolerance); AssertEx.EqualTolerance(1, Pressure.FromMetersOfWaterColumn(pascal.MetersOfWaterColumn).Pascals, MetersOfWaterColumnTolerance); AssertEx.EqualTolerance(1, Pressure.FromMicrobars(pascal.Microbars).Pascals, MicrobarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMicrobarsG(pascal.MicrobarsG).Pascals, MicrobarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMicropascals(pascal.Micropascals).Pascals, MicropascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMicropascalsG(pascal.MicropascalsG).Pascals, MicropascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillibars(pascal.Millibars).Pascals, MillibarsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMillibarsG(pascal.MillibarsG).Pascals, MillibarsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfMercury(pascal.MillimetersOfMercury).Pascals, MillimetersOfMercuryTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillimetersOfWaterColumn(pascal.MillimetersOfWaterColumn).Pascals, MillimetersOfWaterColumnTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillipascals(pascal.Millipascals).Pascals, MillipascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromMillipascalsG(pascal.MillipascalsG).Pascals, MillipascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromMillitorrs(pascal.Millitorrs).Pascals, MillitorrsTolerance); AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareCentimeter(pascal.NewtonsPerSquareCentimeter).Pascals, NewtonsPerSquareCentimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMeter(pascal.NewtonsPerSquareMeter).Pascals, NewtonsPerSquareMeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromNewtonsPerSquareMillimeter(pascal.NewtonsPerSquareMillimeter).Pascals, NewtonsPerSquareMillimeterTolerance); AssertEx.EqualTolerance(1, Pressure.FromPascals(pascal.Pascals).Pascals, PascalsTolerance); + AssertEx.EqualTolerance(1, Pressure.FromPascalsG(pascal.PascalsG).Pascals, PascalsGTolerance); AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareFoot(pascal.PoundsForcePerSquareFoot).Pascals, PoundsForcePerSquareFootTolerance); AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareInch(pascal.PoundsForcePerSquareInch).Pascals, PoundsForcePerSquareInchTolerance); AssertEx.EqualTolerance(1, Pressure.FromPoundsForcePerSquareMil(pascal.PoundsForcePerSquareMil).Pascals, PoundsForcePerSquareMilTolerance); @@ -1802,17 +2177,24 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() using var _ = new CultureScope("en-US"); Assert.Equal("1 atm", new Pressure(1, PressureUnit.Atmosphere).ToString()); Assert.Equal("1 bar", new Pressure(1, PressureUnit.Bar).ToString()); + Assert.Equal("1 bar(g)", new Pressure(1, PressureUnit.BarG).ToString()); Assert.Equal("1 cbar", new Pressure(1, PressureUnit.Centibar).ToString()); + Assert.Equal("1 cbar(g)", new Pressure(1, PressureUnit.CentibarG).ToString()); Assert.Equal("1 cmH₂O", new Pressure(1, PressureUnit.CentimeterOfWaterColumn).ToString()); Assert.Equal("1 daPa", new Pressure(1, PressureUnit.Decapascal).ToString()); + Assert.Equal("1 daPa(g)", new Pressure(1, PressureUnit.DecapascalG).ToString()); Assert.Equal("1 dbar", new Pressure(1, PressureUnit.Decibar).ToString()); + Assert.Equal("1 dbar(g)", new Pressure(1, PressureUnit.DecibarG).ToString()); Assert.Equal("1 dyn/cm²", new Pressure(1, PressureUnit.DynePerSquareCentimeter).ToString()); Assert.Equal("1 ft of head", new Pressure(1, PressureUnit.FootOfHead).ToString()); Assert.Equal("1 GPa", new Pressure(1, PressureUnit.Gigapascal).ToString()); + Assert.Equal("1 GPa(g)", new Pressure(1, PressureUnit.GigapascalG).ToString()); Assert.Equal("1 hPa", new Pressure(1, PressureUnit.Hectopascal).ToString()); + Assert.Equal("1 hPa(g)", new Pressure(1, PressureUnit.HectopascalG).ToString()); Assert.Equal("1 inHg", new Pressure(1, PressureUnit.InchOfMercury).ToString()); Assert.Equal("1 inH2O", new Pressure(1, PressureUnit.InchOfWaterColumn).ToString()); Assert.Equal("1 kbar", new Pressure(1, PressureUnit.Kilobar).ToString()); + Assert.Equal("1 kbar(g)", new Pressure(1, PressureUnit.KilobarG).ToString()); Assert.Equal("1 kgf/cm²", new Pressure(1, PressureUnit.KilogramForcePerSquareCentimeter).ToString()); Assert.Equal("1 kgf/m²", new Pressure(1, PressureUnit.KilogramForcePerSquareMeter).ToString()); Assert.Equal("1 kgf/mm²", new Pressure(1, PressureUnit.KilogramForcePerSquareMillimeter).ToString()); @@ -1820,25 +2202,33 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 kN/m²", new Pressure(1, PressureUnit.KilonewtonPerSquareMeter).ToString()); Assert.Equal("1 kN/mm²", new Pressure(1, PressureUnit.KilonewtonPerSquareMillimeter).ToString()); Assert.Equal("1 kPa", new Pressure(1, PressureUnit.Kilopascal).ToString()); + Assert.Equal("1 kPa(g)", new Pressure(1, PressureUnit.KilopascalG).ToString()); Assert.Equal("1 kipf/ft²", new Pressure(1, PressureUnit.KilopoundForcePerSquareFoot).ToString()); Assert.Equal("1 ksi", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString()); Assert.Equal("1 kipf/mil²", new Pressure(1, PressureUnit.KilopoundForcePerSquareMil).ToString()); Assert.Equal("1 Mbar", new Pressure(1, PressureUnit.Megabar).ToString()); + Assert.Equal("1 Mbar(g)", new Pressure(1, PressureUnit.MegabarG).ToString()); Assert.Equal("1 MN/m²", new Pressure(1, PressureUnit.MeganewtonPerSquareMeter).ToString()); Assert.Equal("1 MPa", new Pressure(1, PressureUnit.Megapascal).ToString()); + Assert.Equal("1 MPa(g)", new Pressure(1, PressureUnit.MegapascalG).ToString()); Assert.Equal("1 m of head", new Pressure(1, PressureUnit.MeterOfHead).ToString()); Assert.Equal("1 mH₂O", new Pressure(1, PressureUnit.MeterOfWaterColumn).ToString()); Assert.Equal("1 µbar", new Pressure(1, PressureUnit.Microbar).ToString()); + Assert.Equal("1 µbar(g)", new Pressure(1, PressureUnit.MicrobarG).ToString()); Assert.Equal("1 µPa", new Pressure(1, PressureUnit.Micropascal).ToString()); + Assert.Equal("1 µPa(g)", new Pressure(1, PressureUnit.MicropascalG).ToString()); Assert.Equal("1 mbar", new Pressure(1, PressureUnit.Millibar).ToString()); + Assert.Equal("1 mbar(g)", new Pressure(1, PressureUnit.MillibarG).ToString()); Assert.Equal("1 mmHg", new Pressure(1, PressureUnit.MillimeterOfMercury).ToString()); Assert.Equal("1 mmH₂O", new Pressure(1, PressureUnit.MillimeterOfWaterColumn).ToString()); Assert.Equal("1 mPa", new Pressure(1, PressureUnit.Millipascal).ToString()); + Assert.Equal("1 mPa(g)", new Pressure(1, PressureUnit.MillipascalG).ToString()); Assert.Equal("1 mtorr", new Pressure(1, PressureUnit.Millitorr).ToString()); Assert.Equal("1 N/cm²", new Pressure(1, PressureUnit.NewtonPerSquareCentimeter).ToString()); Assert.Equal("1 N/m²", new Pressure(1, PressureUnit.NewtonPerSquareMeter).ToString()); Assert.Equal("1 N/mm²", new Pressure(1, PressureUnit.NewtonPerSquareMillimeter).ToString()); Assert.Equal("1 Pa", new Pressure(1, PressureUnit.Pascal).ToString()); + Assert.Equal("1 Pa(g)", new Pressure(1, PressureUnit.PascalG).ToString()); Assert.Equal("1 lb/ft²", new Pressure(1, PressureUnit.PoundForcePerSquareFoot).ToString()); Assert.Equal("1 psi", new Pressure(1, PressureUnit.PoundForcePerSquareInch).ToString()); Assert.Equal("1 lb/mil²", new Pressure(1, PressureUnit.PoundForcePerSquareMil).ToString()); @@ -1858,17 +2248,24 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 atm", new Pressure(1, PressureUnit.Atmosphere).ToString(swedishCulture)); Assert.Equal("1 bar", new Pressure(1, PressureUnit.Bar).ToString(swedishCulture)); + Assert.Equal("1 bar(g)", new Pressure(1, PressureUnit.BarG).ToString(swedishCulture)); Assert.Equal("1 cbar", new Pressure(1, PressureUnit.Centibar).ToString(swedishCulture)); + Assert.Equal("1 cbar(g)", new Pressure(1, PressureUnit.CentibarG).ToString(swedishCulture)); Assert.Equal("1 cmH₂O", new Pressure(1, PressureUnit.CentimeterOfWaterColumn).ToString(swedishCulture)); Assert.Equal("1 daPa", new Pressure(1, PressureUnit.Decapascal).ToString(swedishCulture)); + Assert.Equal("1 daPa(g)", new Pressure(1, PressureUnit.DecapascalG).ToString(swedishCulture)); Assert.Equal("1 dbar", new Pressure(1, PressureUnit.Decibar).ToString(swedishCulture)); + Assert.Equal("1 dbar(g)", new Pressure(1, PressureUnit.DecibarG).ToString(swedishCulture)); Assert.Equal("1 dyn/cm²", new Pressure(1, PressureUnit.DynePerSquareCentimeter).ToString(swedishCulture)); Assert.Equal("1 ft of head", new Pressure(1, PressureUnit.FootOfHead).ToString(swedishCulture)); Assert.Equal("1 GPa", new Pressure(1, PressureUnit.Gigapascal).ToString(swedishCulture)); + Assert.Equal("1 GPa(g)", new Pressure(1, PressureUnit.GigapascalG).ToString(swedishCulture)); Assert.Equal("1 hPa", new Pressure(1, PressureUnit.Hectopascal).ToString(swedishCulture)); + Assert.Equal("1 hPa(g)", new Pressure(1, PressureUnit.HectopascalG).ToString(swedishCulture)); Assert.Equal("1 inHg", new Pressure(1, PressureUnit.InchOfMercury).ToString(swedishCulture)); Assert.Equal("1 inH2O", new Pressure(1, PressureUnit.InchOfWaterColumn).ToString(swedishCulture)); Assert.Equal("1 kbar", new Pressure(1, PressureUnit.Kilobar).ToString(swedishCulture)); + Assert.Equal("1 kbar(g)", new Pressure(1, PressureUnit.KilobarG).ToString(swedishCulture)); Assert.Equal("1 kgf/cm²", new Pressure(1, PressureUnit.KilogramForcePerSquareCentimeter).ToString(swedishCulture)); Assert.Equal("1 kgf/m²", new Pressure(1, PressureUnit.KilogramForcePerSquareMeter).ToString(swedishCulture)); Assert.Equal("1 kgf/mm²", new Pressure(1, PressureUnit.KilogramForcePerSquareMillimeter).ToString(swedishCulture)); @@ -1876,25 +2273,33 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 kN/m²", new Pressure(1, PressureUnit.KilonewtonPerSquareMeter).ToString(swedishCulture)); Assert.Equal("1 kN/mm²", new Pressure(1, PressureUnit.KilonewtonPerSquareMillimeter).ToString(swedishCulture)); Assert.Equal("1 kPa", new Pressure(1, PressureUnit.Kilopascal).ToString(swedishCulture)); + Assert.Equal("1 kPa(g)", new Pressure(1, PressureUnit.KilopascalG).ToString(swedishCulture)); Assert.Equal("1 kipf/ft²", new Pressure(1, PressureUnit.KilopoundForcePerSquareFoot).ToString(swedishCulture)); Assert.Equal("1 ksi", new Pressure(1, PressureUnit.KilopoundForcePerSquareInch).ToString(swedishCulture)); Assert.Equal("1 kipf/mil²", new Pressure(1, PressureUnit.KilopoundForcePerSquareMil).ToString(swedishCulture)); Assert.Equal("1 Mbar", new Pressure(1, PressureUnit.Megabar).ToString(swedishCulture)); + Assert.Equal("1 Mbar(g)", new Pressure(1, PressureUnit.MegabarG).ToString(swedishCulture)); Assert.Equal("1 MN/m²", new Pressure(1, PressureUnit.MeganewtonPerSquareMeter).ToString(swedishCulture)); Assert.Equal("1 MPa", new Pressure(1, PressureUnit.Megapascal).ToString(swedishCulture)); + Assert.Equal("1 MPa(g)", new Pressure(1, PressureUnit.MegapascalG).ToString(swedishCulture)); Assert.Equal("1 m of head", new Pressure(1, PressureUnit.MeterOfHead).ToString(swedishCulture)); Assert.Equal("1 mH₂O", new Pressure(1, PressureUnit.MeterOfWaterColumn).ToString(swedishCulture)); Assert.Equal("1 µbar", new Pressure(1, PressureUnit.Microbar).ToString(swedishCulture)); + Assert.Equal("1 µbar(g)", new Pressure(1, PressureUnit.MicrobarG).ToString(swedishCulture)); Assert.Equal("1 µPa", new Pressure(1, PressureUnit.Micropascal).ToString(swedishCulture)); + Assert.Equal("1 µPa(g)", new Pressure(1, PressureUnit.MicropascalG).ToString(swedishCulture)); Assert.Equal("1 mbar", new Pressure(1, PressureUnit.Millibar).ToString(swedishCulture)); + Assert.Equal("1 mbar(g)", new Pressure(1, PressureUnit.MillibarG).ToString(swedishCulture)); Assert.Equal("1 mmHg", new Pressure(1, PressureUnit.MillimeterOfMercury).ToString(swedishCulture)); Assert.Equal("1 mmH₂O", new Pressure(1, PressureUnit.MillimeterOfWaterColumn).ToString(swedishCulture)); Assert.Equal("1 mPa", new Pressure(1, PressureUnit.Millipascal).ToString(swedishCulture)); + Assert.Equal("1 mPa(g)", new Pressure(1, PressureUnit.MillipascalG).ToString(swedishCulture)); Assert.Equal("1 mtorr", new Pressure(1, PressureUnit.Millitorr).ToString(swedishCulture)); Assert.Equal("1 N/cm²", new Pressure(1, PressureUnit.NewtonPerSquareCentimeter).ToString(swedishCulture)); Assert.Equal("1 N/m²", new Pressure(1, PressureUnit.NewtonPerSquareMeter).ToString(swedishCulture)); Assert.Equal("1 N/mm²", new Pressure(1, PressureUnit.NewtonPerSquareMillimeter).ToString(swedishCulture)); Assert.Equal("1 Pa", new Pressure(1, PressureUnit.Pascal).ToString(swedishCulture)); + Assert.Equal("1 Pa(g)", new Pressure(1, PressureUnit.PascalG).ToString(swedishCulture)); Assert.Equal("1 lb/ft²", new Pressure(1, PressureUnit.PoundForcePerSquareFoot).ToString(swedishCulture)); Assert.Equal("1 psi", new Pressure(1, PressureUnit.PoundForcePerSquareInch).ToString(swedishCulture)); Assert.Equal("1 lb/mil²", new Pressure(1, PressureUnit.PoundForcePerSquareMil).ToString(swedishCulture)); diff --git a/UnitsNet/GeneratedCode/Quantities/Fluence.g.cs b/UnitsNet/GeneratedCode/Quantities/Fluence.g.cs new file mode 100644 index 0000000000..708ec5bb16 --- /dev/null +++ b/UnitsNet/GeneratedCode/Quantities/Fluence.g.cs @@ -0,0 +1,740 @@ +//------------------------------------------------------------------------------ +// +// 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.Globalization; +using System.Resources; +using System.Runtime.Serialization; +#if NET +using System.Numerics; +#endif + +#nullable enable + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// + /// In nuclear physics, fluence is the time-integrated flux of particles (typically neutrons) passing through a unit area. It is commonly measured in neutrons per square centimeter (n/cm²) for reactor vessel wall exposure. + /// + [DataContract] + [DebuggerTypeProxy(typeof(QuantityDisplay))] + public readonly partial struct Fluence : + IArithmeticQuantity, +#if NET7_0_OR_GREATER + IDivisionOperators, + IComparisonOperators, + IParsable, +#endif + IComparable, + IComparable, + IEquatable, + IFormattable + { + /// + /// The numeric value this quantity was constructed with. + /// + [DataMember(Name = "Value", Order = 1)] + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + [DataMember(Name = "Unit", Order = 2)] + private readonly FluenceUnit? _unit; + + /// + /// Provides detailed information about the quantity, including its name, base unit, unit mappings, base dimensions, and conversion functions. + /// + public sealed class FluenceInfo: QuantityInfo + { + /// + public FluenceInfo(string name, FluenceUnit baseUnit, IEnumerable> unitMappings, Fluence zero, BaseDimensions baseDimensions, + QuantityFromDelegate fromDelegate, ResourceManager? unitAbbreviations) + : base(name, baseUnit, unitMappings, zero, baseDimensions, fromDelegate, unitAbbreviations) + { + } + + /// + public FluenceInfo(string name, FluenceUnit baseUnit, IEnumerable> unitMappings, Fluence zero, BaseDimensions baseDimensions) + : this(name, baseUnit, unitMappings, zero, baseDimensions, Fluence.From, new ResourceManager("UnitsNet.GeneratedCode.Resources.Fluence", typeof(Fluence).Assembly)) + { + } + + /// + /// Creates a new instance of the class with the default settings for the Fluence quantity. + /// + /// A new instance of the class with the default settings. + public static FluenceInfo CreateDefault() + { + return new FluenceInfo(nameof(Fluence), DefaultBaseUnit, GetDefaultMappings(), new Fluence(0, DefaultBaseUnit), DefaultBaseDimensions); + } + + /// + /// Creates a new instance of the class with the default settings for the Fluence quantity and a callback for customizing the default unit mappings. + /// + /// + /// A callback function for customizing the default unit mappings. + /// + /// + /// A new instance of the class with the default settings. + /// + public static FluenceInfo CreateDefault(Func>, IEnumerable>> customizeUnits) + { + return new FluenceInfo(nameof(Fluence), DefaultBaseUnit, customizeUnits(GetDefaultMappings()), new Fluence(0, DefaultBaseUnit), DefaultBaseDimensions); + } + + /// + /// The for is [L^-2]. + /// + public static BaseDimensions DefaultBaseDimensions { get; } = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0); + + /// + /// The default base unit of Fluence is NeutronPerSquareCentimeter. All conversions, as defined in the , go via this value. + /// + public static FluenceUnit DefaultBaseUnit { get; } = FluenceUnit.NeutronPerSquareCentimeter; + + /// + /// Retrieves the default mappings for . + /// + /// An of representing the default unit mappings for Fluence. + public static IEnumerable> GetDefaultMappings() + { + yield return new (FluenceUnit.NeutronPerSquareCentimeter, "NeutronPerSquareCentimeter", "NeutronsPerSquareCentimeter", new BaseUnits(length: LengthUnit.Centimeter)); + } + } + + static Fluence() + { + Info = FluenceInfo.CreateDefault(); + DefaultConversionFunctions = new UnitConverter(); + RegisterDefaultConversions(DefaultConversionFunctions); + } + + /// + /// 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. + public Fluence(double value, FluenceUnit unit) + { + _value = value; + _unit = unit; + } + + /// + /// Creates an instance of the quantity with the given numeric value in units compatible with the given . + /// If multiple compatible units were found, the first match is used. + /// + /// The numeric value to construct this quantity with. + /// The unit system to create the quantity with. + /// The given is null. + /// No unit was found for the given . + public Fluence(double value, UnitSystem unitSystem) + { + _value = value; + _unit = Info.GetDefaultUnit(unitSystem); + } + + #region Static Properties + + /// + /// The containing the default generated conversion functions for instances. + /// + public static UnitConverter DefaultConversionFunctions { get; } + + /// + public static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions => Info.BaseDimensions; + + /// + /// The base unit of Fluence, which is NeutronPerSquareCentimeter. All conversions go via this value. + /// + public static FluenceUnit BaseUnit => Info.BaseUnitInfo.Value; + + /// + /// All units of measurement for the Fluence quantity. + /// + public static IReadOnlyCollection Units => Info.Units; + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit NeutronPerSquareCentimeter. + /// + public static Fluence Zero => Info.Zero; + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + /// + public FluenceUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + /// + public QuantityInfo QuantityInfo => Info; + + #region Explicit implementations + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + UnitKey IQuantity.UnitKey => UnitKey.ForUnit(Unit); + +#if NETSTANDARD2_0 + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + IQuantityInstanceInfo IQuantityOfType.QuantityInfo => Info; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + QuantityInfo IQuantity.QuantityInfo => Info; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + QuantityInfo IQuantity.QuantityInfo => Info; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Enum IQuantity.Unit => Unit; +#endif + + #endregion + + #endregion + + #region Conversion Properties + + /// + /// Gets a value of this quantity converted into + /// + public double NeutronsPerSquareCentimeter => As(FluenceUnit.NeutronPerSquareCentimeter); + + #endregion + + #region Static Methods + + /// + /// Registers the default conversion functions in the given instance. + /// + /// The to register the default conversion functions in. + internal static void RegisterDefaultConversions(UnitConverter unitConverter) + { + // Register in unit converter: FluenceUnit -> BaseUnit + + // Register in unit converter: BaseUnit <-> BaseUnit + unitConverter.SetConversionFunction(FluenceUnit.NeutronPerSquareCentimeter, FluenceUnit.NeutronPerSquareCentimeter, quantity => quantity); + + // Register in unit converter: BaseUnit -> FluenceUnit + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(FluenceUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + /// Format to use for localization. Defaults to if null. + public static string GetAbbreviation(FluenceUnit unit, IFormatProvider? provider) + { + return UnitsNetSetup.Default.UnitAbbreviations.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Creates a from . + /// + public static Fluence FromNeutronsPerSquareCentimeter(double value) + { + return new Fluence(value, FluenceUnit.NeutronPerSquareCentimeter); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Fluence unit value. + public static Fluence From(double value, FluenceUnit fromUnit) + { + return new Fluence(value, fromUnit); + } + + #endregion + + #region Static Parse Methods + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + public static Fluence Parse(string str) + { + return Parse(str, null); + } + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static Fluence Parse(string str, IFormatProvider? provider) + { + return UnitsNetSetup.Default.QuantityParser.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US")); + /// + public static bool TryParse([NotNullWhen(true)]string? str, out Fluence result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", CultureInfo.GetCultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParse([NotNullWhen(true)]string? str, IFormatProvider? provider, out Fluence result) + { + return UnitsNetSetup.Default.QuantityParser.TryParse( + str, + provider, + From, + out result); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static FluenceUnit ParseUnit(string str) + { + return ParseUnit(str, null); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// Format to use when parsing number and unit. Defaults to if null. + /// + /// Length.ParseUnit("m", CultureInfo.GetCultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static FluenceUnit ParseUnit(string str, IFormatProvider? provider) + { + return UnitParser.Default.Parse(str, Info.UnitInfos, provider).Value; + } + + /// + public static bool TryParseUnit([NotNullWhen(true)]string? str, out FluenceUnit unit) + { + return TryParseUnit(str, null, out unit); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// The parsed unit if successful. + /// True if successful, otherwise false. + /// + /// Length.TryParseUnit("m", CultureInfo.GetCultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider? provider, out FluenceUnit unit) + { + return UnitParser.Default.TryParse(str, Info, provider, out unit); + } + + #endregion + + #region Arithmetic Operators + + /// Negate the value. + public static Fluence operator -(Fluence right) + { + return new Fluence(-right.Value, right.Unit); + } + + /// Get from adding two . + public static Fluence operator +(Fluence left, Fluence right) + { + return new Fluence(left.Value + right.ToUnit(left.Unit).Value, left.Unit); + } + + /// Get from subtracting two . + public static Fluence operator -(Fluence left, Fluence right) + { + return new Fluence(left.Value - right.ToUnit(left.Unit).Value, left.Unit); + } + + /// Get from multiplying value and . + public static Fluence operator *(double left, Fluence right) + { + return new Fluence(left * right.Value, right.Unit); + } + + /// Get from multiplying value and . + public static Fluence operator *(Fluence left, double right) + { + return new Fluence(left.Value * right, left.Unit); + } + + /// Get from dividing by value. + public static Fluence operator /(Fluence left, double right) + { + return new Fluence(left.Value / right, left.Unit); + } + + /// Get ratio value from dividing by . + public static double operator /(Fluence left, Fluence right) + { + return left.NeutronsPerSquareCentimeter / right.NeutronsPerSquareCentimeter; + } + + #endregion + + #region Equality / IComparable + + /// Returns true if less or equal to. + public static bool operator <=(Fluence left, Fluence right) + { + return left.Value <= right.ToUnit(left.Unit).Value; + } + + /// Returns true if greater than or equal to. + public static bool operator >=(Fluence left, Fluence right) + { + return left.Value >= right.ToUnit(left.Unit).Value; + } + + /// Returns true if less than. + public static bool operator <(Fluence left, Fluence right) + { + return left.Value < right.ToUnit(left.Unit).Value; + } + + /// Returns true if greater than. + public static bool operator >(Fluence left, Fluence right) + { + return left.Value > right.ToUnit(left.Unit).Value; + } + + // We use obsolete attribute to communicate the preferred equality members to use. + // CS0809: Obsolete member 'memberA' overrides non-obsolete member 'memberB'. + #pragma warning disable CS0809 + + /// Indicates strict equality of two quantities, where both and are exactly equal. + [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Fluence other, Fluence tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")] + public static bool operator ==(Fluence left, Fluence right) + { + return left.Equals(right); + } + + /// Indicates strict inequality of two quantities, where both and are exactly equal. + [Obsolete("For null checks, use `x is null` syntax to not invoke overloads. For equality checks, use Equals(Fluence other, Fluence tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")] + public static bool operator !=(Fluence left, Fluence right) + { + return !(left == right); + } + + /// + /// Indicates strict equality of two quantities, where both and are exactly equal. + [Obsolete("Use Equals(Fluence other, Fluence tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")] + public override bool Equals(object? obj) + { + if (obj is null || !(obj is Fluence otherQuantity)) + return false; + + return Equals(otherQuantity); + } + + /// + /// Indicates strict equality of two quantities, where both and are exactly equal. + [Obsolete("Use Equals(Fluence other, Fluence tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units.")] + public bool Equals(Fluence other) + { + return new { Value, Unit }.Equals(new { other.Value, other.Unit }); + } + + #pragma warning restore CS0809 + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current Fluence. + public override int GetHashCode() + { + return Comparison.GetHashCode(Unit, Value); + } + + /// Compares the current with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit. + /// An object to compare with this instance. + /// + /// is not the same type as this instance. + /// + /// A value that indicates the relative order of the quantities being compared. The return value has these meanings: + /// + /// Value Meaning + /// Less than zero This instance precedes in the sort order. + /// Zero This instance occurs in the same position in the sort order as . + /// Greater than zero This instance follows in the sort order. + /// + /// + public int CompareTo(object? obj) + { + if (obj is null) throw new ArgumentNullException(nameof(obj)); + if (!(obj is Fluence otherQuantity)) throw new ArgumentException("Expected type Fluence.", nameof(obj)); + + return CompareTo(otherQuantity); + } + + /// Compares the current with another and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other when converted to the same unit. + /// A quantity to compare with this instance. + /// A value that indicates the relative order of the quantities being compared. The return value has these meanings: + /// + /// Value Meaning + /// Less than zero This instance precedes in the sort order. + /// Zero This instance occurs in the same position in the sort order as . + /// Greater than zero This instance follows in the sort order. + /// + /// + public int CompareTo(Fluence other) + { + return _value.CompareTo(other.ToUnit(this.Unit).Value); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(FluenceUnit unit) + { + if (Unit == unit) + return Value; + + return ToUnit(unit).Value; + } + + /// + public double As(UnitKey unitKey) + { + return As(unitKey.ToUnit()); + } + + /// + /// Converts this Fluence to another Fluence with the unit representation . + /// + /// The unit to convert to. + /// A Fluence with the specified unit. + public Fluence ToUnit(FluenceUnit unit) + { + return ToUnit(unit, DefaultConversionFunctions); + } + + /// + /// Converts this to another using the given with the unit representation . + /// + /// The unit to convert to. + /// The to use for the conversion. + /// A Fluence with the specified unit. + public Fluence ToUnit(FluenceUnit unit, UnitConverter unitConverter) + { + if (TryToUnit(unit, out var converted)) + { + // Try to convert using the auto-generated conversion methods. + return converted!.Value; + } + else if (unitConverter.TryGetConversionFunction((typeof(Fluence), Unit, typeof(Fluence), unit), out var conversionFunction)) + { + // See if the unit converter has an extensibility conversion registered. + return (Fluence)conversionFunction(this); + } + else if (Unit != BaseUnit) + { + // Conversion to requested unit NOT found. Try to convert to BaseUnit, and then from BaseUnit to requested unit. + var inBaseUnits = ToUnit(BaseUnit); + return inBaseUnits.ToUnit(unit); + } + else + { + // No possible conversion + throw new UnitNotFoundException($"Can't convert {Unit} to {unit}."); + } + } + + /// + /// Attempts to convert this to another with the unit representation . + /// + /// The unit to convert to. + /// The converted in , if successful. + /// True if successful, otherwise false. + private bool TryToUnit(FluenceUnit unit, [NotNullWhen(true)] out Fluence? converted) + { + if (Unit == unit) + { + converted = this; + return true; + } + + Fluence? convertedOrNull = (Unit, unit) switch + { + // FluenceUnit -> BaseUnit + + // BaseUnit -> FluenceUnit + + _ => null + }; + + if (convertedOrNull is null) + { + converted = default; + return false; + } + + converted = convertedOrNull.Value; + return true; + } + + #region Explicit implementations + + double IQuantity.As(Enum unit) + { + if (unit is not FluenceUnit typedUnit) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FluenceUnit)} is supported.", nameof(unit)); + + return As(typedUnit); + } + + /// + IQuantity IQuantity.ToUnit(Enum unit) + { + if (!(unit is FluenceUnit typedUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FluenceUnit)} is supported.", nameof(unit)); + + return ToUnit(typedUnit, DefaultConversionFunctions); + } + + /// + IQuantity IQuantity.ToUnit(FluenceUnit unit) => ToUnit(unit); + + #endregion + + #endregion + + #region ToString Methods + + /// + /// Gets the default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString(null, null); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using the specified format provider, or if null. + /// + public string ToString(string? format, IFormatProvider? provider) + { + return QuantityFormatter.Default.Format(this, format, provider); + } + + #endregion + + } +} diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs index 2f49d5080e..198f6fb741 100644 --- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs @@ -133,28 +133,41 @@ public static IEnumerable> GetDefaultMappings() { yield return new (PowerUnit.BoilerHorsepower, "BoilerHorsepower", "BoilerHorsepower", BaseUnits.Undefined); yield return new (PowerUnit.BritishThermalUnitPerHour, "BritishThermalUnitPerHour", "BritishThermalUnitsPerHour", BaseUnits.Undefined); + yield return new (PowerUnit.DecapascalCubicMeterPerSecond, "DecapascalCubicMeterPerSecond", "DecapascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Decawatt, "Decawatt", "Decawatts", BaseUnits.Undefined); + yield return new (PowerUnit.DecipascalCubicMeterPerSecond, "DecipascalCubicMeterPerSecond", "DecipascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Deciwatt, "Deciwatt", "Deciwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Hectogram, time: DurationUnit.Second)); yield return new (PowerUnit.ElectricalHorsepower, "ElectricalHorsepower", "ElectricalHorsepower", BaseUnits.Undefined); + yield return new (PowerUnit.FemtopascalCubicMeterPerSecond, "FemtopascalCubicMeterPerSecond", "FemtopascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Femtowatt, "Femtowatt", "Femtowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Picogram, time: DurationUnit.Second)); yield return new (PowerUnit.GigajoulePerHour, "GigajoulePerHour", "GigajoulesPerHour", BaseUnits.Undefined); + yield return new (PowerUnit.GigapascalCubicMeterPerSecond, "GigapascalCubicMeterPerSecond", "GigapascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Gigawatt, "Gigawatt", "Gigawatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Millisecond)); yield return new (PowerUnit.HydraulicHorsepower, "HydraulicHorsepower", "HydraulicHorsepower", BaseUnits.Undefined); yield return new (PowerUnit.JoulePerHour, "JoulePerHour", "JoulesPerHour", BaseUnits.Undefined); yield return new (PowerUnit.KilobritishThermalUnitPerHour, "KilobritishThermalUnitPerHour", "KilobritishThermalUnitsPerHour", BaseUnits.Undefined); yield return new (PowerUnit.KilojoulePerHour, "KilojoulePerHour", "KilojoulesPerHour", BaseUnits.Undefined); + yield return new (PowerUnit.KilopascalCubicMeterPerSecond, "KilopascalCubicMeterPerSecond", "KilopascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Kilowatt, "Kilowatt", "Kilowatts", BaseUnits.Undefined); yield return new (PowerUnit.MechanicalHorsepower, "MechanicalHorsepower", "MechanicalHorsepower", BaseUnits.Undefined); yield return new (PowerUnit.MegabritishThermalUnitPerHour, "MegabritishThermalUnitPerHour", "MegabritishThermalUnitsPerHour", BaseUnits.Undefined); yield return new (PowerUnit.MegajoulePerHour, "MegajoulePerHour", "MegajoulesPerHour", BaseUnits.Undefined); + yield return new (PowerUnit.MegapascalCubicMeterPerSecond, "MegapascalCubicMeterPerSecond", "MegapascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Megawatt, "Megawatt", "Megawatts", new BaseUnits(length: LengthUnit.Kilometer, mass: MassUnit.Kilogram, time: DurationUnit.Second)); yield return new (PowerUnit.MetricHorsepower, "MetricHorsepower", "MetricHorsepower", BaseUnits.Undefined); + yield return new (PowerUnit.MicropascalCubicMeterPerSecond, "MicropascalCubicMeterPerSecond", "MicropascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Microwatt, "Microwatt", "Microwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second)); yield return new (PowerUnit.MillijoulePerHour, "MillijoulePerHour", "MillijoulesPerHour", BaseUnits.Undefined); + yield return new (PowerUnit.MillipascalCubicMeterPerSecond, "MillipascalCubicMeterPerSecond", "MillipascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Milliwatt, "Milliwatt", "Milliwatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second)); + yield return new (PowerUnit.NanopascalCubicMeterPerSecond, "NanopascalCubicMeterPerSecond", "NanopascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Nanowatt, "Nanowatt", "Nanowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Microgram, time: DurationUnit.Second)); + yield return new (PowerUnit.PascalCubicMeterPerSecond, "PascalCubicMeterPerSecond", "PascalCubicMeterPerSecond", BaseUnits.Undefined); + yield return new (PowerUnit.PetapascalCubicMeterPerSecond, "PetapascalCubicMeterPerSecond", "PetapascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Petawatt, "Petawatt", "Petawatts", BaseUnits.Undefined); + yield return new (PowerUnit.PicopascalCubicMeterPerSecond, "PicopascalCubicMeterPerSecond", "PicopascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Picowatt, "Picowatt", "Picowatts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Nanogram, time: DurationUnit.Second)); + yield return new (PowerUnit.TerapascalCubicMeterPerSecond, "TerapascalCubicMeterPerSecond", "TerapascalCubicMeterPerSecond", BaseUnits.Undefined); yield return new (PowerUnit.Terawatt, "Terawatt", "Terawatts", new BaseUnits(length: LengthUnit.Megameter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); yield return new (PowerUnit.TonOfRefrigeration, "TonOfRefrigeration", "TonsOfRefrigeration", BaseUnits.Undefined); yield return new (PowerUnit.Watt, "Watt", "Watts", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); @@ -273,11 +286,21 @@ public Power(double value, UnitSystem unitSystem) /// public double BritishThermalUnitsPerHour => As(PowerUnit.BritishThermalUnitPerHour); + /// + /// Gets a value of this quantity converted into + /// + public double DecapascalCubicMeterPerSecond => As(PowerUnit.DecapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Decawatts => As(PowerUnit.Decawatt); + /// + /// Gets a value of this quantity converted into + /// + public double DecipascalCubicMeterPerSecond => As(PowerUnit.DecipascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -288,6 +311,11 @@ public Power(double value, UnitSystem unitSystem) /// public double ElectricalHorsepower => As(PowerUnit.ElectricalHorsepower); + /// + /// Gets a value of this quantity converted into + /// + public double FemtopascalCubicMeterPerSecond => As(PowerUnit.FemtopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -298,6 +326,11 @@ public Power(double value, UnitSystem unitSystem) /// public double GigajoulesPerHour => As(PowerUnit.GigajoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double GigapascalCubicMeterPerSecond => As(PowerUnit.GigapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -323,6 +356,11 @@ public Power(double value, UnitSystem unitSystem) /// public double KilojoulesPerHour => As(PowerUnit.KilojoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double KilopascalCubicMeterPerSecond => As(PowerUnit.KilopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -343,6 +381,11 @@ public Power(double value, UnitSystem unitSystem) /// public double MegajoulesPerHour => As(PowerUnit.MegajoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double MegapascalCubicMeterPerSecond => As(PowerUnit.MegapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -353,6 +396,11 @@ public Power(double value, UnitSystem unitSystem) /// public double MetricHorsepower => As(PowerUnit.MetricHorsepower); + /// + /// Gets a value of this quantity converted into + /// + public double MicropascalCubicMeterPerSecond => As(PowerUnit.MicropascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -363,26 +411,56 @@ public Power(double value, UnitSystem unitSystem) /// public double MillijoulesPerHour => As(PowerUnit.MillijoulePerHour); + /// + /// Gets a value of this quantity converted into + /// + public double MillipascalCubicMeterPerSecond => As(PowerUnit.MillipascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Milliwatts => As(PowerUnit.Milliwatt); + /// + /// Gets a value of this quantity converted into + /// + public double NanopascalCubicMeterPerSecond => As(PowerUnit.NanopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Nanowatts => As(PowerUnit.Nanowatt); + /// + /// Gets a value of this quantity converted into + /// + public double PascalCubicMeterPerSecond => As(PowerUnit.PascalCubicMeterPerSecond); + + /// + /// Gets a value of this quantity converted into + /// + public double PetapascalCubicMeterPerSecond => As(PowerUnit.PetapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Petawatts => As(PowerUnit.Petawatt); + /// + /// Gets a value of this quantity converted into + /// + public double PicopascalCubicMeterPerSecond => As(PowerUnit.PicopascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// public double Picowatts => As(PowerUnit.Picowatt); + /// + /// Gets a value of this quantity converted into + /// + public double TerapascalCubicMeterPerSecond => As(PowerUnit.TerapascalCubicMeterPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -411,28 +489,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: PowerUnit -> BaseUnit unitConverter.SetConversionFunction(PowerUnit.BoilerHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.BritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.DecapascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Decawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.DecipascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Deciwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.ElectricalHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.FemtopascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Femtowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.GigajoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.GigapascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Gigawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.HydraulicHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.JoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.KilobritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.KilojoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.KilopascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Kilowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.MechanicalHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.MegabritishThermalUnitPerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.MegajoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.MegapascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Megawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.MetricHorsepower, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.MicropascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Microwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.MillijoulePerHour, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.MillipascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Milliwatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.NanopascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Nanowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.PascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.PetapascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Petawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.PicopascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Picowatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); + unitConverter.SetConversionFunction(PowerUnit.TerapascalCubicMeterPerSecond, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.Terawatt, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); unitConverter.SetConversionFunction(PowerUnit.TonOfRefrigeration, PowerUnit.Watt, quantity => quantity.ToUnit(PowerUnit.Watt)); @@ -442,28 +533,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: BaseUnit -> PowerUnit unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.BoilerHorsepower, quantity => quantity.ToUnit(PowerUnit.BoilerHorsepower)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.BritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.BritishThermalUnitPerHour)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.DecapascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.DecapascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Decawatt, quantity => quantity.ToUnit(PowerUnit.Decawatt)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.DecipascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.DecipascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Deciwatt, quantity => quantity.ToUnit(PowerUnit.Deciwatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.ElectricalHorsepower, quantity => quantity.ToUnit(PowerUnit.ElectricalHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.FemtopascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.FemtopascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Femtowatt, quantity => quantity.ToUnit(PowerUnit.Femtowatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.GigajoulePerHour, quantity => quantity.ToUnit(PowerUnit.GigajoulePerHour)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.GigapascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.GigapascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Gigawatt, quantity => quantity.ToUnit(PowerUnit.Gigawatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.HydraulicHorsepower, quantity => quantity.ToUnit(PowerUnit.HydraulicHorsepower)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.JoulePerHour, quantity => quantity.ToUnit(PowerUnit.JoulePerHour)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.KilobritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.KilobritishThermalUnitPerHour)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.KilojoulePerHour, quantity => quantity.ToUnit(PowerUnit.KilojoulePerHour)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.KilopascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.KilopascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Kilowatt, quantity => quantity.ToUnit(PowerUnit.Kilowatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MechanicalHorsepower, quantity => quantity.ToUnit(PowerUnit.MechanicalHorsepower)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MegabritishThermalUnitPerHour, quantity => quantity.ToUnit(PowerUnit.MegabritishThermalUnitPerHour)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MegajoulePerHour, quantity => quantity.ToUnit(PowerUnit.MegajoulePerHour)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MegapascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.MegapascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Megawatt, quantity => quantity.ToUnit(PowerUnit.Megawatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MetricHorsepower, quantity => quantity.ToUnit(PowerUnit.MetricHorsepower)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MicropascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.MicropascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Microwatt, quantity => quantity.ToUnit(PowerUnit.Microwatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MillijoulePerHour, quantity => quantity.ToUnit(PowerUnit.MillijoulePerHour)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.MillipascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.MillipascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Milliwatt, quantity => quantity.ToUnit(PowerUnit.Milliwatt)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.NanopascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.NanopascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Nanowatt, quantity => quantity.ToUnit(PowerUnit.Nanowatt)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.PascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.PascalCubicMeterPerSecond)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.PetapascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.PetapascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Petawatt, quantity => quantity.ToUnit(PowerUnit.Petawatt)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.PicopascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.PicopascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Picowatt, quantity => quantity.ToUnit(PowerUnit.Picowatt)); + unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.TerapascalCubicMeterPerSecond, quantity => quantity.ToUnit(PowerUnit.TerapascalCubicMeterPerSecond)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.Terawatt, quantity => quantity.ToUnit(PowerUnit.Terawatt)); unitConverter.SetConversionFunction(PowerUnit.Watt, PowerUnit.TonOfRefrigeration, quantity => quantity.ToUnit(PowerUnit.TonOfRefrigeration)); } @@ -509,6 +613,14 @@ public static Power FromBritishThermalUnitsPerHour(double value) return new Power(value, PowerUnit.BritishThermalUnitPerHour); } + /// + /// Creates a from . + /// + public static Power FromDecapascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.DecapascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -517,6 +629,14 @@ public static Power FromDecawatts(double value) return new Power(value, PowerUnit.Decawatt); } + /// + /// Creates a from . + /// + public static Power FromDecipascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.DecipascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -533,6 +653,14 @@ public static Power FromElectricalHorsepower(double value) return new Power(value, PowerUnit.ElectricalHorsepower); } + /// + /// Creates a from . + /// + public static Power FromFemtopascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.FemtopascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -549,6 +677,14 @@ public static Power FromGigajoulesPerHour(double value) return new Power(value, PowerUnit.GigajoulePerHour); } + /// + /// Creates a from . + /// + public static Power FromGigapascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.GigapascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -589,6 +725,14 @@ public static Power FromKilojoulesPerHour(double value) return new Power(value, PowerUnit.KilojoulePerHour); } + /// + /// Creates a from . + /// + public static Power FromKilopascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.KilopascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -621,6 +765,14 @@ public static Power FromMegajoulesPerHour(double value) return new Power(value, PowerUnit.MegajoulePerHour); } + /// + /// Creates a from . + /// + public static Power FromMegapascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.MegapascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -637,6 +789,14 @@ public static Power FromMetricHorsepower(double value) return new Power(value, PowerUnit.MetricHorsepower); } + /// + /// Creates a from . + /// + public static Power FromMicropascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.MicropascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -653,6 +813,14 @@ public static Power FromMillijoulesPerHour(double value) return new Power(value, PowerUnit.MillijoulePerHour); } + /// + /// Creates a from . + /// + public static Power FromMillipascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.MillipascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -661,6 +829,14 @@ public static Power FromMilliwatts(double value) return new Power(value, PowerUnit.Milliwatt); } + /// + /// Creates a from . + /// + public static Power FromNanopascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.NanopascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -669,6 +845,22 @@ public static Power FromNanowatts(double value) return new Power(value, PowerUnit.Nanowatt); } + /// + /// Creates a from . + /// + public static Power FromPascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.PascalCubicMeterPerSecond); + } + + /// + /// Creates a from . + /// + public static Power FromPetapascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.PetapascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -677,6 +869,14 @@ public static Power FromPetawatts(double value) return new Power(value, PowerUnit.Petawatt); } + /// + /// Creates a from . + /// + public static Power FromPicopascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.PicopascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -685,6 +885,14 @@ public static Power FromPicowatts(double value) return new Power(value, PowerUnit.Picowatt); } + /// + /// Creates a from . + /// + public static Power FromTerapascalCubicMeterPerSecond(double value) + { + return new Power(value, PowerUnit.TerapascalCubicMeterPerSecond); + } + /// /// Creates a from . /// @@ -1192,56 +1400,82 @@ private bool TryToUnit(PowerUnit unit, [NotNullWhen(true)] out Power? converted) // PowerUnit -> BaseUnit (PowerUnit.BoilerHorsepower, PowerUnit.Watt) => new Power(_value * 9812.5, PowerUnit.Watt), (PowerUnit.BritishThermalUnitPerHour, PowerUnit.Watt) => new Power(_value * 1055.05585262 / 3600, PowerUnit.Watt), + (PowerUnit.DecapascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e1d, PowerUnit.Watt), (PowerUnit.Decawatt, PowerUnit.Watt) => new Power((_value) * 1e1d, PowerUnit.Watt), + (PowerUnit.DecipascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-1d, PowerUnit.Watt), (PowerUnit.Deciwatt, PowerUnit.Watt) => new Power((_value) * 1e-1d, PowerUnit.Watt), (PowerUnit.ElectricalHorsepower, PowerUnit.Watt) => new Power(_value * 746, PowerUnit.Watt), + (PowerUnit.FemtopascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-15d, PowerUnit.Watt), (PowerUnit.Femtowatt, PowerUnit.Watt) => new Power((_value) * 1e-15d, PowerUnit.Watt), (PowerUnit.GigajoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e9d, PowerUnit.Watt), + (PowerUnit.GigapascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e9d, PowerUnit.Watt), (PowerUnit.Gigawatt, PowerUnit.Watt) => new Power((_value) * 1e9d, PowerUnit.Watt), (PowerUnit.HydraulicHorsepower, PowerUnit.Watt) => new Power(_value * 745.69987158227022, PowerUnit.Watt), (PowerUnit.JoulePerHour, PowerUnit.Watt) => new Power(_value / 3600, PowerUnit.Watt), (PowerUnit.KilobritishThermalUnitPerHour, PowerUnit.Watt) => new Power((_value * 1055.05585262 / 3600) * 1e3d, PowerUnit.Watt), (PowerUnit.KilojoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e3d, PowerUnit.Watt), + (PowerUnit.KilopascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e3d, PowerUnit.Watt), (PowerUnit.Kilowatt, PowerUnit.Watt) => new Power((_value) * 1e3d, PowerUnit.Watt), (PowerUnit.MechanicalHorsepower, PowerUnit.Watt) => new Power(_value * 76.0402249 * 9.80665, PowerUnit.Watt), (PowerUnit.MegabritishThermalUnitPerHour, PowerUnit.Watt) => new Power((_value * 1055.05585262 / 3600) * 1e6d, PowerUnit.Watt), (PowerUnit.MegajoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e6d, PowerUnit.Watt), + (PowerUnit.MegapascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e6d, PowerUnit.Watt), (PowerUnit.Megawatt, PowerUnit.Watt) => new Power((_value) * 1e6d, PowerUnit.Watt), (PowerUnit.MetricHorsepower, PowerUnit.Watt) => new Power(_value * 75 * 9.80665, PowerUnit.Watt), + (PowerUnit.MicropascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-6d, PowerUnit.Watt), (PowerUnit.Microwatt, PowerUnit.Watt) => new Power((_value) * 1e-6d, PowerUnit.Watt), (PowerUnit.MillijoulePerHour, PowerUnit.Watt) => new Power((_value / 3600) * 1e-3d, PowerUnit.Watt), + (PowerUnit.MillipascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-3d, PowerUnit.Watt), (PowerUnit.Milliwatt, PowerUnit.Watt) => new Power((_value) * 1e-3d, PowerUnit.Watt), + (PowerUnit.NanopascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-9d, PowerUnit.Watt), (PowerUnit.Nanowatt, PowerUnit.Watt) => new Power((_value) * 1e-9d, PowerUnit.Watt), + (PowerUnit.PascalCubicMeterPerSecond, PowerUnit.Watt) => new Power(_value, PowerUnit.Watt), + (PowerUnit.PetapascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e15d, PowerUnit.Watt), (PowerUnit.Petawatt, PowerUnit.Watt) => new Power((_value) * 1e15d, PowerUnit.Watt), + (PowerUnit.PicopascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e-12d, PowerUnit.Watt), (PowerUnit.Picowatt, PowerUnit.Watt) => new Power((_value) * 1e-12d, PowerUnit.Watt), + (PowerUnit.TerapascalCubicMeterPerSecond, PowerUnit.Watt) => new Power((_value) * 1e12d, PowerUnit.Watt), (PowerUnit.Terawatt, PowerUnit.Watt) => new Power((_value) * 1e12d, PowerUnit.Watt), (PowerUnit.TonOfRefrigeration, PowerUnit.Watt) => new Power(_value * 3516.853, PowerUnit.Watt), // BaseUnit -> PowerUnit (PowerUnit.Watt, PowerUnit.BoilerHorsepower) => new Power(_value / 9812.5, PowerUnit.BoilerHorsepower), (PowerUnit.Watt, PowerUnit.BritishThermalUnitPerHour) => new Power(_value * 3600 / 1055.05585262, PowerUnit.BritishThermalUnitPerHour), + (PowerUnit.Watt, PowerUnit.DecapascalCubicMeterPerSecond) => new Power((_value) / 1e1d, PowerUnit.DecapascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Decawatt) => new Power((_value) / 1e1d, PowerUnit.Decawatt), + (PowerUnit.Watt, PowerUnit.DecipascalCubicMeterPerSecond) => new Power((_value) / 1e-1d, PowerUnit.DecipascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Deciwatt) => new Power((_value) / 1e-1d, PowerUnit.Deciwatt), (PowerUnit.Watt, PowerUnit.ElectricalHorsepower) => new Power(_value / 746, PowerUnit.ElectricalHorsepower), + (PowerUnit.Watt, PowerUnit.FemtopascalCubicMeterPerSecond) => new Power((_value) / 1e-15d, PowerUnit.FemtopascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Femtowatt) => new Power((_value) / 1e-15d, PowerUnit.Femtowatt), (PowerUnit.Watt, PowerUnit.GigajoulePerHour) => new Power((_value * 3600) / 1e9d, PowerUnit.GigajoulePerHour), + (PowerUnit.Watt, PowerUnit.GigapascalCubicMeterPerSecond) => new Power((_value) / 1e9d, PowerUnit.GigapascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Gigawatt) => new Power((_value) / 1e9d, PowerUnit.Gigawatt), (PowerUnit.Watt, PowerUnit.HydraulicHorsepower) => new Power(_value / 745.69987158227022, PowerUnit.HydraulicHorsepower), (PowerUnit.Watt, PowerUnit.JoulePerHour) => new Power(_value * 3600, PowerUnit.JoulePerHour), (PowerUnit.Watt, PowerUnit.KilobritishThermalUnitPerHour) => new Power((_value * 3600 / 1055.05585262) / 1e3d, PowerUnit.KilobritishThermalUnitPerHour), (PowerUnit.Watt, PowerUnit.KilojoulePerHour) => new Power((_value * 3600) / 1e3d, PowerUnit.KilojoulePerHour), + (PowerUnit.Watt, PowerUnit.KilopascalCubicMeterPerSecond) => new Power((_value) / 1e3d, PowerUnit.KilopascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Kilowatt) => new Power((_value) / 1e3d, PowerUnit.Kilowatt), (PowerUnit.Watt, PowerUnit.MechanicalHorsepower) => new Power(_value / (76.0402249 * 9.80665), PowerUnit.MechanicalHorsepower), (PowerUnit.Watt, PowerUnit.MegabritishThermalUnitPerHour) => new Power((_value * 3600 / 1055.05585262) / 1e6d, PowerUnit.MegabritishThermalUnitPerHour), (PowerUnit.Watt, PowerUnit.MegajoulePerHour) => new Power((_value * 3600) / 1e6d, PowerUnit.MegajoulePerHour), + (PowerUnit.Watt, PowerUnit.MegapascalCubicMeterPerSecond) => new Power((_value) / 1e6d, PowerUnit.MegapascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Megawatt) => new Power((_value) / 1e6d, PowerUnit.Megawatt), (PowerUnit.Watt, PowerUnit.MetricHorsepower) => new Power(_value / (75 * 9.80665), PowerUnit.MetricHorsepower), + (PowerUnit.Watt, PowerUnit.MicropascalCubicMeterPerSecond) => new Power((_value) / 1e-6d, PowerUnit.MicropascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Microwatt) => new Power((_value) / 1e-6d, PowerUnit.Microwatt), (PowerUnit.Watt, PowerUnit.MillijoulePerHour) => new Power((_value * 3600) / 1e-3d, PowerUnit.MillijoulePerHour), + (PowerUnit.Watt, PowerUnit.MillipascalCubicMeterPerSecond) => new Power((_value) / 1e-3d, PowerUnit.MillipascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Milliwatt) => new Power((_value) / 1e-3d, PowerUnit.Milliwatt), + (PowerUnit.Watt, PowerUnit.NanopascalCubicMeterPerSecond) => new Power((_value) / 1e-9d, PowerUnit.NanopascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Nanowatt) => new Power((_value) / 1e-9d, PowerUnit.Nanowatt), + (PowerUnit.Watt, PowerUnit.PascalCubicMeterPerSecond) => new Power(_value, PowerUnit.PascalCubicMeterPerSecond), + (PowerUnit.Watt, PowerUnit.PetapascalCubicMeterPerSecond) => new Power((_value) / 1e15d, PowerUnit.PetapascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Petawatt) => new Power((_value) / 1e15d, PowerUnit.Petawatt), + (PowerUnit.Watt, PowerUnit.PicopascalCubicMeterPerSecond) => new Power((_value) / 1e-12d, PowerUnit.PicopascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Picowatt) => new Power((_value) / 1e-12d, PowerUnit.Picowatt), + (PowerUnit.Watt, PowerUnit.TerapascalCubicMeterPerSecond) => new Power((_value) / 1e12d, PowerUnit.TerapascalCubicMeterPerSecond), (PowerUnit.Watt, PowerUnit.Terawatt) => new Power((_value) / 1e12d, PowerUnit.Terawatt), (PowerUnit.Watt, PowerUnit.TonOfRefrigeration) => new Power(_value / 3516.853, PowerUnit.TonOfRefrigeration), diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs index 2a91befa59..4545242e65 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs @@ -129,17 +129,24 @@ public static IEnumerable> GetDefaultMappings() { yield return new (PressureUnit.Atmosphere, "Atmosphere", "Atmospheres", BaseUnits.Undefined); yield return new (PressureUnit.Bar, "Bar", "Bars", BaseUnits.Undefined); + yield return new (PressureUnit.BarG, "BarG", "BarsG", BaseUnits.Undefined); yield return new (PressureUnit.Centibar, "Centibar", "Centibars", BaseUnits.Undefined); + yield return new (PressureUnit.CentibarG, "CentibarG", "CentibarsG", BaseUnits.Undefined); yield return new (PressureUnit.CentimeterOfWaterColumn, "CentimeterOfWaterColumn", "CentimetersOfWaterColumn", BaseUnits.Undefined); yield return new (PressureUnit.Decapascal, "Decapascal", "Decapascals", new BaseUnits(length: LengthUnit.Decimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.DecapascalG, "DecapascalG", "DecapascalsG", BaseUnits.Undefined); yield return new (PressureUnit.Decibar, "Decibar", "Decibars", BaseUnits.Undefined); + yield return new (PressureUnit.DecibarG, "DecibarG", "DecibarsG", BaseUnits.Undefined); yield return new (PressureUnit.DynePerSquareCentimeter, "DynePerSquareCentimeter", "DynesPerSquareCentimeter", BaseUnits.Undefined); yield return new (PressureUnit.FootOfHead, "FootOfHead", "FeetOfHead", BaseUnits.Undefined); yield return new (PressureUnit.Gigapascal, "Gigapascal", "Gigapascals", new BaseUnits(length: LengthUnit.Nanometer, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.GigapascalG, "GigapascalG", "GigapascalsG", BaseUnits.Undefined); yield return new (PressureUnit.Hectopascal, "Hectopascal", "Hectopascals", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.HectopascalG, "HectopascalG", "HectopascalsG", BaseUnits.Undefined); yield return new (PressureUnit.InchOfMercury, "InchOfMercury", "InchesOfMercury", BaseUnits.Undefined); yield return new (PressureUnit.InchOfWaterColumn, "InchOfWaterColumn", "InchesOfWaterColumn", BaseUnits.Undefined); yield return new (PressureUnit.Kilobar, "Kilobar", "Kilobars", BaseUnits.Undefined); + yield return new (PressureUnit.KilobarG, "KilobarG", "KilobarsG", BaseUnits.Undefined); yield return new (PressureUnit.KilogramForcePerSquareCentimeter, "KilogramForcePerSquareCentimeter", "KilogramsForcePerSquareCentimeter", BaseUnits.Undefined); yield return new (PressureUnit.KilogramForcePerSquareMeter, "KilogramForcePerSquareMeter", "KilogramsForcePerSquareMeter", BaseUnits.Undefined); yield return new (PressureUnit.KilogramForcePerSquareMillimeter, "KilogramForcePerSquareMillimeter", "KilogramsForcePerSquareMillimeter", BaseUnits.Undefined); @@ -147,25 +154,33 @@ public static IEnumerable> GetDefaultMappings() yield return new (PressureUnit.KilonewtonPerSquareMeter, "KilonewtonPerSquareMeter", "KilonewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); yield return new (PressureUnit.KilonewtonPerSquareMillimeter, "KilonewtonPerSquareMillimeter", "KilonewtonsPerSquareMillimeter", BaseUnits.Undefined); yield return new (PressureUnit.Kilopascal, "Kilopascal", "Kilopascals", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.KilopascalG, "KilopascalG", "KilopascalsG", BaseUnits.Undefined); yield return new (PressureUnit.KilopoundForcePerSquareFoot, "KilopoundForcePerSquareFoot", "KilopoundsForcePerSquareFoot", BaseUnits.Undefined); yield return new (PressureUnit.KilopoundForcePerSquareInch, "KilopoundForcePerSquareInch", "KilopoundsForcePerSquareInch", BaseUnits.Undefined); yield return new (PressureUnit.KilopoundForcePerSquareMil, "KilopoundForcePerSquareMil", "KilopoundsForcePerSquareMil", BaseUnits.Undefined); yield return new (PressureUnit.Megabar, "Megabar", "Megabars", BaseUnits.Undefined); + yield return new (PressureUnit.MegabarG, "MegabarG", "MegabarsG", BaseUnits.Undefined); yield return new (PressureUnit.MeganewtonPerSquareMeter, "MeganewtonPerSquareMeter", "MeganewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second)); yield return new (PressureUnit.Megapascal, "Megapascal", "Megapascals", new BaseUnits(length: LengthUnit.Micrometer, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.MegapascalG, "MegapascalG", "MegapascalsG", BaseUnits.Undefined); yield return new (PressureUnit.MeterOfHead, "MeterOfHead", "MetersOfHead", BaseUnits.Undefined); yield return new (PressureUnit.MeterOfWaterColumn, "MeterOfWaterColumn", "MetersOfWaterColumn", BaseUnits.Undefined); yield return new (PressureUnit.Microbar, "Microbar", "Microbars", BaseUnits.Undefined); + yield return new (PressureUnit.MicrobarG, "MicrobarG", "MicrobarsG", BaseUnits.Undefined); yield return new (PressureUnit.Micropascal, "Micropascal", "Micropascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Milligram, time: DurationUnit.Second)); + yield return new (PressureUnit.MicropascalG, "MicropascalG", "MicropascalsG", BaseUnits.Undefined); yield return new (PressureUnit.Millibar, "Millibar", "Millibars", BaseUnits.Undefined); + yield return new (PressureUnit.MillibarG, "MillibarG", "MillibarsG", BaseUnits.Undefined); yield return new (PressureUnit.MillimeterOfMercury, "MillimeterOfMercury", "MillimetersOfMercury", BaseUnits.Undefined); yield return new (PressureUnit.MillimeterOfWaterColumn, "MillimeterOfWaterColumn", "MillimetersOfWaterColumn", BaseUnits.Undefined); yield return new (PressureUnit.Millipascal, "Millipascal", "Millipascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram, time: DurationUnit.Second)); + yield return new (PressureUnit.MillipascalG, "MillipascalG", "MillipascalsG", BaseUnits.Undefined); yield return new (PressureUnit.Millitorr, "Millitorr", "Millitorrs", BaseUnits.Undefined); yield return new (PressureUnit.NewtonPerSquareCentimeter, "NewtonPerSquareCentimeter", "NewtonsPerSquareCentimeter", BaseUnits.Undefined); yield return new (PressureUnit.NewtonPerSquareMeter, "NewtonPerSquareMeter", "NewtonsPerSquareMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); yield return new (PressureUnit.NewtonPerSquareMillimeter, "NewtonPerSquareMillimeter", "NewtonsPerSquareMillimeter", BaseUnits.Undefined); yield return new (PressureUnit.Pascal, "Pascal", "Pascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)); + yield return new (PressureUnit.PascalG, "PascalG", "PascalsG", BaseUnits.Undefined); yield return new (PressureUnit.PoundForcePerSquareFoot, "PoundForcePerSquareFoot", "PoundsForcePerSquareFoot", BaseUnits.Undefined); yield return new (PressureUnit.PoundForcePerSquareInch, "PoundForcePerSquareInch", "PoundsForcePerSquareInch", BaseUnits.Undefined); yield return new (PressureUnit.PoundForcePerSquareMil, "PoundForcePerSquareMil", "PoundsForcePerSquareMil", BaseUnits.Undefined); @@ -290,11 +305,21 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Bars => As(PressureUnit.Bar); + /// + /// Gets a value of this quantity converted into + /// + public double BarsG => As(PressureUnit.BarG); + /// /// Gets a value of this quantity converted into /// public double Centibars => As(PressureUnit.Centibar); + /// + /// Gets a value of this quantity converted into + /// + public double CentibarsG => As(PressureUnit.CentibarG); + /// /// Gets a value of this quantity converted into /// @@ -305,11 +330,21 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Decapascals => As(PressureUnit.Decapascal); + /// + /// Gets a value of this quantity converted into + /// + public double DecapascalsG => As(PressureUnit.DecapascalG); + /// /// Gets a value of this quantity converted into /// public double Decibars => As(PressureUnit.Decibar); + /// + /// Gets a value of this quantity converted into + /// + public double DecibarsG => As(PressureUnit.DecibarG); + /// /// Gets a value of this quantity converted into /// @@ -325,11 +360,21 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Gigapascals => As(PressureUnit.Gigapascal); + /// + /// Gets a value of this quantity converted into + /// + public double GigapascalsG => As(PressureUnit.GigapascalG); + /// /// Gets a value of this quantity converted into /// public double Hectopascals => As(PressureUnit.Hectopascal); + /// + /// Gets a value of this quantity converted into + /// + public double HectopascalsG => As(PressureUnit.HectopascalG); + /// /// Gets a value of this quantity converted into /// @@ -345,6 +390,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Kilobars => As(PressureUnit.Kilobar); + /// + /// Gets a value of this quantity converted into + /// + public double KilobarsG => As(PressureUnit.KilobarG); + /// /// Gets a value of this quantity converted into /// @@ -380,6 +430,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Kilopascals => As(PressureUnit.Kilopascal); + /// + /// Gets a value of this quantity converted into + /// + public double KilopascalsG => As(PressureUnit.KilopascalG); + /// /// Gets a value of this quantity converted into /// @@ -400,6 +455,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Megabars => As(PressureUnit.Megabar); + /// + /// Gets a value of this quantity converted into + /// + public double MegabarsG => As(PressureUnit.MegabarG); + /// /// Gets a value of this quantity converted into /// @@ -410,6 +470,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Megapascals => As(PressureUnit.Megapascal); + /// + /// Gets a value of this quantity converted into + /// + public double MegapascalsG => As(PressureUnit.MegapascalG); + /// /// Gets a value of this quantity converted into /// @@ -425,16 +490,31 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Microbars => As(PressureUnit.Microbar); + /// + /// Gets a value of this quantity converted into + /// + public double MicrobarsG => As(PressureUnit.MicrobarG); + /// /// Gets a value of this quantity converted into /// public double Micropascals => As(PressureUnit.Micropascal); + /// + /// Gets a value of this quantity converted into + /// + public double MicropascalsG => As(PressureUnit.MicropascalG); + /// /// Gets a value of this quantity converted into /// public double Millibars => As(PressureUnit.Millibar); + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsG => As(PressureUnit.MillibarG); + /// /// Gets a value of this quantity converted into /// @@ -450,6 +530,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Millipascals => As(PressureUnit.Millipascal); + /// + /// Gets a value of this quantity converted into + /// + public double MillipascalsG => As(PressureUnit.MillipascalG); + /// /// Gets a value of this quantity converted into /// @@ -475,6 +560,11 @@ public Pressure(double value, UnitSystem unitSystem) /// public double Pascals => As(PressureUnit.Pascal); + /// + /// Gets a value of this quantity converted into + /// + public double PascalsG => As(PressureUnit.PascalG); + /// /// Gets a value of this quantity converted into /// @@ -533,17 +623,24 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: PressureUnit -> BaseUnit unitConverter.SetConversionFunction(PressureUnit.Atmosphere, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Bar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.BarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Centibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.CentibarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.CentimeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Decapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.DecapascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Decibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.DecibarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.DynePerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.FootOfHead, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Gigapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.GigapascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Hectopascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.HectopascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.InchOfMercury, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.InchOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Kilobar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.KilobarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilogramForcePerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); @@ -551,24 +648,32 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilonewtonPerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Kilopascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.KilopascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareFoot, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareInch, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.KilopoundForcePerSquareMil, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Megabar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MegabarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.MeganewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Megapascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MegapascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.MeterOfHead, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.MeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Microbar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MicrobarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Micropascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MicropascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Millibar, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MillibarG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.MillimeterOfMercury, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.MillimeterOfWaterColumn, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Millipascal, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.MillipascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.Millitorr, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareCentimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.NewtonPerSquareMillimeter, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); + unitConverter.SetConversionFunction(PressureUnit.PascalG, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareFoot, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareInch, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); unitConverter.SetConversionFunction(PressureUnit.PoundForcePerSquareMil, PressureUnit.Pascal, quantity => quantity.ToUnit(PressureUnit.Pascal)); @@ -585,17 +690,24 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: BaseUnit -> PressureUnit unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Atmosphere, quantity => quantity.ToUnit(PressureUnit.Atmosphere)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Bar, quantity => quantity.ToUnit(PressureUnit.Bar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.BarG, quantity => quantity.ToUnit(PressureUnit.BarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Centibar, quantity => quantity.ToUnit(PressureUnit.Centibar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.CentibarG, quantity => quantity.ToUnit(PressureUnit.CentibarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.CentimeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.CentimeterOfWaterColumn)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Decapascal, quantity => quantity.ToUnit(PressureUnit.Decapascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.DecapascalG, quantity => quantity.ToUnit(PressureUnit.DecapascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Decibar, quantity => quantity.ToUnit(PressureUnit.Decibar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.DecibarG, quantity => quantity.ToUnit(PressureUnit.DecibarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.DynePerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.DynePerSquareCentimeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.FootOfHead, quantity => quantity.ToUnit(PressureUnit.FootOfHead)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Gigapascal, quantity => quantity.ToUnit(PressureUnit.Gigapascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.GigapascalG, quantity => quantity.ToUnit(PressureUnit.GigapascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Hectopascal, quantity => quantity.ToUnit(PressureUnit.Hectopascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.HectopascalG, quantity => quantity.ToUnit(PressureUnit.HectopascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.InchOfMercury, quantity => quantity.ToUnit(PressureUnit.InchOfMercury)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.InchOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.InchOfWaterColumn)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Kilobar, quantity => quantity.ToUnit(PressureUnit.Kilobar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilobarG, quantity => quantity.ToUnit(PressureUnit.KilobarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareCentimeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareMeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.KilogramForcePerSquareMillimeter)); @@ -603,24 +715,32 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.KilonewtonPerSquareMeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.KilonewtonPerSquareMillimeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Kilopascal, quantity => quantity.ToUnit(PressureUnit.Kilopascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilopascalG, quantity => quantity.ToUnit(PressureUnit.KilopascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareFoot, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareFoot)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareInch, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareInch)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareMil, quantity => quantity.ToUnit(PressureUnit.KilopoundForcePerSquareMil)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Megabar, quantity => quantity.ToUnit(PressureUnit.Megabar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MegabarG, quantity => quantity.ToUnit(PressureUnit.MegabarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MeganewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.MeganewtonPerSquareMeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Megapascal, quantity => quantity.ToUnit(PressureUnit.Megapascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MegapascalG, quantity => quantity.ToUnit(PressureUnit.MegapascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MeterOfHead, quantity => quantity.ToUnit(PressureUnit.MeterOfHead)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.MeterOfWaterColumn)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Microbar, quantity => quantity.ToUnit(PressureUnit.Microbar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MicrobarG, quantity => quantity.ToUnit(PressureUnit.MicrobarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Micropascal, quantity => quantity.ToUnit(PressureUnit.Micropascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MicropascalG, quantity => quantity.ToUnit(PressureUnit.MicropascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Millibar, quantity => quantity.ToUnit(PressureUnit.Millibar)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MillibarG, quantity => quantity.ToUnit(PressureUnit.MillibarG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MillimeterOfMercury, quantity => quantity.ToUnit(PressureUnit.MillimeterOfMercury)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MillimeterOfWaterColumn, quantity => quantity.ToUnit(PressureUnit.MillimeterOfWaterColumn)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Millipascal, quantity => quantity.ToUnit(PressureUnit.Millipascal)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.MillipascalG, quantity => quantity.ToUnit(PressureUnit.MillipascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.Millitorr, quantity => quantity.ToUnit(PressureUnit.Millitorr)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.NewtonPerSquareCentimeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareCentimeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.NewtonPerSquareMeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareMeter)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.NewtonPerSquareMillimeter, quantity => quantity.ToUnit(PressureUnit.NewtonPerSquareMillimeter)); + unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.PascalG, quantity => quantity.ToUnit(PressureUnit.PascalG)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareFoot, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareFoot)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareInch, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareInch)); unitConverter.SetConversionFunction(PressureUnit.Pascal, PressureUnit.PoundForcePerSquareMil, quantity => quantity.ToUnit(PressureUnit.PoundForcePerSquareMil)); @@ -673,6 +793,14 @@ public static Pressure FromBars(double value) return new Pressure(value, PressureUnit.Bar); } + /// + /// Creates a from . + /// + public static Pressure FromBarsG(double value) + { + return new Pressure(value, PressureUnit.BarG); + } + /// /// Creates a from . /// @@ -681,6 +809,14 @@ public static Pressure FromCentibars(double value) return new Pressure(value, PressureUnit.Centibar); } + /// + /// Creates a from . + /// + public static Pressure FromCentibarsG(double value) + { + return new Pressure(value, PressureUnit.CentibarG); + } + /// /// Creates a from . /// @@ -697,6 +833,14 @@ public static Pressure FromDecapascals(double value) return new Pressure(value, PressureUnit.Decapascal); } + /// + /// Creates a from . + /// + public static Pressure FromDecapascalsG(double value) + { + return new Pressure(value, PressureUnit.DecapascalG); + } + /// /// Creates a from . /// @@ -705,6 +849,14 @@ public static Pressure FromDecibars(double value) return new Pressure(value, PressureUnit.Decibar); } + /// + /// Creates a from . + /// + public static Pressure FromDecibarsG(double value) + { + return new Pressure(value, PressureUnit.DecibarG); + } + /// /// Creates a from . /// @@ -729,6 +881,14 @@ public static Pressure FromGigapascals(double value) return new Pressure(value, PressureUnit.Gigapascal); } + /// + /// Creates a from . + /// + public static Pressure FromGigapascalsG(double value) + { + return new Pressure(value, PressureUnit.GigapascalG); + } + /// /// Creates a from . /// @@ -737,6 +897,14 @@ public static Pressure FromHectopascals(double value) return new Pressure(value, PressureUnit.Hectopascal); } + /// + /// Creates a from . + /// + public static Pressure FromHectopascalsG(double value) + { + return new Pressure(value, PressureUnit.HectopascalG); + } + /// /// Creates a from . /// @@ -761,6 +929,14 @@ public static Pressure FromKilobars(double value) return new Pressure(value, PressureUnit.Kilobar); } + /// + /// Creates a from . + /// + public static Pressure FromKilobarsG(double value) + { + return new Pressure(value, PressureUnit.KilobarG); + } + /// /// Creates a from . /// @@ -817,6 +993,14 @@ public static Pressure FromKilopascals(double value) return new Pressure(value, PressureUnit.Kilopascal); } + /// + /// Creates a from . + /// + public static Pressure FromKilopascalsG(double value) + { + return new Pressure(value, PressureUnit.KilopascalG); + } + /// /// Creates a from . /// @@ -849,6 +1033,14 @@ public static Pressure FromMegabars(double value) return new Pressure(value, PressureUnit.Megabar); } + /// + /// Creates a from . + /// + public static Pressure FromMegabarsG(double value) + { + return new Pressure(value, PressureUnit.MegabarG); + } + /// /// Creates a from . /// @@ -865,6 +1057,14 @@ public static Pressure FromMegapascals(double value) return new Pressure(value, PressureUnit.Megapascal); } + /// + /// Creates a from . + /// + public static Pressure FromMegapascalsG(double value) + { + return new Pressure(value, PressureUnit.MegapascalG); + } + /// /// Creates a from . /// @@ -889,6 +1089,14 @@ public static Pressure FromMicrobars(double value) return new Pressure(value, PressureUnit.Microbar); } + /// + /// Creates a from . + /// + public static Pressure FromMicrobarsG(double value) + { + return new Pressure(value, PressureUnit.MicrobarG); + } + /// /// Creates a from . /// @@ -897,6 +1105,14 @@ public static Pressure FromMicropascals(double value) return new Pressure(value, PressureUnit.Micropascal); } + /// + /// Creates a from . + /// + public static Pressure FromMicropascalsG(double value) + { + return new Pressure(value, PressureUnit.MicropascalG); + } + /// /// Creates a from . /// @@ -905,6 +1121,14 @@ public static Pressure FromMillibars(double value) return new Pressure(value, PressureUnit.Millibar); } + /// + /// Creates a from . + /// + public static Pressure FromMillibarsG(double value) + { + return new Pressure(value, PressureUnit.MillibarG); + } + /// /// Creates a from . /// @@ -929,6 +1153,14 @@ public static Pressure FromMillipascals(double value) return new Pressure(value, PressureUnit.Millipascal); } + /// + /// Creates a from . + /// + public static Pressure FromMillipascalsG(double value) + { + return new Pressure(value, PressureUnit.MillipascalG); + } + /// /// Creates a from . /// @@ -969,6 +1201,14 @@ public static Pressure FromPascals(double value) return new Pressure(value, PressureUnit.Pascal); } + /// + /// Creates a from . + /// + public static Pressure FromPascalsG(double value) + { + return new Pressure(value, PressureUnit.PascalG); + } + /// /// Creates a from . /// @@ -1500,17 +1740,24 @@ private bool TryToUnit(PressureUnit unit, [NotNullWhen(true)] out Pressure? conv // PressureUnit -> BaseUnit (PressureUnit.Atmosphere, PressureUnit.Pascal) => new Pressure(_value * 1.01325 * 1e5, PressureUnit.Pascal), (PressureUnit.Bar, PressureUnit.Pascal) => new Pressure(_value * 1e5, PressureUnit.Pascal), + (PressureUnit.BarG, PressureUnit.Pascal) => new Pressure((_value * 1e5) + 101325, PressureUnit.Pascal), (PressureUnit.Centibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-2d, PressureUnit.Pascal), + (PressureUnit.CentibarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e-2d, PressureUnit.Pascal), (PressureUnit.CentimeterOfWaterColumn, PressureUnit.Pascal) => new Pressure((_value * 9.80665e3) * 1e-2d, PressureUnit.Pascal), (PressureUnit.Decapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e1d, PressureUnit.Pascal), + (PressureUnit.DecapascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e1d, PressureUnit.Pascal), (PressureUnit.Decibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-1d, PressureUnit.Pascal), + (PressureUnit.DecibarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e-1d, PressureUnit.Pascal), (PressureUnit.DynePerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 1.0e-1, PressureUnit.Pascal), (PressureUnit.FootOfHead, PressureUnit.Pascal) => new Pressure(_value * 9804.139432 * 0.3048, PressureUnit.Pascal), (PressureUnit.Gigapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e9d, PressureUnit.Pascal), + (PressureUnit.GigapascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e9d, PressureUnit.Pascal), (PressureUnit.Hectopascal, PressureUnit.Pascal) => new Pressure((_value) * 1e2d, PressureUnit.Pascal), + (PressureUnit.HectopascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e2d, PressureUnit.Pascal), (PressureUnit.InchOfMercury, PressureUnit.Pascal) => new Pressure(_value * 2.54e1 * 133.322387415, PressureUnit.Pascal), (PressureUnit.InchOfWaterColumn, PressureUnit.Pascal) => new Pressure(_value * 2.54e-2 * 9.80665e3, PressureUnit.Pascal), (PressureUnit.Kilobar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e3d, PressureUnit.Pascal), + (PressureUnit.KilobarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e3d, PressureUnit.Pascal), (PressureUnit.KilogramForcePerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e4, PressureUnit.Pascal), (PressureUnit.KilogramForcePerSquareMeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665, PressureUnit.Pascal), (PressureUnit.KilogramForcePerSquareMillimeter, PressureUnit.Pascal) => new Pressure(_value * 9.80665e6, PressureUnit.Pascal), @@ -1518,24 +1765,32 @@ private bool TryToUnit(PressureUnit unit, [NotNullWhen(true)] out Pressure? conv (PressureUnit.KilonewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure((_value) * 1e3d, PressureUnit.Pascal), (PressureUnit.KilonewtonPerSquareMillimeter, PressureUnit.Pascal) => new Pressure((_value * 1e6) * 1e3d, PressureUnit.Pascal), (PressureUnit.Kilopascal, PressureUnit.Pascal) => new Pressure((_value) * 1e3d, PressureUnit.Pascal), + (PressureUnit.KilopascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e3d, PressureUnit.Pascal), (PressureUnit.KilopoundForcePerSquareFoot, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / 9.290304e-2) * 1e3d, PressureUnit.Pascal), (PressureUnit.KilopoundForcePerSquareInch, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / 0.00064516) * 1e3d, PressureUnit.Pascal), (PressureUnit.KilopoundForcePerSquareMil, PressureUnit.Pascal) => new Pressure((_value * 4.4482216152605 / (2.54e-5 * 2.54e-5)) * 1e3d, PressureUnit.Pascal), (PressureUnit.Megabar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e6d, PressureUnit.Pascal), + (PressureUnit.MegabarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e6d, PressureUnit.Pascal), (PressureUnit.MeganewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure((_value) * 1e6d, PressureUnit.Pascal), (PressureUnit.Megapascal, PressureUnit.Pascal) => new Pressure((_value) * 1e6d, PressureUnit.Pascal), + (PressureUnit.MegapascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e6d, PressureUnit.Pascal), (PressureUnit.MeterOfHead, PressureUnit.Pascal) => new Pressure(_value * 9804.139432, PressureUnit.Pascal), (PressureUnit.MeterOfWaterColumn, PressureUnit.Pascal) => new Pressure(_value * 9.80665e3, PressureUnit.Pascal), (PressureUnit.Microbar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-6d, PressureUnit.Pascal), + (PressureUnit.MicrobarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e-6d, PressureUnit.Pascal), (PressureUnit.Micropascal, PressureUnit.Pascal) => new Pressure((_value) * 1e-6d, PressureUnit.Pascal), + (PressureUnit.MicropascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e-6d, PressureUnit.Pascal), (PressureUnit.Millibar, PressureUnit.Pascal) => new Pressure((_value * 1e5) * 1e-3d, PressureUnit.Pascal), + (PressureUnit.MillibarG, PressureUnit.Pascal) => new Pressure(((_value * 1e5) + 101325) * 1e-3d, PressureUnit.Pascal), (PressureUnit.MillimeterOfMercury, PressureUnit.Pascal) => new Pressure(_value * 133.322387415, PressureUnit.Pascal), (PressureUnit.MillimeterOfWaterColumn, PressureUnit.Pascal) => new Pressure((_value * 9.80665e3) * 1e-3d, PressureUnit.Pascal), (PressureUnit.Millipascal, PressureUnit.Pascal) => new Pressure((_value) * 1e-3d, PressureUnit.Pascal), + (PressureUnit.MillipascalG, PressureUnit.Pascal) => new Pressure((_value + 101325) * 1e-3d, PressureUnit.Pascal), (PressureUnit.Millitorr, PressureUnit.Pascal) => new Pressure((_value * 101325 / 760) * 1e-3d, PressureUnit.Pascal), (PressureUnit.NewtonPerSquareCentimeter, PressureUnit.Pascal) => new Pressure(_value * 1e4, PressureUnit.Pascal), (PressureUnit.NewtonPerSquareMeter, PressureUnit.Pascal) => new Pressure(_value, PressureUnit.Pascal), (PressureUnit.NewtonPerSquareMillimeter, PressureUnit.Pascal) => new Pressure(_value * 1e6, PressureUnit.Pascal), + (PressureUnit.PascalG, PressureUnit.Pascal) => new Pressure(_value + 101325, PressureUnit.Pascal), (PressureUnit.PoundForcePerSquareFoot, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / 9.290304e-2, PressureUnit.Pascal), (PressureUnit.PoundForcePerSquareInch, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / 0.00064516, PressureUnit.Pascal), (PressureUnit.PoundForcePerSquareMil, PressureUnit.Pascal) => new Pressure(_value * 4.4482216152605 / (2.54e-5 * 2.54e-5), PressureUnit.Pascal), @@ -1549,17 +1804,24 @@ private bool TryToUnit(PressureUnit unit, [NotNullWhen(true)] out Pressure? conv // BaseUnit -> PressureUnit (PressureUnit.Pascal, PressureUnit.Atmosphere) => new Pressure(_value / (1.01325 * 1e5), PressureUnit.Atmosphere), (PressureUnit.Pascal, PressureUnit.Bar) => new Pressure(_value / 1e5, PressureUnit.Bar), + (PressureUnit.Pascal, PressureUnit.BarG) => new Pressure((_value - 101325) / 1e5, PressureUnit.BarG), (PressureUnit.Pascal, PressureUnit.Centibar) => new Pressure((_value / 1e5) / 1e-2d, PressureUnit.Centibar), + (PressureUnit.Pascal, PressureUnit.CentibarG) => new Pressure(((_value - 101325) / 1e5) / 1e-2d, PressureUnit.CentibarG), (PressureUnit.Pascal, PressureUnit.CentimeterOfWaterColumn) => new Pressure((_value / 9.80665e3) / 1e-2d, PressureUnit.CentimeterOfWaterColumn), (PressureUnit.Pascal, PressureUnit.Decapascal) => new Pressure((_value) / 1e1d, PressureUnit.Decapascal), + (PressureUnit.Pascal, PressureUnit.DecapascalG) => new Pressure((_value - 101325) / 1e1d, PressureUnit.DecapascalG), (PressureUnit.Pascal, PressureUnit.Decibar) => new Pressure((_value / 1e5) / 1e-1d, PressureUnit.Decibar), + (PressureUnit.Pascal, PressureUnit.DecibarG) => new Pressure(((_value - 101325) / 1e5) / 1e-1d, PressureUnit.DecibarG), (PressureUnit.Pascal, PressureUnit.DynePerSquareCentimeter) => new Pressure(_value / 1.0e-1, PressureUnit.DynePerSquareCentimeter), (PressureUnit.Pascal, PressureUnit.FootOfHead) => new Pressure(_value / (9804.139432 * 0.3048), PressureUnit.FootOfHead), (PressureUnit.Pascal, PressureUnit.Gigapascal) => new Pressure((_value) / 1e9d, PressureUnit.Gigapascal), + (PressureUnit.Pascal, PressureUnit.GigapascalG) => new Pressure((_value - 101325) / 1e9d, PressureUnit.GigapascalG), (PressureUnit.Pascal, PressureUnit.Hectopascal) => new Pressure((_value) / 1e2d, PressureUnit.Hectopascal), + (PressureUnit.Pascal, PressureUnit.HectopascalG) => new Pressure((_value - 101325) / 1e2d, PressureUnit.HectopascalG), (PressureUnit.Pascal, PressureUnit.InchOfMercury) => new Pressure(_value / (2.54e1 * 133.322387415), PressureUnit.InchOfMercury), (PressureUnit.Pascal, PressureUnit.InchOfWaterColumn) => new Pressure(_value / (2.54e-2 * 9.80665e3), PressureUnit.InchOfWaterColumn), (PressureUnit.Pascal, PressureUnit.Kilobar) => new Pressure((_value / 1e5) / 1e3d, PressureUnit.Kilobar), + (PressureUnit.Pascal, PressureUnit.KilobarG) => new Pressure(((_value - 101325) / 1e5) / 1e3d, PressureUnit.KilobarG), (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareCentimeter) => new Pressure(_value / 9.80665e4, PressureUnit.KilogramForcePerSquareCentimeter), (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMeter) => new Pressure(_value / 9.80665, PressureUnit.KilogramForcePerSquareMeter), (PressureUnit.Pascal, PressureUnit.KilogramForcePerSquareMillimeter) => new Pressure(_value / 9.80665e6, PressureUnit.KilogramForcePerSquareMillimeter), @@ -1567,24 +1829,32 @@ private bool TryToUnit(PressureUnit unit, [NotNullWhen(true)] out Pressure? conv (PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMeter) => new Pressure((_value) / 1e3d, PressureUnit.KilonewtonPerSquareMeter), (PressureUnit.Pascal, PressureUnit.KilonewtonPerSquareMillimeter) => new Pressure((_value / 1e6) / 1e3d, PressureUnit.KilonewtonPerSquareMillimeter), (PressureUnit.Pascal, PressureUnit.Kilopascal) => new Pressure((_value) / 1e3d, PressureUnit.Kilopascal), + (PressureUnit.Pascal, PressureUnit.KilopascalG) => new Pressure((_value - 101325) / 1e3d, PressureUnit.KilopascalG), (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareFoot) => new Pressure((_value * 9.290304e-2 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareFoot), (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareInch) => new Pressure((_value * 0.00064516 / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareInch), (PressureUnit.Pascal, PressureUnit.KilopoundForcePerSquareMil) => new Pressure((_value * (2.54e-5 * 2.54e-5) / 4.4482216152605) / 1e3d, PressureUnit.KilopoundForcePerSquareMil), (PressureUnit.Pascal, PressureUnit.Megabar) => new Pressure((_value / 1e5) / 1e6d, PressureUnit.Megabar), + (PressureUnit.Pascal, PressureUnit.MegabarG) => new Pressure(((_value - 101325) / 1e5) / 1e6d, PressureUnit.MegabarG), (PressureUnit.Pascal, PressureUnit.MeganewtonPerSquareMeter) => new Pressure((_value) / 1e6d, PressureUnit.MeganewtonPerSquareMeter), (PressureUnit.Pascal, PressureUnit.Megapascal) => new Pressure((_value) / 1e6d, PressureUnit.Megapascal), + (PressureUnit.Pascal, PressureUnit.MegapascalG) => new Pressure((_value - 101325) / 1e6d, PressureUnit.MegapascalG), (PressureUnit.Pascal, PressureUnit.MeterOfHead) => new Pressure(_value / 9804.139432, PressureUnit.MeterOfHead), (PressureUnit.Pascal, PressureUnit.MeterOfWaterColumn) => new Pressure(_value / 9.80665e3, PressureUnit.MeterOfWaterColumn), (PressureUnit.Pascal, PressureUnit.Microbar) => new Pressure((_value / 1e5) / 1e-6d, PressureUnit.Microbar), + (PressureUnit.Pascal, PressureUnit.MicrobarG) => new Pressure(((_value - 101325) / 1e5) / 1e-6d, PressureUnit.MicrobarG), (PressureUnit.Pascal, PressureUnit.Micropascal) => new Pressure((_value) / 1e-6d, PressureUnit.Micropascal), + (PressureUnit.Pascal, PressureUnit.MicropascalG) => new Pressure((_value - 101325) / 1e-6d, PressureUnit.MicropascalG), (PressureUnit.Pascal, PressureUnit.Millibar) => new Pressure((_value / 1e5) / 1e-3d, PressureUnit.Millibar), + (PressureUnit.Pascal, PressureUnit.MillibarG) => new Pressure(((_value - 101325) / 1e5) / 1e-3d, PressureUnit.MillibarG), (PressureUnit.Pascal, PressureUnit.MillimeterOfMercury) => new Pressure(_value / 133.322387415, PressureUnit.MillimeterOfMercury), (PressureUnit.Pascal, PressureUnit.MillimeterOfWaterColumn) => new Pressure((_value / 9.80665e3) / 1e-3d, PressureUnit.MillimeterOfWaterColumn), (PressureUnit.Pascal, PressureUnit.Millipascal) => new Pressure((_value) / 1e-3d, PressureUnit.Millipascal), + (PressureUnit.Pascal, PressureUnit.MillipascalG) => new Pressure((_value - 101325) / 1e-3d, PressureUnit.MillipascalG), (PressureUnit.Pascal, PressureUnit.Millitorr) => new Pressure((_value * 760 / 101325) / 1e-3d, PressureUnit.Millitorr), (PressureUnit.Pascal, PressureUnit.NewtonPerSquareCentimeter) => new Pressure(_value / 1e4, PressureUnit.NewtonPerSquareCentimeter), (PressureUnit.Pascal, PressureUnit.NewtonPerSquareMeter) => new Pressure(_value, PressureUnit.NewtonPerSquareMeter), (PressureUnit.Pascal, PressureUnit.NewtonPerSquareMillimeter) => new Pressure(_value / 1e6, PressureUnit.NewtonPerSquareMillimeter), + (PressureUnit.Pascal, PressureUnit.PascalG) => new Pressure(_value - 101325, PressureUnit.PascalG), (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareFoot) => new Pressure(_value * 9.290304e-2 / 4.4482216152605, PressureUnit.PoundForcePerSquareFoot), (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareInch) => new Pressure(_value * 0.00064516 / 4.4482216152605, PressureUnit.PoundForcePerSquareInch), (PressureUnit.Pascal, PressureUnit.PoundForcePerSquareMil) => new Pressure(_value * (2.54e-5 * 2.54e-5) / 4.4482216152605, PressureUnit.PoundForcePerSquareMil), diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs index c7a7c3af9c..c40c0101e0 100644 --- a/UnitsNet/GeneratedCode/Quantity.g.cs +++ b/UnitsNet/GeneratedCode/Quantity.g.cs @@ -78,6 +78,7 @@ internal static class DefaultProvider Energy.Info, EnergyDensity.Info, Entropy.Info, + Fluence.Info, FluidResistance.Info, Force.Info, ForceChangeRate.Info, @@ -210,6 +211,7 @@ internal static void RegisterUnitConversions(UnitConverter unitConverter) Energy.RegisterDefaultConversions(unitConverter); EnergyDensity.RegisterDefaultConversions(unitConverter); Entropy.RegisterDefaultConversions(unitConverter); + Fluence.RegisterDefaultConversions(unitConverter); FluidResistance.RegisterDefaultConversions(unitConverter); Force.RegisterDefaultConversions(unitConverter); ForceChangeRate.RegisterDefaultConversions(unitConverter); diff --git a/UnitsNet/GeneratedCode/Resources/Fluence.restext b/UnitsNet/GeneratedCode/Resources/Fluence.restext new file mode 100644 index 0000000000..ef4af6eaab --- /dev/null +++ b/UnitsNet/GeneratedCode/Resources/Fluence.restext @@ -0,0 +1 @@ +NeutronsPerSquareCentimeter=n/cm²,n·cm⁻² diff --git a/UnitsNet/GeneratedCode/Resources/Power.restext b/UnitsNet/GeneratedCode/Resources/Power.restext index a9f68096c3..e7fdef85c4 100644 --- a/UnitsNet/GeneratedCode/Resources/Power.restext +++ b/UnitsNet/GeneratedCode/Resources/Power.restext @@ -1,27 +1,40 @@ BoilerHorsepower=hp(S) BritishThermalUnitsPerHour=Btu/h,Btu/hr +DecapascalCubicMeterPerSecond=daPa.m³/s Decawatts=daW +DecipascalCubicMeterPerSecond=dPa.m³/s Deciwatts=dW ElectricalHorsepower=hp(E) +FemtopascalCubicMeterPerSecond=fPa.m³/s Femtowatts=fW GigajoulesPerHour=GJ/h +GigapascalCubicMeterPerSecond=GPa.m³/s Gigawatts=GW HydraulicHorsepower=hp(H) JoulesPerHour=J/h KilobritishThermalUnitsPerHour=kBtu/h,kBtu/hr KilojoulesPerHour=kJ/h +KilopascalCubicMeterPerSecond=kPa.m³/s Kilowatts=kW MechanicalHorsepower=hp(I) MegabritishThermalUnitsPerHour=MBtu/h,MBtu/hr MegajoulesPerHour=MJ/h +MegapascalCubicMeterPerSecond=MPa.m³/s Megawatts=MW MetricHorsepower=hp(M) +MicropascalCubicMeterPerSecond=µPa.m³/s Microwatts=µW MillijoulesPerHour=mJ/h +MillipascalCubicMeterPerSecond=mPa.m³/s Milliwatts=mW +NanopascalCubicMeterPerSecond=nPa.m³/s Nanowatts=nW +PascalCubicMeterPerSecond=Pa.m³/s +PetapascalCubicMeterPerSecond=PPa.m³/s Petawatts=PW +PicopascalCubicMeterPerSecond=pPa.m³/s Picowatts=pW +TerapascalCubicMeterPerSecond=TPa.m³/s Terawatts=TW TonsOfRefrigeration=TR Watts=W diff --git a/UnitsNet/GeneratedCode/Resources/Pressure.restext b/UnitsNet/GeneratedCode/Resources/Pressure.restext index 133dbef717..7546252fd8 100644 --- a/UnitsNet/GeneratedCode/Resources/Pressure.restext +++ b/UnitsNet/GeneratedCode/Resources/Pressure.restext @@ -1,16 +1,23 @@ Atmospheres=atm Bars=bar +BarsG=bar(g) Centibars=cbar +CentibarsG=cbar(g) CentimetersOfWaterColumn=cmH₂O,cmH2O,cm wc,cm wg Decapascals=daPa +DecapascalsG=daPa(g) Decibars=dbar +DecibarsG=dbar(g) DynesPerSquareCentimeter=dyn/cm² FeetOfHead=ft of head Gigapascals=GPa +GigapascalsG=GPa(g) Hectopascals=hPa +HectopascalsG=hPa(g) InchesOfMercury=inHg InchesOfWaterColumn=inH2O,inch wc,wc Kilobars=kbar +KilobarsG=kbar(g) KilogramsForcePerSquareCentimeter=kgf/cm² KilogramsForcePerSquareMeter=kgf/m² KilogramsForcePerSquareMillimeter=kgf/mm² @@ -18,25 +25,33 @@ KilonewtonsPerSquareCentimeter=kN/cm² KilonewtonsPerSquareMeter=kN/m² KilonewtonsPerSquareMillimeter=kN/mm² Kilopascals=kPa +KilopascalsG=kPa(g) KilopoundsForcePerSquareFoot=kipf/ft² KilopoundsForcePerSquareInch=ksi,kipf/in² KilopoundsForcePerSquareMil=kipf/mil² Megabars=Mbar +MegabarsG=Mbar(g) MeganewtonsPerSquareMeter=MN/m² Megapascals=MPa +MegapascalsG=MPa(g) MetersOfHead=m of head MetersOfWaterColumn=mH₂O,mH2O,m wc,m wg Microbars=µbar +MicrobarsG=µbar(g) Micropascals=µPa +MicropascalsG=µPa(g) Millibars=mbar +MillibarsG=mbar(g) MillimetersOfMercury=mmHg MillimetersOfWaterColumn=mmH₂O,mmH2O,mm wc,mm wg Millipascals=mPa +MillipascalsG=mPa(g) Millitorrs=mtorr NewtonsPerSquareCentimeter=N/cm² NewtonsPerSquareMeter=N/m² NewtonsPerSquareMillimeter=N/mm² Pascals=Pa +PascalsG=Pa(g) PoundsForcePerSquareFoot=lb/ft² PoundsForcePerSquareInch=psi,lb/in² PoundsForcePerSquareMil=lb/mil²,lbs/mil² diff --git a/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext index 4a13b08a9e..e6dfb0a376 100644 --- a/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext +++ b/UnitsNet/GeneratedCode/Resources/Pressure.ru-RU.restext @@ -1,11 +1,18 @@ Atmospheres=атм Bars=бар +BarsG=бар(g) Centibars=сбар +CentibarsG=сбар(g) Decapascals=даПа +DecapascalsG=даПа(g) Decibars=дбар +DecibarsG=дбар(g) Gigapascals=ГПа +GigapascalsG=ГПа(g) Hectopascals=гПа +HectopascalsG=гПа(g) Kilobars=кбар +KilobarsG=кбар(g) KilogramsForcePerSquareCentimeter=кгс/см² KilogramsForcePerSquareMeter=кгс/м² KilogramsForcePerSquareMillimeter=кгс/мм² @@ -13,20 +20,28 @@ KilonewtonsPerSquareCentimeter=кН/см² KilonewtonsPerSquareMeter=кН/м² KilonewtonsPerSquareMillimeter=кН/мм² Kilopascals=кПа +KilopascalsG=кПа(g) KilopoundsForcePerSquareInch=ksi,kipf/in² Megabars=Мбар +MegabarsG=Мбар(g) MeganewtonsPerSquareMeter=МН/м² Megapascals=МПа +MegapascalsG=МПа(g) Microbars=мкбар +MicrobarsG=мкбар(g) Micropascals=мкПа +MicropascalsG=мкПа(g) Millibars=мбар +MillibarsG=мбар(g) MillimetersOfMercury=мм рт.ст. Millipascals=мПа +MillipascalsG=мПа(g) Millitorrs=мторр NewtonsPerSquareCentimeter=Н/см² NewtonsPerSquareMeter=Н/м² NewtonsPerSquareMillimeter=Н/мм² Pascals=Па +PascalsG=Па(g) PoundsForcePerSquareInch=psi,lb/in² TechnicalAtmospheres=ат Torrs=торр diff --git a/UnitsNet/GeneratedCode/Units/FluenceUnit.g.cs b/UnitsNet/GeneratedCode/Units/FluenceUnit.g.cs new file mode 100644 index 0000000000..a8b57011a2 --- /dev/null +++ b/UnitsNet/GeneratedCode/Units/FluenceUnit.g.cs @@ -0,0 +1,36 @@ +//------------------------------------------------------------------------------ +// +// 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 FluenceUnit + { + + /// + /// The fluence of neutrons measured per square centimeter (n/cm²). Example: A reactor vessel may receive 6×10¹⁹ n/cm² over its lifetime. + /// + NeutronPerSquareCentimeter = 4, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet/GeneratedCode/Units/PowerUnit.g.cs b/UnitsNet/GeneratedCode/Units/PowerUnit.g.cs index c0ddfe10ec..d973798ad1 100644 --- a/UnitsNet/GeneratedCode/Units/PowerUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PowerUnit.g.cs @@ -33,7 +33,9 @@ public enum PowerUnit BoilerHorsepower = 1, /// Based on the International Table (IT) definition of the British thermal unit (BTU), where 1 BTU is defined as exactly 1055.05585262 joules (≈1.05506 kJ). See https://en.wikipedia.org/wiki/British_thermal_unit for details. BritishThermalUnitPerHour = 2, + DecapascalCubicMeterPerSecond = 35, Decawatt = 3, + DecipascalCubicMeterPerSecond = 36, Deciwatt = 4, /// @@ -41,8 +43,10 @@ public enum PowerUnit /// /// https://en.wikipedia.org/wiki/Horsepower#Electrical_horsepower ElectricalHorsepower = 5, + FemtopascalCubicMeterPerSecond = 34, Femtowatt = 6, GigajoulePerHour = 7, + GigapascalCubicMeterPerSecond = 32, Gigawatt = 8, /// @@ -53,6 +57,7 @@ public enum PowerUnit JoulePerHour = 10, KilobritishThermalUnitPerHour = 11, KilojoulePerHour = 12, + KilopascalCubicMeterPerSecond = 28, Kilowatt = 13, /// @@ -62,6 +67,7 @@ public enum PowerUnit MechanicalHorsepower = 14, MegabritishThermalUnitPerHour = 15, MegajoulePerHour = 16, + MegapascalCubicMeterPerSecond = 27, Megawatt = 17, /// @@ -69,12 +75,19 @@ public enum PowerUnit /// /// https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower_(PS,_KM,_cv,_hk,_pk,_k,_ks,_ch) MetricHorsepower = 18, + MicropascalCubicMeterPerSecond = 37, Microwatt = 19, MillijoulePerHour = 20, + MillipascalCubicMeterPerSecond = 30, Milliwatt = 21, + NanopascalCubicMeterPerSecond = 31, Nanowatt = 22, + PascalCubicMeterPerSecond = 33, + PetapascalCubicMeterPerSecond = 45, Petawatt = 23, + PicopascalCubicMeterPerSecond = 47, Picowatt = 24, + TerapascalCubicMeterPerSecond = 42, Terawatt = 25, TonOfRefrigeration = 29, Watt = 26, diff --git a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs index dbcff54072..87ef37ec0d 100644 --- a/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PressureUnit.g.cs @@ -37,14 +37,25 @@ public enum PressureUnit /// /// https://en.wikipedia.org/wiki/Bar_(unit) Bar = 2, + + /// + /// The bar(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 1.01325 bar). + /// + /// https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure + BarG = 53, Centibar = 3, + CentibarG = 58, CentimeterOfWaterColumn = 48, Decapascal = 4, + DecapascalG = 50, Decibar = 5, + DecibarG = 55, DynePerSquareCentimeter = 6, FootOfHead = 8, Gigapascal = 9, + GigapascalG = 54, Hectopascal = 10, + HectopascalG = 59, /// /// Inch of mercury (inHg and ″Hg) is a non-SI unit of measurement for pressure. It is used for barometric pressure in weather reports, refrigeration and aviation in the United States. It is the pressure exerted by a column of mercury 1 inch (25.4 mm) in height at the standard acceleration of gravity. @@ -58,6 +69,7 @@ public enum PressureUnit /// https://en.wikipedia.org/wiki/Inch_of_water InchOfWaterColumn = 12, Kilobar = 13, + KilobarG = 51, /// /// A kilogram-force per centimetre square (kgf/cm2), often just kilogram per square centimetre (kg/cm2), or kilopond per centimetre square (kp/cm2) is a deprecated unit of pressure using metric units. It is not a part of the International System of Units (SI), the modern metric system. 1 kgf/cm2 equals 98.0665 kPa (kilopascals). It is also known as a technical atmosphere (symbol: at). @@ -70,12 +82,15 @@ public enum PressureUnit KilonewtonPerSquareMeter = 18, KilonewtonPerSquareMillimeter = 19, Kilopascal = 20, + KilopascalG = 49, KilopoundForcePerSquareFoot = 21, KilopoundForcePerSquareInch = 22, KilopoundForcePerSquareMil = 23, Megabar = 24, + MegabarG = 60, MeganewtonPerSquareMeter = 25, Megapascal = 26, + MegapascalG = 56, MeterOfHead = 28, /// @@ -84,8 +99,11 @@ public enum PressureUnit /// https://en.wikipedia.org/wiki/Centimetre_or_millimetre_of_water MeterOfWaterColumn = 57, Microbar = 29, + MicrobarG = 67, Micropascal = 30, + MicropascalG = 65, Millibar = 31, + MillibarG = 62, /// /// A millimetre of mercury is a manometric unit of pressure, formerly defined as the extra pressure generated by a column of mercury one millimetre high, and currently defined as exactly 133.322387415 pascals. @@ -94,11 +112,18 @@ public enum PressureUnit MillimeterOfMercury = 32, MillimeterOfWaterColumn = 33, Millipascal = 34, + MillipascalG = 68, Millitorr = 52, NewtonPerSquareCentimeter = 35, NewtonPerSquareMeter = 36, NewtonPerSquareMillimeter = 37, Pascal = 38, + + /// + /// The Pa(g) is a metric unit of gauge pressure, where the pressure is relative to atmospheric pressure (approximately 101325 Pa). + /// + /// https://en.wikipedia.org/wiki/Pressure_measurement#Gauge_pressure + PascalG = 69, PoundForcePerSquareFoot = 39, PoundForcePerSquareInch = 40, PoundForcePerSquareMil = 41,