diff --git a/Common/UnitDefinitions/Density.json b/Common/UnitDefinitions/Density.json index 29551305fb..c3c5a32983 100644 --- a/Common/UnitDefinitions/Density.json +++ b/Common/UnitDefinitions/Density.json @@ -178,7 +178,7 @@ }, { "SingularName": "GramPerDeciliter", - "PluralName": "GramsPerDeciLiter", + "PluralName": "GramsPerDeciliter", "FromUnitToBaseFunc": "{x} / 1e-1", "FromBaseToUnitFunc": "{x} * 1e-1", "Prefixes": [ "Pico", "Nano", "Micro", "Milli", "Centi", "Deci" ], diff --git a/Common/UnitDefinitions/ElectricPotentialChangeRate.json b/Common/UnitDefinitions/ElectricPotentialChangeRate.json index ed81c5aa1d..9e7a1916a8 100644 --- a/Common/UnitDefinitions/ElectricPotentialChangeRate.json +++ b/Common/UnitDefinitions/ElectricPotentialChangeRate.json @@ -11,7 +11,7 @@ "Units": [ { "SingularName": "VoltPerSecond", - "PluralName": "VoltsPerSeconds", + "PluralName": "VoltsPerSecond", "BaseUnits": { "L": "Meter", "M": "Kilogram", @@ -30,7 +30,7 @@ }, { "SingularName": "VoltPerMicrosecond", - "PluralName": "VoltsPerMicroseconds", + "PluralName": "VoltsPerMicrosecond", "BaseUnits": { "L": "Meter", "M": "Kilogram", @@ -49,7 +49,7 @@ }, { "SingularName": "VoltPerMinute", - "PluralName": "VoltsPerMinutes", + "PluralName": "VoltsPerMinute", "BaseUnits": { "L": "Meter", "M": "Kilogram", @@ -68,7 +68,7 @@ }, { "SingularName": "VoltPerHour", - "PluralName": "VoltsPerHours", + "PluralName": "VoltsPerHour", "BaseUnits": { "L": "Meter", "M": "Kilogram", diff --git a/Common/UnitDefinitions/FuelEfficiency.json b/Common/UnitDefinitions/FuelEfficiency.json index d0a27ce366..a32e9cd959 100644 --- a/Common/UnitDefinitions/FuelEfficiency.json +++ b/Common/UnitDefinitions/FuelEfficiency.json @@ -41,7 +41,7 @@ }, { "SingularName": "KilometerPerLiter", - "PluralName": "KilometersPerLiters", + "PluralName": "KilometersPerLiter", "FromUnitToBaseFunc": "100 / {x}", "FromBaseToUnitFunc": "100 / {x}", "Localization": [{ diff --git a/Common/UnitDefinitions/Speed.json b/Common/UnitDefinitions/Speed.json index f17f8a321c..6a127121e5 100644 --- a/Common/UnitDefinitions/Speed.json +++ b/Common/UnitDefinitions/Speed.json @@ -30,7 +30,7 @@ }, { "SingularName": "MeterPerMinute", - "PluralName": "MetersPerMinutes", + "PluralName": "MetersPerMinute", "BaseUnits": { "L": "Meter", "T": "Minute" diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs index 552c710f9c..a8ad5f5576 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Density.g.cs @@ -85,7 +85,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double CentigramsPerDeciLiter => As(DensityUnit.CentigramPerDeciliter); + public double CentigramsPerDeciliter => As(DensityUnit.CentigramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -100,7 +100,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double DecigramsPerDeciLiter => As(DensityUnit.DecigramPerDeciliter); + public double DecigramsPerDeciliter => As(DensityUnit.DecigramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -140,7 +140,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double GramsPerDeciLiter => As(DensityUnit.GramPerDeciliter); + public double GramsPerDeciliter => As(DensityUnit.GramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -190,7 +190,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double MicrogramsPerDeciLiter => As(DensityUnit.MicrogramPerDeciliter); + public double MicrogramsPerDeciliter => As(DensityUnit.MicrogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -210,7 +210,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double MilligramsPerDeciLiter => As(DensityUnit.MilligramPerDeciliter); + public double MilligramsPerDeciliter => As(DensityUnit.MilligramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -225,7 +225,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double NanogramsPerDeciLiter => As(DensityUnit.NanogramPerDeciliter); + public double NanogramsPerDeciliter => As(DensityUnit.NanogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -240,7 +240,7 @@ public Density(double value, DensityUnit unit) /// /// Gets a value of this quantity converted into /// - public double PicogramsPerDeciLiter => As(DensityUnit.PicogramPerDeciliter); + public double PicogramsPerDeciliter => As(DensityUnit.PicogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -345,7 +345,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromCentigramsPerDeciLiter(double centigramsperdeciliter) => new Density(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter); + public static Density FromCentigramsPerDeciliter(double centigramsperdeciliter) => new Density(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter); /// /// Creates a from . @@ -363,7 +363,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromDecigramsPerDeciLiter(double decigramsperdeciliter) => new Density(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter); + public static Density FromDecigramsPerDeciliter(double decigramsperdeciliter) => new Density(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter); /// /// Creates a from . @@ -411,7 +411,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromGramsPerDeciLiter(double gramsperdeciliter) => new Density(gramsperdeciliter, DensityUnit.GramPerDeciliter); + public static Density FromGramsPerDeciliter(double gramsperdeciliter) => new Density(gramsperdeciliter, DensityUnit.GramPerDeciliter); /// /// Creates a from . @@ -471,7 +471,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromMicrogramsPerDeciLiter(double microgramsperdeciliter) => new Density(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter); + public static Density FromMicrogramsPerDeciliter(double microgramsperdeciliter) => new Density(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter); /// /// Creates a from . @@ -495,7 +495,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromMilligramsPerDeciLiter(double milligramsperdeciliter) => new Density(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter); + public static Density FromMilligramsPerDeciliter(double milligramsperdeciliter) => new Density(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter); /// /// Creates a from . @@ -513,7 +513,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromNanogramsPerDeciLiter(double nanogramsperdeciliter) => new Density(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter); + public static Density FromNanogramsPerDeciliter(double nanogramsperdeciliter) => new Density(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter); /// /// Creates a from . @@ -531,7 +531,7 @@ public Density(double value, DensityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromPicogramsPerDeciLiter(double picogramsperdeciliter) => new Density(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter); + public static Density FromPicogramsPerDeciliter(double picogramsperdeciliter) => new Density(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter); /// /// Creates a from . diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index 1ce4ce0ecc..75d8f1efe5 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -82,102 +82,102 @@ public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerHours => As(ElectricPotentialChangeRateUnit.KilovoltPerHour); + public double KilovoltsPerHour => As(ElectricPotentialChangeRateUnit.KilovoltPerHour); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); + public double KilovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute); + public double KilovoltsPerMinute => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond); + public double KilovoltsPerSecond => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerHours => As(ElectricPotentialChangeRateUnit.MegavoltPerHour); + public double MegavoltsPerHour => As(ElectricPotentialChangeRateUnit.MegavoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); + public double MegavoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute); + public double MegavoltsPerMinute => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond); + public double MegavoltsPerSecond => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerHours => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour); + public double MicrovoltsPerHour => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); + public double MicrovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute); + public double MicrovoltsPerMinute => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond); + public double MicrovoltsPerSecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerHours => As(ElectricPotentialChangeRateUnit.MillivoltPerHour); + public double MillivoltsPerHour => As(ElectricPotentialChangeRateUnit.MillivoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); + public double MillivoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute); + public double MillivoltsPerMinute => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond); + public double MillivoltsPerSecond => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double VoltsPerHours => As(ElectricPotentialChangeRateUnit.VoltPerHour); + public double VoltsPerHour => As(ElectricPotentialChangeRateUnit.VoltPerHour); /// /// Gets a value of this quantity converted into /// - public double VoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond); + public double VoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double VoltsPerMinutes => As(ElectricPotentialChangeRateUnit.VoltPerMinute); + public double VoltsPerMinute => As(ElectricPotentialChangeRateUnit.VoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double VoltsPerSeconds => As(ElectricPotentialChangeRateUnit.VoltPerSecond); + public double VoltsPerSecond => As(ElectricPotentialChangeRateUnit.VoltPerSecond); #endregion @@ -187,121 +187,121 @@ public ElectricPotentialChangeRate(double value, ElectricPotentialChangeRateUnit /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerHours(double kilovoltsperhours) => new ElectricPotentialChangeRate(kilovoltsperhours, ElectricPotentialChangeRateUnit.KilovoltPerHour); + public static ElectricPotentialChangeRate FromKilovoltsPerHour(double kilovoltsperhour) => new ElectricPotentialChangeRate(kilovoltsperhour, ElectricPotentialChangeRateUnit.KilovoltPerHour); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(double kilovoltspermicroseconds) => new ElectricPotentialChangeRate(kilovoltspermicroseconds, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); + public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double kilovoltspermicrosecond) => new ElectricPotentialChangeRate(kilovoltspermicrosecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(double kilovoltsperminutes) => new ElectricPotentialChangeRate(kilovoltsperminutes, ElectricPotentialChangeRateUnit.KilovoltPerMinute); + public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double kilovoltsperminute) => new ElectricPotentialChangeRate(kilovoltsperminute, ElectricPotentialChangeRateUnit.KilovoltPerMinute); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(double kilovoltsperseconds) => new ElectricPotentialChangeRate(kilovoltsperseconds, ElectricPotentialChangeRateUnit.KilovoltPerSecond); + public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double kilovoltspersecond) => new ElectricPotentialChangeRate(kilovoltspersecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerHours(double megavoltsperhours) => new ElectricPotentialChangeRate(megavoltsperhours, ElectricPotentialChangeRateUnit.MegavoltPerHour); + public static ElectricPotentialChangeRate FromMegavoltsPerHour(double megavoltsperhour) => new ElectricPotentialChangeRate(megavoltsperhour, ElectricPotentialChangeRateUnit.MegavoltPerHour); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(double megavoltspermicroseconds) => new ElectricPotentialChangeRate(megavoltspermicroseconds, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); + public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double megavoltspermicrosecond) => new ElectricPotentialChangeRate(megavoltspermicrosecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(double megavoltsperminutes) => new ElectricPotentialChangeRate(megavoltsperminutes, ElectricPotentialChangeRateUnit.MegavoltPerMinute); + public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double megavoltsperminute) => new ElectricPotentialChangeRate(megavoltsperminute, ElectricPotentialChangeRateUnit.MegavoltPerMinute); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(double megavoltsperseconds) => new ElectricPotentialChangeRate(megavoltsperseconds, ElectricPotentialChangeRateUnit.MegavoltPerSecond); + public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double megavoltspersecond) => new ElectricPotentialChangeRate(megavoltspersecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerHours(double microvoltsperhours) => new ElectricPotentialChangeRate(microvoltsperhours, ElectricPotentialChangeRateUnit.MicrovoltPerHour); + public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double microvoltsperhour) => new ElectricPotentialChangeRate(microvoltsperhour, ElectricPotentialChangeRateUnit.MicrovoltPerHour); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(double microvoltspermicroseconds) => new ElectricPotentialChangeRate(microvoltspermicroseconds, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); + public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double microvoltspermicrosecond) => new ElectricPotentialChangeRate(microvoltspermicrosecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(double microvoltsperminutes) => new ElectricPotentialChangeRate(microvoltsperminutes, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); + public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double microvoltsperminute) => new ElectricPotentialChangeRate(microvoltsperminute, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(double microvoltsperseconds) => new ElectricPotentialChangeRate(microvoltsperseconds, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); + public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double microvoltspersecond) => new ElectricPotentialChangeRate(microvoltspersecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerHours(double millivoltsperhours) => new ElectricPotentialChangeRate(millivoltsperhours, ElectricPotentialChangeRateUnit.MillivoltPerHour); + public static ElectricPotentialChangeRate FromMillivoltsPerHour(double millivoltsperhour) => new ElectricPotentialChangeRate(millivoltsperhour, ElectricPotentialChangeRateUnit.MillivoltPerHour); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(double millivoltspermicroseconds) => new ElectricPotentialChangeRate(millivoltspermicroseconds, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); + public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double millivoltspermicrosecond) => new ElectricPotentialChangeRate(millivoltspermicrosecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(double millivoltsperminutes) => new ElectricPotentialChangeRate(millivoltsperminutes, ElectricPotentialChangeRateUnit.MillivoltPerMinute); + public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double millivoltsperminute) => new ElectricPotentialChangeRate(millivoltsperminute, ElectricPotentialChangeRateUnit.MillivoltPerMinute); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(double millivoltsperseconds) => new ElectricPotentialChangeRate(millivoltsperseconds, ElectricPotentialChangeRateUnit.MillivoltPerSecond); + public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double millivoltspersecond) => new ElectricPotentialChangeRate(millivoltspersecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerHours(double voltsperhours) => new ElectricPotentialChangeRate(voltsperhours, ElectricPotentialChangeRateUnit.VoltPerHour); + public static ElectricPotentialChangeRate FromVoltsPerHour(double voltsperhour) => new ElectricPotentialChangeRate(voltsperhour, ElectricPotentialChangeRateUnit.VoltPerHour); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(double voltspermicroseconds) => new ElectricPotentialChangeRate(voltspermicroseconds, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); + public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double voltspermicrosecond) => new ElectricPotentialChangeRate(voltspermicrosecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerMinutes(double voltsperminutes) => new ElectricPotentialChangeRate(voltsperminutes, ElectricPotentialChangeRateUnit.VoltPerMinute); + public static ElectricPotentialChangeRate FromVoltsPerMinute(double voltsperminute) => new ElectricPotentialChangeRate(voltsperminute, ElectricPotentialChangeRateUnit.VoltPerMinute); /// /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerSeconds(double voltsperseconds) => new ElectricPotentialChangeRate(voltsperseconds, ElectricPotentialChangeRateUnit.VoltPerSecond); + public static ElectricPotentialChangeRate FromVoltsPerSecond(double voltspersecond) => new ElectricPotentialChangeRate(voltspersecond, ElectricPotentialChangeRateUnit.VoltPerSecond); /// /// Dynamically convert from value and unit enum to . diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs index e1ff33660e..381e3e29c1 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -85,7 +85,7 @@ public FuelEfficiency(double value, FuelEfficiencyUnit unit) /// /// Gets a value of this quantity converted into /// - public double KilometersPerLiters => As(FuelEfficiencyUnit.KilometerPerLiter); + public double KilometersPerLiter => As(FuelEfficiencyUnit.KilometerPerLiter); /// /// Gets a value of this quantity converted into @@ -110,7 +110,7 @@ public FuelEfficiency(double value, FuelEfficiencyUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static FuelEfficiency FromKilometersPerLiters(double kilometersperliters) => new FuelEfficiency(kilometersperliters, FuelEfficiencyUnit.KilometerPerLiter); + public static FuelEfficiency FromKilometersPerLiter(double kilometersperliter) => new FuelEfficiency(kilometersperliter, FuelEfficiencyUnit.KilometerPerLiter); /// /// Creates a from . diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs index 6dc39a4e37..b8ebe48855 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Speed.g.cs @@ -87,7 +87,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double CentimetersPerMinutes => As(SpeedUnit.CentimeterPerMinute); + public double CentimetersPerMinute => As(SpeedUnit.CentimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -97,7 +97,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double DecimetersPerMinutes => As(SpeedUnit.DecimeterPerMinute); + public double DecimetersPerMinute => As(SpeedUnit.DecimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -142,7 +142,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double KilometersPerMinutes => As(SpeedUnit.KilometerPerMinute); + public double KilometersPerMinute => As(SpeedUnit.KilometerPerMinute); /// /// Gets a value of this quantity converted into @@ -167,7 +167,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double MetersPerMinutes => As(SpeedUnit.MeterPerMinute); + public double MetersPerMinute => As(SpeedUnit.MeterPerMinute); /// /// Gets a value of this quantity converted into @@ -177,7 +177,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double MicrometersPerMinutes => As(SpeedUnit.MicrometerPerMinute); + public double MicrometersPerMinute => As(SpeedUnit.MicrometerPerMinute); /// /// Gets a value of this quantity converted into @@ -197,7 +197,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double MillimetersPerMinutes => As(SpeedUnit.MillimeterPerMinute); + public double MillimetersPerMinute => As(SpeedUnit.MillimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -207,7 +207,7 @@ public Speed(double value, SpeedUnit unit) /// /// Gets a value of this quantity converted into /// - public double NanometersPerMinutes => As(SpeedUnit.NanometerPerMinute); + public double NanometersPerMinute => As(SpeedUnit.NanometerPerMinute); /// /// Gets a value of this quantity converted into @@ -258,7 +258,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromCentimetersPerMinutes(double centimetersperminutes) => new Speed(centimetersperminutes, SpeedUnit.CentimeterPerMinute); + public static Speed FromCentimetersPerMinute(double centimetersperminute) => new Speed(centimetersperminute, SpeedUnit.CentimeterPerMinute); /// /// Creates a from . @@ -270,7 +270,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromDecimetersPerMinutes(double decimetersperminutes) => new Speed(decimetersperminutes, SpeedUnit.DecimeterPerMinute); + public static Speed FromDecimetersPerMinute(double decimetersperminute) => new Speed(decimetersperminute, SpeedUnit.DecimeterPerMinute); /// /// Creates a from . @@ -324,7 +324,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromKilometersPerMinutes(double kilometersperminutes) => new Speed(kilometersperminutes, SpeedUnit.KilometerPerMinute); + public static Speed FromKilometersPerMinute(double kilometersperminute) => new Speed(kilometersperminute, SpeedUnit.KilometerPerMinute); /// /// Creates a from . @@ -354,7 +354,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMetersPerMinutes(double metersperminutes) => new Speed(metersperminutes, SpeedUnit.MeterPerMinute); + public static Speed FromMetersPerMinute(double metersperminute) => new Speed(metersperminute, SpeedUnit.MeterPerMinute); /// /// Creates a from . @@ -366,7 +366,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMicrometersPerMinutes(double micrometersperminutes) => new Speed(micrometersperminutes, SpeedUnit.MicrometerPerMinute); + public static Speed FromMicrometersPerMinute(double micrometersperminute) => new Speed(micrometersperminute, SpeedUnit.MicrometerPerMinute); /// /// Creates a from . @@ -390,7 +390,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMillimetersPerMinutes(double millimetersperminutes) => new Speed(millimetersperminutes, SpeedUnit.MillimeterPerMinute); + public static Speed FromMillimetersPerMinute(double millimetersperminute) => new Speed(millimetersperminute, SpeedUnit.MillimeterPerMinute); /// /// Creates a from . @@ -402,7 +402,7 @@ public Speed(double value, SpeedUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromNanometersPerMinutes(double nanometersperminutes) => new Speed(nanometersperminutes, SpeedUnit.NanometerPerMinute); + public static Speed FromNanometersPerMinute(double nanometersperminute) => new Speed(nanometersperminute, SpeedUnit.NanometerPerMinute); /// /// Creates a from . diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs index 8857f33283..8999da8ad6 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs @@ -25,8 +25,8 @@ namespace UnitsNet.Tests public class NumberToDensityExtensionsTests { [Fact] - public void NumberToCentigramsPerDeciLiterTest() => - Assert.Equal(Density.FromCentigramsPerDeciLiter(2), 2.CentigramsPerDeciLiter()); + public void NumberToCentigramsPerDeciliterTest() => + Assert.Equal(Density.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter()); [Fact] public void NumberToCentigramsPerLiterTest() => @@ -37,8 +37,8 @@ public void NumberToCentigramsPerMilliliterTest() => Assert.Equal(Density.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter()); [Fact] - public void NumberToDecigramsPerDeciLiterTest() => - Assert.Equal(Density.FromDecigramsPerDeciLiter(2), 2.DecigramsPerDeciLiter()); + public void NumberToDecigramsPerDeciliterTest() => + Assert.Equal(Density.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter()); [Fact] public void NumberToDecigramsPerLiterTest() => @@ -69,8 +69,8 @@ public void NumberToGramsPerCubicMillimeterTest() => Assert.Equal(Density.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter()); [Fact] - public void NumberToGramsPerDeciLiterTest() => - Assert.Equal(Density.FromGramsPerDeciLiter(2), 2.GramsPerDeciLiter()); + public void NumberToGramsPerDeciliterTest() => + Assert.Equal(Density.FromGramsPerDeciliter(2), 2.GramsPerDeciliter()); [Fact] public void NumberToGramsPerLiterTest() => @@ -109,8 +109,8 @@ public void NumberToMicrogramsPerCubicMeterTest() => Assert.Equal(Density.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter()); [Fact] - public void NumberToMicrogramsPerDeciLiterTest() => - Assert.Equal(Density.FromMicrogramsPerDeciLiter(2), 2.MicrogramsPerDeciLiter()); + public void NumberToMicrogramsPerDeciliterTest() => + Assert.Equal(Density.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter()); [Fact] public void NumberToMicrogramsPerLiterTest() => @@ -125,8 +125,8 @@ public void NumberToMilligramsPerCubicMeterTest() => Assert.Equal(Density.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter()); [Fact] - public void NumberToMilligramsPerDeciLiterTest() => - Assert.Equal(Density.FromMilligramsPerDeciLiter(2), 2.MilligramsPerDeciLiter()); + public void NumberToMilligramsPerDeciliterTest() => + Assert.Equal(Density.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter()); [Fact] public void NumberToMilligramsPerLiterTest() => @@ -137,8 +137,8 @@ public void NumberToMilligramsPerMilliliterTest() => Assert.Equal(Density.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter()); [Fact] - public void NumberToNanogramsPerDeciLiterTest() => - Assert.Equal(Density.FromNanogramsPerDeciLiter(2), 2.NanogramsPerDeciLiter()); + public void NumberToNanogramsPerDeciliterTest() => + Assert.Equal(Density.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter()); [Fact] public void NumberToNanogramsPerLiterTest() => @@ -149,8 +149,8 @@ public void NumberToNanogramsPerMilliliterTest() => Assert.Equal(Density.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter()); [Fact] - public void NumberToPicogramsPerDeciLiterTest() => - Assert.Equal(Density.FromPicogramsPerDeciLiter(2), 2.PicogramsPerDeciLiter()); + public void NumberToPicogramsPerDeciliterTest() => + Assert.Equal(Density.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter()); [Fact] public void NumberToPicogramsPerLiterTest() => diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs index da8acffcc6..dda5ae8b63 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs @@ -25,84 +25,84 @@ namespace UnitsNet.Tests public class NumberToElectricPotentialChangeRateExtensionsTests { [Fact] - public void NumberToKilovoltsPerHoursTest() => - Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerHours(2), 2.KilovoltsPerHours()); + public void NumberToKilovoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerHour(2), 2.KilovoltsPerHour()); [Fact] - public void NumberToKilovoltsPerMicrosecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(2), 2.KilovoltsPerMicroseconds()); + public void NumberToKilovoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(2), 2.KilovoltsPerMicrosecond()); [Fact] - public void NumberToKilovoltsPerMinutesTest() => - Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMinutes(2), 2.KilovoltsPerMinutes()); + public void NumberToKilovoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMinute(2), 2.KilovoltsPerMinute()); [Fact] - public void NumberToKilovoltsPerSecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerSeconds(2), 2.KilovoltsPerSeconds()); + public void NumberToKilovoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerSecond(2), 2.KilovoltsPerSecond()); [Fact] - public void NumberToMegavoltsPerHoursTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerHours(2), 2.MegavoltsPerHours()); + public void NumberToMegavoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerHour(2), 2.MegavoltsPerHour()); [Fact] - public void NumberToMegavoltsPerMicrosecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(2), 2.MegavoltsPerMicroseconds()); + public void NumberToMegavoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(2), 2.MegavoltsPerMicrosecond()); [Fact] - public void NumberToMegavoltsPerMinutesTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMinutes(2), 2.MegavoltsPerMinutes()); + public void NumberToMegavoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMinute(2), 2.MegavoltsPerMinute()); [Fact] - public void NumberToMegavoltsPerSecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerSeconds(2), 2.MegavoltsPerSeconds()); + public void NumberToMegavoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerSecond(2), 2.MegavoltsPerSecond()); [Fact] - public void NumberToMicrovoltsPerHoursTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerHours(2), 2.MicrovoltsPerHours()); + public void NumberToMicrovoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerHour(2), 2.MicrovoltsPerHour()); [Fact] - public void NumberToMicrovoltsPerMicrosecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(2), 2.MicrovoltsPerMicroseconds()); + public void NumberToMicrovoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(2), 2.MicrovoltsPerMicrosecond()); [Fact] - public void NumberToMicrovoltsPerMinutesTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(2), 2.MicrovoltsPerMinutes()); + public void NumberToMicrovoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMinute(2), 2.MicrovoltsPerMinute()); [Fact] - public void NumberToMicrovoltsPerSecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(2), 2.MicrovoltsPerSeconds()); + public void NumberToMicrovoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerSecond(2), 2.MicrovoltsPerSecond()); [Fact] - public void NumberToMillivoltsPerHoursTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerHours(2), 2.MillivoltsPerHours()); + public void NumberToMillivoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerHour(2), 2.MillivoltsPerHour()); [Fact] - public void NumberToMillivoltsPerMicrosecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(2), 2.MillivoltsPerMicroseconds()); + public void NumberToMillivoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(2), 2.MillivoltsPerMicrosecond()); [Fact] - public void NumberToMillivoltsPerMinutesTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMinutes(2), 2.MillivoltsPerMinutes()); + public void NumberToMillivoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMinute(2), 2.MillivoltsPerMinute()); [Fact] - public void NumberToMillivoltsPerSecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerSeconds(2), 2.MillivoltsPerSeconds()); + public void NumberToMillivoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerSecond(2), 2.MillivoltsPerSecond()); [Fact] - public void NumberToVoltsPerHoursTest() => - Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerHours(2), 2.VoltsPerHours()); + public void NumberToVoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerHour(2), 2.VoltsPerHour()); [Fact] - public void NumberToVoltsPerMicrosecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMicroseconds(2), 2.VoltsPerMicroseconds()); + public void NumberToVoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMicrosecond(2), 2.VoltsPerMicrosecond()); [Fact] - public void NumberToVoltsPerMinutesTest() => - Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMinutes(2), 2.VoltsPerMinutes()); + public void NumberToVoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMinute(2), 2.VoltsPerMinute()); [Fact] - public void NumberToVoltsPerSecondsTest() => - Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSeconds(2), 2.VoltsPerSeconds()); + public void NumberToVoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSecond(2), 2.VoltsPerSecond()); } } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs index 1a82f80799..c721dbcb09 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs @@ -25,8 +25,8 @@ namespace UnitsNet.Tests public class NumberToFuelEfficiencyExtensionsTests { [Fact] - public void NumberToKilometersPerLitersTest() => - Assert.Equal(FuelEfficiency.FromKilometersPerLiters(2), 2.KilometersPerLiters()); + public void NumberToKilometersPerLiterTest() => + Assert.Equal(FuelEfficiency.FromKilometersPerLiter(2), 2.KilometersPerLiter()); [Fact] public void NumberToLitersPer100KilometersTest() => diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs index 7ce9151a80..770b924b14 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs @@ -29,16 +29,16 @@ public void NumberToCentimetersPerHourTest() => Assert.Equal(Speed.FromCentimetersPerHour(2), 2.CentimetersPerHour()); [Fact] - public void NumberToCentimetersPerMinutesTest() => - Assert.Equal(Speed.FromCentimetersPerMinutes(2), 2.CentimetersPerMinutes()); + public void NumberToCentimetersPerMinuteTest() => + Assert.Equal(Speed.FromCentimetersPerMinute(2), 2.CentimetersPerMinute()); [Fact] public void NumberToCentimetersPerSecondTest() => Assert.Equal(Speed.FromCentimetersPerSecond(2), 2.CentimetersPerSecond()); [Fact] - public void NumberToDecimetersPerMinutesTest() => - Assert.Equal(Speed.FromDecimetersPerMinutes(2), 2.DecimetersPerMinutes()); + public void NumberToDecimetersPerMinuteTest() => + Assert.Equal(Speed.FromDecimetersPerMinute(2), 2.DecimetersPerMinute()); [Fact] public void NumberToDecimetersPerSecondTest() => @@ -73,8 +73,8 @@ public void NumberToKilometersPerHourTest() => Assert.Equal(Speed.FromKilometersPerHour(2), 2.KilometersPerHour()); [Fact] - public void NumberToKilometersPerMinutesTest() => - Assert.Equal(Speed.FromKilometersPerMinutes(2), 2.KilometersPerMinutes()); + public void NumberToKilometersPerMinuteTest() => + Assert.Equal(Speed.FromKilometersPerMinute(2), 2.KilometersPerMinute()); [Fact] public void NumberToKilometersPerSecondTest() => @@ -93,16 +93,16 @@ public void NumberToMetersPerHourTest() => Assert.Equal(Speed.FromMetersPerHour(2), 2.MetersPerHour()); [Fact] - public void NumberToMetersPerMinutesTest() => - Assert.Equal(Speed.FromMetersPerMinutes(2), 2.MetersPerMinutes()); + public void NumberToMetersPerMinuteTest() => + Assert.Equal(Speed.FromMetersPerMinute(2), 2.MetersPerMinute()); [Fact] public void NumberToMetersPerSecondTest() => Assert.Equal(Speed.FromMetersPerSecond(2), 2.MetersPerSecond()); [Fact] - public void NumberToMicrometersPerMinutesTest() => - Assert.Equal(Speed.FromMicrometersPerMinutes(2), 2.MicrometersPerMinutes()); + public void NumberToMicrometersPerMinuteTest() => + Assert.Equal(Speed.FromMicrometersPerMinute(2), 2.MicrometersPerMinute()); [Fact] public void NumberToMicrometersPerSecondTest() => @@ -117,16 +117,16 @@ public void NumberToMillimetersPerHourTest() => Assert.Equal(Speed.FromMillimetersPerHour(2), 2.MillimetersPerHour()); [Fact] - public void NumberToMillimetersPerMinutesTest() => - Assert.Equal(Speed.FromMillimetersPerMinutes(2), 2.MillimetersPerMinutes()); + public void NumberToMillimetersPerMinuteTest() => + Assert.Equal(Speed.FromMillimetersPerMinute(2), 2.MillimetersPerMinute()); [Fact] public void NumberToMillimetersPerSecondTest() => Assert.Equal(Speed.FromMillimetersPerSecond(2), 2.MillimetersPerSecond()); [Fact] - public void NumberToNanometersPerMinutesTest() => - Assert.Equal(Speed.FromNanometersPerMinutes(2), 2.NanometersPerMinutes()); + public void NumberToNanometersPerMinuteTest() => + Assert.Equal(Speed.FromNanometersPerMinute(2), 2.NanometersPerMinute()); [Fact] public void NumberToNanometersPerSecondTest() => diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs index 31bbc65296..73c3acb3ce 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs @@ -32,13 +32,13 @@ namespace UnitsNet.NumberExtensions.NumberToDensity /// public static class NumberToDensityExtensions { - /// - public static Density CentigramsPerDeciLiter(this T value) + /// + public static Density CentigramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromCentigramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromCentigramsPerDeciliter(Convert.ToDouble(value)); /// public static Density CentigramsPerLiter(this T value) @@ -56,13 +56,13 @@ public static Density CentigramsPerMilliliter(this T value) #endif => Density.FromCentigramsPerMilliliter(Convert.ToDouble(value)); - /// - public static Density DecigramsPerDeciLiter(this T value) + /// + public static Density DecigramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromDecigramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromDecigramsPerDeciliter(Convert.ToDouble(value)); /// public static Density DecigramsPerLiter(this T value) @@ -120,13 +120,13 @@ public static Density GramsPerCubicMillimeter(this T value) #endif => Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value)); - /// - public static Density GramsPerDeciLiter(this T value) + /// + public static Density GramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromGramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromGramsPerDeciliter(Convert.ToDouble(value)); /// public static Density GramsPerLiter(this T value) @@ -200,13 +200,13 @@ public static Density MicrogramsPerCubicMeter(this T value) #endif => Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value)); - /// - public static Density MicrogramsPerDeciLiter(this T value) + /// + public static Density MicrogramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromMicrogramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromMicrogramsPerDeciliter(Convert.ToDouble(value)); /// public static Density MicrogramsPerLiter(this T value) @@ -232,13 +232,13 @@ public static Density MilligramsPerCubicMeter(this T value) #endif => Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value)); - /// - public static Density MilligramsPerDeciLiter(this T value) + /// + public static Density MilligramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromMilligramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromMilligramsPerDeciliter(Convert.ToDouble(value)); /// public static Density MilligramsPerLiter(this T value) @@ -256,13 +256,13 @@ public static Density MilligramsPerMilliliter(this T value) #endif => Density.FromMilligramsPerMilliliter(Convert.ToDouble(value)); - /// - public static Density NanogramsPerDeciLiter(this T value) + /// + public static Density NanogramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromNanogramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromNanogramsPerDeciliter(Convert.ToDouble(value)); /// public static Density NanogramsPerLiter(this T value) @@ -280,13 +280,13 @@ public static Density NanogramsPerMilliliter(this T value) #endif => Density.FromNanogramsPerMilliliter(Convert.ToDouble(value)); - /// - public static Density PicogramsPerDeciLiter(this T value) + /// + public static Density PicogramsPerDeciliter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Density.FromPicogramsPerDeciLiter(Convert.ToDouble(value)); + => Density.FromPicogramsPerDeciliter(Convert.ToDouble(value)); /// public static Density PicogramsPerLiter(this T value) diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs index c277d4ab40..c41cfd13ba 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs @@ -32,165 +32,165 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialChangeRate /// public static class NumberToElectricPotentialChangeRateExtensions { - /// - public static ElectricPotentialChangeRate KilovoltsPerHours(this T value) + /// + public static ElectricPotentialChangeRate KilovoltsPerHour(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromKilovoltsPerHours(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromKilovoltsPerHour(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate KilovoltsPerMicroseconds(this T value) + /// + public static ElectricPotentialChangeRate KilovoltsPerMicrosecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate KilovoltsPerMinutes(this T value) + /// + public static ElectricPotentialChangeRate KilovoltsPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromKilovoltsPerMinutes(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromKilovoltsPerMinute(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate KilovoltsPerSeconds(this T value) + /// + public static ElectricPotentialChangeRate KilovoltsPerSecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromKilovoltsPerSeconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromKilovoltsPerSecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MegavoltsPerHours(this T value) + /// + public static ElectricPotentialChangeRate MegavoltsPerHour(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMegavoltsPerHours(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMegavoltsPerHour(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MegavoltsPerMicroseconds(this T value) + /// + public static ElectricPotentialChangeRate MegavoltsPerMicrosecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MegavoltsPerMinutes(this T value) + /// + public static ElectricPotentialChangeRate MegavoltsPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMegavoltsPerMinutes(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMegavoltsPerMinute(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MegavoltsPerSeconds(this T value) + /// + public static ElectricPotentialChangeRate MegavoltsPerSecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMegavoltsPerSeconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMegavoltsPerSecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MicrovoltsPerHours(this T value) + /// + public static ElectricPotentialChangeRate MicrovoltsPerHour(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMicrovoltsPerHours(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMicrovoltsPerHour(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MicrovoltsPerMicroseconds(this T value) + /// + public static ElectricPotentialChangeRate MicrovoltsPerMicrosecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MicrovoltsPerMinutes(this T value) + /// + public static ElectricPotentialChangeRate MicrovoltsPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MicrovoltsPerSeconds(this T value) + /// + public static ElectricPotentialChangeRate MicrovoltsPerSecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MillivoltsPerHours(this T value) + /// + public static ElectricPotentialChangeRate MillivoltsPerHour(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMillivoltsPerHours(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMillivoltsPerHour(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MillivoltsPerMicroseconds(this T value) + /// + public static ElectricPotentialChangeRate MillivoltsPerMicrosecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MillivoltsPerMinutes(this T value) + /// + public static ElectricPotentialChangeRate MillivoltsPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMillivoltsPerMinutes(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMillivoltsPerMinute(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate MillivoltsPerSeconds(this T value) + /// + public static ElectricPotentialChangeRate MillivoltsPerSecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromMillivoltsPerSeconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromMillivoltsPerSecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate VoltsPerHours(this T value) + /// + public static ElectricPotentialChangeRate VoltsPerHour(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromVoltsPerHours(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromVoltsPerHour(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate VoltsPerMicroseconds(this T value) + /// + public static ElectricPotentialChangeRate VoltsPerMicrosecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromVoltsPerMicroseconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate VoltsPerMinutes(this T value) + /// + public static ElectricPotentialChangeRate VoltsPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromVoltsPerMinutes(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromVoltsPerMinute(Convert.ToDouble(value)); - /// - public static ElectricPotentialChangeRate VoltsPerSeconds(this T value) + /// + public static ElectricPotentialChangeRate VoltsPerSecond(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => ElectricPotentialChangeRate.FromVoltsPerSeconds(Convert.ToDouble(value)); + => ElectricPotentialChangeRate.FromVoltsPerSecond(Convert.ToDouble(value)); } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs index da01bfdfcd..e7681b8ef9 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs @@ -32,13 +32,13 @@ namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency /// public static class NumberToFuelEfficiencyExtensions { - /// - public static FuelEfficiency KilometersPerLiters(this T value) + /// + public static FuelEfficiency KilometersPerLiter(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => FuelEfficiency.FromKilometersPerLiters(Convert.ToDouble(value)); + => FuelEfficiency.FromKilometersPerLiter(Convert.ToDouble(value)); /// public static FuelEfficiency LitersPer100Kilometers(this T value) diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs index ab0cfd99cb..956e9ae248 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs @@ -40,13 +40,13 @@ public static Speed CentimetersPerHour(this T value) #endif => Speed.FromCentimetersPerHour(Convert.ToDouble(value)); - /// - public static Speed CentimetersPerMinutes(this T value) + /// + public static Speed CentimetersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromCentimetersPerMinutes(Convert.ToDouble(value)); + => Speed.FromCentimetersPerMinute(Convert.ToDouble(value)); /// public static Speed CentimetersPerSecond(this T value) @@ -56,13 +56,13 @@ public static Speed CentimetersPerSecond(this T value) #endif => Speed.FromCentimetersPerSecond(Convert.ToDouble(value)); - /// - public static Speed DecimetersPerMinutes(this T value) + /// + public static Speed DecimetersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromDecimetersPerMinutes(Convert.ToDouble(value)); + => Speed.FromDecimetersPerMinute(Convert.ToDouble(value)); /// public static Speed DecimetersPerSecond(this T value) @@ -128,13 +128,13 @@ public static Speed KilometersPerHour(this T value) #endif => Speed.FromKilometersPerHour(Convert.ToDouble(value)); - /// - public static Speed KilometersPerMinutes(this T value) + /// + public static Speed KilometersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromKilometersPerMinutes(Convert.ToDouble(value)); + => Speed.FromKilometersPerMinute(Convert.ToDouble(value)); /// public static Speed KilometersPerSecond(this T value) @@ -168,13 +168,13 @@ public static Speed MetersPerHour(this T value) #endif => Speed.FromMetersPerHour(Convert.ToDouble(value)); - /// - public static Speed MetersPerMinutes(this T value) + /// + public static Speed MetersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromMetersPerMinutes(Convert.ToDouble(value)); + => Speed.FromMetersPerMinute(Convert.ToDouble(value)); /// public static Speed MetersPerSecond(this T value) @@ -184,13 +184,13 @@ public static Speed MetersPerSecond(this T value) #endif => Speed.FromMetersPerSecond(Convert.ToDouble(value)); - /// - public static Speed MicrometersPerMinutes(this T value) + /// + public static Speed MicrometersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromMicrometersPerMinutes(Convert.ToDouble(value)); + => Speed.FromMicrometersPerMinute(Convert.ToDouble(value)); /// public static Speed MicrometersPerSecond(this T value) @@ -216,13 +216,13 @@ public static Speed MillimetersPerHour(this T value) #endif => Speed.FromMillimetersPerHour(Convert.ToDouble(value)); - /// - public static Speed MillimetersPerMinutes(this T value) + /// + public static Speed MillimetersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromMillimetersPerMinutes(Convert.ToDouble(value)); + => Speed.FromMillimetersPerMinute(Convert.ToDouble(value)); /// public static Speed MillimetersPerSecond(this T value) @@ -232,13 +232,13 @@ public static Speed MillimetersPerSecond(this T value) #endif => Speed.FromMillimetersPerSecond(Convert.ToDouble(value)); - /// - public static Speed NanometersPerMinutes(this T value) + /// + public static Speed NanometersPerMinute(this T value) where T : notnull #if NET7_0_OR_GREATER , INumber #endif - => Speed.FromNanometersPerMinutes(Convert.ToDouble(value)); + => Speed.FromNanometersPerMinute(Convert.ToDouble(value)); /// public static Speed NanometersPerSecond(this T value) diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs index ac277f8eae..7701893f56 100644 --- a/UnitsNet.Tests/CustomCode/DensityTests.cs +++ b/UnitsNet.Tests/CustomCode/DensityTests.cs @@ -43,43 +43,43 @@ public class DensityTests : DensityTestsBase protected override double SlugsPerCubicFootInOneKilogramPerCubicMeter => 0.00194032; - protected override double CentigramsPerDeciLiterInOneKilogramPerCubicMeter => 1e1; + protected override double CentigramsPerDeciliterInOneKilogramPerCubicMeter => 1e1; protected override double CentigramsPerLiterInOneKilogramPerCubicMeter => 1e2; protected override double CentigramsPerMilliliterInOneKilogramPerCubicMeter => 1e-1; - protected override double DecigramsPerDeciLiterInOneKilogramPerCubicMeter => 1; + protected override double DecigramsPerDeciliterInOneKilogramPerCubicMeter => 1; protected override double DecigramsPerLiterInOneKilogramPerCubicMeter => 1e1; protected override double DecigramsPerMilliliterInOneKilogramPerCubicMeter => 1e-2; - protected override double GramsPerDeciLiterInOneKilogramPerCubicMeter => 1e-1; + protected override double GramsPerDeciliterInOneKilogramPerCubicMeter => 1e-1; protected override double GramsPerLiterInOneKilogramPerCubicMeter => 1; protected override double GramsPerMilliliterInOneKilogramPerCubicMeter => 1e-3; - protected override double MicrogramsPerDeciLiterInOneKilogramPerCubicMeter => 1e5; + protected override double MicrogramsPerDeciliterInOneKilogramPerCubicMeter => 1e5; protected override double MicrogramsPerLiterInOneKilogramPerCubicMeter => 1e6; protected override double MicrogramsPerMilliliterInOneKilogramPerCubicMeter => 1e3; - protected override double MilligramsPerDeciLiterInOneKilogramPerCubicMeter => 1e2; + protected override double MilligramsPerDeciliterInOneKilogramPerCubicMeter => 1e2; protected override double MilligramsPerLiterInOneKilogramPerCubicMeter => 1e3; protected override double MilligramsPerMilliliterInOneKilogramPerCubicMeter => 1; - protected override double NanogramsPerDeciLiterInOneKilogramPerCubicMeter => 1e8; + protected override double NanogramsPerDeciliterInOneKilogramPerCubicMeter => 1e8; protected override double NanogramsPerLiterInOneKilogramPerCubicMeter => 1e9; protected override double NanogramsPerMilliliterInOneKilogramPerCubicMeter => 1e6; - protected override double PicogramsPerDeciLiterInOneKilogramPerCubicMeter => 1e11; + protected override double PicogramsPerDeciliterInOneKilogramPerCubicMeter => 1e11; protected override double PicogramsPerLiterInOneKilogramPerCubicMeter => 1e12; diff --git a/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs b/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs index 478fe93087..80dd69de4d 100644 --- a/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricPotentialChangeRateTests.cs @@ -24,25 +24,25 @@ namespace UnitsNet.Tests.CustomCode public class ElectricPotentialChangeRateTests : ElectricPotentialChangeRateTestsBase { protected override bool SupportsSIUnitSystem => true; - protected override double KilovoltsPerHoursInOneVoltPerSecond => 3.6; - protected override double KilovoltsPerMicrosecondsInOneVoltPerSecond => 1e-09; - protected override double KilovoltsPerMinutesInOneVoltPerSecond => 6e-2; - protected override double KilovoltsPerSecondsInOneVoltPerSecond => 0.001; - protected override double MegavoltsPerHoursInOneVoltPerSecond => 3.6e-3; - protected override double MegavoltsPerMicrosecondsInOneVoltPerSecond => 1e-12; - protected override double MegavoltsPerMinutesInOneVoltPerSecond => 6e-05; - protected override double MegavoltsPerSecondsInOneVoltPerSecond => 1e-06; - protected override double MicrovoltsPerHoursInOneVoltPerSecond => 3.6e9; - protected override double MicrovoltsPerMicrosecondsInOneVoltPerSecond => 1; - protected override double MicrovoltsPerMinutesInOneVoltPerSecond => 6e7; - protected override double MicrovoltsPerSecondsInOneVoltPerSecond => 1e6; - protected override double MillivoltsPerHoursInOneVoltPerSecond => 3.6e6; - protected override double MillivoltsPerMicrosecondsInOneVoltPerSecond => 0.001; - protected override double MillivoltsPerMinutesInOneVoltPerSecond => 6e4; - protected override double MillivoltsPerSecondsInOneVoltPerSecond => 1000; - protected override double VoltsPerHoursInOneVoltPerSecond => 3600; - protected override double VoltsPerMicrosecondsInOneVoltPerSecond => 1e-06; - protected override double VoltsPerMinutesInOneVoltPerSecond => 60; - protected override double VoltsPerSecondsInOneVoltPerSecond => 1; + protected override double KilovoltsPerHourInOneVoltPerSecond => 3.6; + protected override double KilovoltsPerMicrosecondInOneVoltPerSecond => 1e-09; + protected override double KilovoltsPerMinuteInOneVoltPerSecond => 6e-2; + protected override double KilovoltsPerSecondInOneVoltPerSecond => 0.001; + protected override double MegavoltsPerHourInOneVoltPerSecond => 3.6e-3; + protected override double MegavoltsPerMicrosecondInOneVoltPerSecond => 1e-12; + protected override double MegavoltsPerMinuteInOneVoltPerSecond => 6e-05; + protected override double MegavoltsPerSecondInOneVoltPerSecond => 1e-06; + protected override double MicrovoltsPerHourInOneVoltPerSecond => 3.6e9; + protected override double MicrovoltsPerMicrosecondInOneVoltPerSecond => 1; + protected override double MicrovoltsPerMinuteInOneVoltPerSecond => 6e7; + protected override double MicrovoltsPerSecondInOneVoltPerSecond => 1e6; + protected override double MillivoltsPerHourInOneVoltPerSecond => 3.6e6; + protected override double MillivoltsPerMicrosecondInOneVoltPerSecond => 0.001; + protected override double MillivoltsPerMinuteInOneVoltPerSecond => 6e4; + protected override double MillivoltsPerSecondInOneVoltPerSecond => 1000; + protected override double VoltsPerHourInOneVoltPerSecond => 3600; + protected override double VoltsPerMicrosecondInOneVoltPerSecond => 1e-06; + protected override double VoltsPerMinuteInOneVoltPerSecond => 60; + protected override double VoltsPerSecondInOneVoltPerSecond => 1; } } diff --git a/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs b/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs index 3a131ba154..31da379824 100644 --- a/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs +++ b/UnitsNet.Tests/CustomCode/FuelEfficiencyTests.cs @@ -26,7 +26,7 @@ namespace UnitsNet.Tests.CustomCode public class FuelEfficiencyTests : FuelEfficiencyTestsBase { protected override bool SupportsSIUnitSystem => false; - protected override double KilometersPerLitersInOneLiterPer100Kilometers => 100; + protected override double KilometersPerLiterInOneLiterPer100Kilometers => 100; protected override double LitersPer100KilometersInOneLiterPer100Kilometers => 1; protected override double MilesPerUkGallonInOneLiterPer100Kilometers => 282.4809363; protected override double MilesPerUsGallonInOneLiterPer100Kilometers => 235.2145833; diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs index 70c4a569b6..629c61358e 100644 --- a/UnitsNet.Tests/CustomCode/SpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs @@ -33,19 +33,19 @@ public class SpeedTests : SpeedTestsBase protected override double MetersPerHourInOneMeterPerSecond => 3.6E3; - protected override double NanometersPerMinutesInOneMeterPerSecond => 6E10; + protected override double NanometersPerMinuteInOneMeterPerSecond => 6E10; - protected override double MicrometersPerMinutesInOneMeterPerSecond => 6E7; + protected override double MicrometersPerMinuteInOneMeterPerSecond => 6E7; - protected override double MillimetersPerMinutesInOneMeterPerSecond => 6E4; + protected override double MillimetersPerMinuteInOneMeterPerSecond => 6E4; - protected override double CentimetersPerMinutesInOneMeterPerSecond => 6E3; + protected override double CentimetersPerMinuteInOneMeterPerSecond => 6E3; - protected override double DecimetersPerMinutesInOneMeterPerSecond => 6E2; + protected override double DecimetersPerMinuteInOneMeterPerSecond => 6E2; - protected override double MetersPerMinutesInOneMeterPerSecond => 6E1; + protected override double MetersPerMinuteInOneMeterPerSecond => 6E1; - protected override double KilometersPerMinutesInOneMeterPerSecond => 6E-2; + protected override double KilometersPerMinuteInOneMeterPerSecond => 6E-2; protected override double CentimetersPerHourInOneMeterPerSecond => 3.6E5; diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs index 9357b848af..c62baccb37 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/DensityTestsBase.g.cs @@ -38,10 +38,10 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class DensityTestsBase : QuantityTestsBase { - protected abstract double CentigramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double CentigramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double CentigramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double CentigramsPerMilliliterInOneKilogramPerCubicMeter { get; } - protected abstract double DecigramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double DecigramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double DecigramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double DecigramsPerMilliliterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } @@ -49,7 +49,7 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected abstract double GramsPerCubicInchInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicMeterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerCubicMillimeterInOneKilogramPerCubicMeter { get; } - protected abstract double GramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double GramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double GramsPerMilliliterInOneKilogramPerCubicMeter { get; } protected abstract double KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } @@ -59,17 +59,17 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected abstract double KilopoundsPerCubicFootInOneKilogramPerCubicMeter { get; } protected abstract double KilopoundsPerCubicInchInOneKilogramPerCubicMeter { get; } protected abstract double MicrogramsPerCubicMeterInOneKilogramPerCubicMeter { get; } - protected abstract double MicrogramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double MicrogramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double MicrogramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double MicrogramsPerMilliliterInOneKilogramPerCubicMeter { get; } protected abstract double MilligramsPerCubicMeterInOneKilogramPerCubicMeter { get; } - protected abstract double MilligramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double MilligramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double MilligramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double MilligramsPerMilliliterInOneKilogramPerCubicMeter { get; } - protected abstract double NanogramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double NanogramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double NanogramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double NanogramsPerMilliliterInOneKilogramPerCubicMeter { get; } - protected abstract double PicogramsPerDeciLiterInOneKilogramPerCubicMeter { get; } + protected abstract double PicogramsPerDeciliterInOneKilogramPerCubicMeter { get; } protected abstract double PicogramsPerLiterInOneKilogramPerCubicMeter { get; } protected abstract double PicogramsPerMilliliterInOneKilogramPerCubicMeter { get; } protected abstract double PoundsPerCubicCentimeterInOneKilogramPerCubicMeter { get; } @@ -91,10 +91,10 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected abstract double TonnesPerCubicMillimeterInOneKilogramPerCubicMeter { get; } // ReSharper disable VirtualMemberNeverOverriden.Global - protected virtual double CentigramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double CentigramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double CentigramsPerLiterTolerance { get { return 1e-5; } } protected virtual double CentigramsPerMilliliterTolerance { get { return 1e-5; } } - protected virtual double DecigramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double DecigramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double DecigramsPerLiterTolerance { get { return 1e-5; } } protected virtual double DecigramsPerMilliliterTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicCentimeterTolerance { get { return 1e-5; } } @@ -102,7 +102,7 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected virtual double GramsPerCubicInchTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicMeterTolerance { get { return 1e-5; } } protected virtual double GramsPerCubicMillimeterTolerance { get { return 1e-5; } } - protected virtual double GramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double GramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double GramsPerLiterTolerance { get { return 1e-5; } } protected virtual double GramsPerMilliliterTolerance { get { return 1e-5; } } protected virtual double KilogramsPerCubicCentimeterTolerance { get { return 1e-5; } } @@ -112,17 +112,17 @@ public abstract partial class DensityTestsBase : QuantityTestsBase protected virtual double KilopoundsPerCubicFootTolerance { get { return 1e-5; } } protected virtual double KilopoundsPerCubicInchTolerance { get { return 1e-5; } } protected virtual double MicrogramsPerCubicMeterTolerance { get { return 1e-5; } } - protected virtual double MicrogramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double MicrogramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double MicrogramsPerLiterTolerance { get { return 1e-5; } } protected virtual double MicrogramsPerMilliliterTolerance { get { return 1e-5; } } protected virtual double MilligramsPerCubicMeterTolerance { get { return 1e-5; } } - protected virtual double MilligramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double MilligramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double MilligramsPerLiterTolerance { get { return 1e-5; } } protected virtual double MilligramsPerMilliliterTolerance { get { return 1e-5; } } - protected virtual double NanogramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double NanogramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double NanogramsPerLiterTolerance { get { return 1e-5; } } protected virtual double NanogramsPerMilliliterTolerance { get { return 1e-5; } } - protected virtual double PicogramsPerDeciLiterTolerance { get { return 1e-5; } } + protected virtual double PicogramsPerDeciliterTolerance { get { return 1e-5; } } protected virtual double PicogramsPerLiterTolerance { get { return 1e-5; } } protected virtual double PicogramsPerMilliliterTolerance { get { return 1e-5; } } protected virtual double PoundsPerCubicCentimeterTolerance { get { return 1e-5; } } @@ -148,10 +148,10 @@ public abstract partial class DensityTestsBase : QuantityTestsBase { return unit switch { - DensityUnit.CentigramPerDeciliter => (CentigramsPerDeciLiterInOneKilogramPerCubicMeter, CentigramsPerDeciLiterTolerance), + DensityUnit.CentigramPerDeciliter => (CentigramsPerDeciliterInOneKilogramPerCubicMeter, CentigramsPerDeciliterTolerance), DensityUnit.CentigramPerLiter => (CentigramsPerLiterInOneKilogramPerCubicMeter, CentigramsPerLiterTolerance), DensityUnit.CentigramPerMilliliter => (CentigramsPerMilliliterInOneKilogramPerCubicMeter, CentigramsPerMilliliterTolerance), - DensityUnit.DecigramPerDeciliter => (DecigramsPerDeciLiterInOneKilogramPerCubicMeter, DecigramsPerDeciLiterTolerance), + DensityUnit.DecigramPerDeciliter => (DecigramsPerDeciliterInOneKilogramPerCubicMeter, DecigramsPerDeciliterTolerance), DensityUnit.DecigramPerLiter => (DecigramsPerLiterInOneKilogramPerCubicMeter, DecigramsPerLiterTolerance), DensityUnit.DecigramPerMilliliter => (DecigramsPerMilliliterInOneKilogramPerCubicMeter, DecigramsPerMilliliterTolerance), DensityUnit.GramPerCubicCentimeter => (GramsPerCubicCentimeterInOneKilogramPerCubicMeter, GramsPerCubicCentimeterTolerance), @@ -159,7 +159,7 @@ public abstract partial class DensityTestsBase : QuantityTestsBase DensityUnit.GramPerCubicInch => (GramsPerCubicInchInOneKilogramPerCubicMeter, GramsPerCubicInchTolerance), DensityUnit.GramPerCubicMeter => (GramsPerCubicMeterInOneKilogramPerCubicMeter, GramsPerCubicMeterTolerance), DensityUnit.GramPerCubicMillimeter => (GramsPerCubicMillimeterInOneKilogramPerCubicMeter, GramsPerCubicMillimeterTolerance), - DensityUnit.GramPerDeciliter => (GramsPerDeciLiterInOneKilogramPerCubicMeter, GramsPerDeciLiterTolerance), + DensityUnit.GramPerDeciliter => (GramsPerDeciliterInOneKilogramPerCubicMeter, GramsPerDeciliterTolerance), DensityUnit.GramPerLiter => (GramsPerLiterInOneKilogramPerCubicMeter, GramsPerLiterTolerance), DensityUnit.GramPerMilliliter => (GramsPerMilliliterInOneKilogramPerCubicMeter, GramsPerMilliliterTolerance), DensityUnit.KilogramPerCubicCentimeter => (KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter, KilogramsPerCubicCentimeterTolerance), @@ -169,17 +169,17 @@ public abstract partial class DensityTestsBase : QuantityTestsBase DensityUnit.KilopoundPerCubicFoot => (KilopoundsPerCubicFootInOneKilogramPerCubicMeter, KilopoundsPerCubicFootTolerance), DensityUnit.KilopoundPerCubicInch => (KilopoundsPerCubicInchInOneKilogramPerCubicMeter, KilopoundsPerCubicInchTolerance), DensityUnit.MicrogramPerCubicMeter => (MicrogramsPerCubicMeterInOneKilogramPerCubicMeter, MicrogramsPerCubicMeterTolerance), - DensityUnit.MicrogramPerDeciliter => (MicrogramsPerDeciLiterInOneKilogramPerCubicMeter, MicrogramsPerDeciLiterTolerance), + DensityUnit.MicrogramPerDeciliter => (MicrogramsPerDeciliterInOneKilogramPerCubicMeter, MicrogramsPerDeciliterTolerance), DensityUnit.MicrogramPerLiter => (MicrogramsPerLiterInOneKilogramPerCubicMeter, MicrogramsPerLiterTolerance), DensityUnit.MicrogramPerMilliliter => (MicrogramsPerMilliliterInOneKilogramPerCubicMeter, MicrogramsPerMilliliterTolerance), DensityUnit.MilligramPerCubicMeter => (MilligramsPerCubicMeterInOneKilogramPerCubicMeter, MilligramsPerCubicMeterTolerance), - DensityUnit.MilligramPerDeciliter => (MilligramsPerDeciLiterInOneKilogramPerCubicMeter, MilligramsPerDeciLiterTolerance), + DensityUnit.MilligramPerDeciliter => (MilligramsPerDeciliterInOneKilogramPerCubicMeter, MilligramsPerDeciliterTolerance), DensityUnit.MilligramPerLiter => (MilligramsPerLiterInOneKilogramPerCubicMeter, MilligramsPerLiterTolerance), DensityUnit.MilligramPerMilliliter => (MilligramsPerMilliliterInOneKilogramPerCubicMeter, MilligramsPerMilliliterTolerance), - DensityUnit.NanogramPerDeciliter => (NanogramsPerDeciLiterInOneKilogramPerCubicMeter, NanogramsPerDeciLiterTolerance), + DensityUnit.NanogramPerDeciliter => (NanogramsPerDeciliterInOneKilogramPerCubicMeter, NanogramsPerDeciliterTolerance), DensityUnit.NanogramPerLiter => (NanogramsPerLiterInOneKilogramPerCubicMeter, NanogramsPerLiterTolerance), DensityUnit.NanogramPerMilliliter => (NanogramsPerMilliliterInOneKilogramPerCubicMeter, NanogramsPerMilliliterTolerance), - DensityUnit.PicogramPerDeciliter => (PicogramsPerDeciLiterInOneKilogramPerCubicMeter, PicogramsPerDeciLiterTolerance), + DensityUnit.PicogramPerDeciliter => (PicogramsPerDeciliterInOneKilogramPerCubicMeter, PicogramsPerDeciliterTolerance), DensityUnit.PicogramPerLiter => (PicogramsPerLiterInOneKilogramPerCubicMeter, PicogramsPerLiterTolerance), DensityUnit.PicogramPerMilliliter => (PicogramsPerMilliliterInOneKilogramPerCubicMeter, PicogramsPerMilliliterTolerance), DensityUnit.PoundPerCubicCentimeter => (PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, PoundsPerCubicCentimeterTolerance), @@ -323,10 +323,10 @@ public void Density_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() public void KilogramPerCubicMeterToDensityUnits() { Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); - AssertEx.EqualTolerance(CentigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(CentigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance); AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerLiter, CentigramsPerLiterTolerance); AssertEx.EqualTolerance(CentigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.CentigramsPerMilliliter, CentigramsPerMilliliterTolerance); - AssertEx.EqualTolerance(DecigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerDeciLiter, DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(DecigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerDeciliter, DecigramsPerDeciliterTolerance); AssertEx.EqualTolerance(DecigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerLiter, DecigramsPerLiterTolerance); AssertEx.EqualTolerance(DecigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.DecigramsPerMilliliter, DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(GramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicCentimeter, GramsPerCubicCentimeterTolerance); @@ -334,7 +334,7 @@ public void KilogramPerCubicMeterToDensityUnits() AssertEx.EqualTolerance(GramsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicInch, GramsPerCubicInchTolerance); AssertEx.EqualTolerance(GramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicMeter, GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(GramsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerCubicMillimeter, GramsPerCubicMillimeterTolerance); - AssertEx.EqualTolerance(GramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerDeciLiter, GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(GramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerDeciliter, GramsPerDeciliterTolerance); AssertEx.EqualTolerance(GramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerLiter, GramsPerLiterTolerance); AssertEx.EqualTolerance(GramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.GramsPerMilliliter, GramsPerMilliliterTolerance); AssertEx.EqualTolerance(KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.KilogramsPerCubicCentimeter, KilogramsPerCubicCentimeterTolerance); @@ -344,17 +344,17 @@ public void KilogramPerCubicMeterToDensityUnits() AssertEx.EqualTolerance(KilopoundsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.KilopoundsPerCubicFoot, KilopoundsPerCubicFootTolerance); AssertEx.EqualTolerance(KilopoundsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.KilopoundsPerCubicInch, KilopoundsPerCubicInchTolerance); AssertEx.EqualTolerance(MicrogramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MicrogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(MicrogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(MicrogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MicrogramsPerDeciliter, MicrogramsPerDeciliterTolerance); AssertEx.EqualTolerance(MicrogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MicrogramsPerLiter, MicrogramsPerLiterTolerance); AssertEx.EqualTolerance(MicrogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MicrogramsPerMilliliter, MicrogramsPerMilliliterTolerance); AssertEx.EqualTolerance(MilligramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MilligramsPerCubicMeter, MilligramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(MilligramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(MilligramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MilligramsPerDeciliter, MilligramsPerDeciliterTolerance); AssertEx.EqualTolerance(MilligramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MilligramsPerLiter, MilligramsPerLiterTolerance); AssertEx.EqualTolerance(MilligramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.MilligramsPerMilliliter, MilligramsPerMilliliterTolerance); - AssertEx.EqualTolerance(NanogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(NanogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerDeciliter, NanogramsPerDeciliterTolerance); AssertEx.EqualTolerance(NanogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerLiter, NanogramsPerLiterTolerance); AssertEx.EqualTolerance(NanogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance); - AssertEx.EqualTolerance(PicogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(PicogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance); AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerLiter, PicogramsPerLiterTolerance); AssertEx.EqualTolerance(PicogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance); AssertEx.EqualTolerance(PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PoundsPerCubicCentimeter, PoundsPerCubicCentimeterTolerance); @@ -380,7 +380,7 @@ public void KilogramPerCubicMeterToDensityUnits() public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { var quantity00 = Density.From(1, DensityUnit.CentigramPerDeciliter); - AssertEx.EqualTolerance(1, quantity00.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity00.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.CentigramPerDeciliter, quantity00.Unit); var quantity01 = Density.From(1, DensityUnit.CentigramPerLiter); @@ -392,7 +392,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.CentigramPerMilliliter, quantity02.Unit); var quantity03 = Density.From(1, DensityUnit.DecigramPerDeciliter); - AssertEx.EqualTolerance(1, quantity03.DecigramsPerDeciLiter, DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity03.DecigramsPerDeciliter, DecigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.DecigramPerDeciliter, quantity03.Unit); var quantity04 = Density.From(1, DensityUnit.DecigramPerLiter); @@ -424,7 +424,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.GramPerCubicMillimeter, quantity10.Unit); var quantity11 = Density.From(1, DensityUnit.GramPerDeciliter); - AssertEx.EqualTolerance(1, quantity11.GramsPerDeciLiter, GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity11.GramsPerDeciliter, GramsPerDeciliterTolerance); Assert.Equal(DensityUnit.GramPerDeciliter, quantity11.Unit); var quantity12 = Density.From(1, DensityUnit.GramPerLiter); @@ -464,7 +464,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.MicrogramPerCubicMeter, quantity20.Unit); var quantity21 = Density.From(1, DensityUnit.MicrogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity21.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity21.MicrogramsPerDeciliter, MicrogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MicrogramPerDeciliter, quantity21.Unit); var quantity22 = Density.From(1, DensityUnit.MicrogramPerLiter); @@ -480,7 +480,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.MilligramPerCubicMeter, quantity24.Unit); var quantity25 = Density.From(1, DensityUnit.MilligramPerDeciliter); - AssertEx.EqualTolerance(1, quantity25.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity25.MilligramsPerDeciliter, MilligramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MilligramPerDeciliter, quantity25.Unit); var quantity26 = Density.From(1, DensityUnit.MilligramPerLiter); @@ -492,7 +492,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.MilligramPerMilliliter, quantity27.Unit); var quantity28 = Density.From(1, DensityUnit.NanogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity28.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity28.NanogramsPerDeciliter, NanogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.NanogramPerDeciliter, quantity28.Unit); var quantity29 = Density.From(1, DensityUnit.NanogramPerLiter); @@ -504,7 +504,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(DensityUnit.NanogramPerMilliliter, quantity30.Unit); var quantity31 = Density.From(1, DensityUnit.PicogramPerDeciliter); - AssertEx.EqualTolerance(1, quantity31.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, quantity31.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.PicogramPerDeciliter, quantity31.Unit); var quantity32 = Density.From(1, DensityUnit.PicogramPerLiter); @@ -607,10 +607,10 @@ public void FromKilogramsPerCubicMeter_WithNanValue_DoNotThrowsArgumentException public void As() { var kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); - AssertEx.EqualTolerance(CentigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerDeciliter), CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(CentigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerDeciliter), CentigramsPerDeciliterTolerance); AssertEx.EqualTolerance(CentigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerLiter), CentigramsPerLiterTolerance); AssertEx.EqualTolerance(CentigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.CentigramPerMilliliter), CentigramsPerMilliliterTolerance); - AssertEx.EqualTolerance(DecigramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerDeciliter), DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(DecigramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerDeciliter), DecigramsPerDeciliterTolerance); AssertEx.EqualTolerance(DecigramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerLiter), DecigramsPerLiterTolerance); AssertEx.EqualTolerance(DecigramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.DecigramPerMilliliter), DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(GramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicCentimeter), GramsPerCubicCentimeterTolerance); @@ -618,7 +618,7 @@ public void As() AssertEx.EqualTolerance(GramsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicInch), GramsPerCubicInchTolerance); AssertEx.EqualTolerance(GramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicMeter), GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(GramsPerCubicMillimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerCubicMillimeter), GramsPerCubicMillimeterTolerance); - AssertEx.EqualTolerance(GramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerDeciliter), GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(GramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerDeciliter), GramsPerDeciliterTolerance); AssertEx.EqualTolerance(GramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerLiter), GramsPerLiterTolerance); AssertEx.EqualTolerance(GramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.GramPerMilliliter), GramsPerMilliliterTolerance); AssertEx.EqualTolerance(KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.KilogramPerCubicCentimeter), KilogramsPerCubicCentimeterTolerance); @@ -628,17 +628,17 @@ public void As() AssertEx.EqualTolerance(KilopoundsPerCubicFootInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.KilopoundPerCubicFoot), KilopoundsPerCubicFootTolerance); AssertEx.EqualTolerance(KilopoundsPerCubicInchInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.KilopoundPerCubicInch), KilopoundsPerCubicInchTolerance); AssertEx.EqualTolerance(MicrogramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MicrogramPerCubicMeter), MicrogramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(MicrogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MicrogramPerDeciliter), MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(MicrogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MicrogramPerDeciliter), MicrogramsPerDeciliterTolerance); AssertEx.EqualTolerance(MicrogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MicrogramPerLiter), MicrogramsPerLiterTolerance); AssertEx.EqualTolerance(MicrogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MicrogramPerMilliliter), MicrogramsPerMilliliterTolerance); AssertEx.EqualTolerance(MilligramsPerCubicMeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MilligramPerCubicMeter), MilligramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(MilligramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MilligramPerDeciliter), MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(MilligramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MilligramPerDeciliter), MilligramsPerDeciliterTolerance); AssertEx.EqualTolerance(MilligramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MilligramPerLiter), MilligramsPerLiterTolerance); AssertEx.EqualTolerance(MilligramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.MilligramPerMilliliter), MilligramsPerMilliliterTolerance); - AssertEx.EqualTolerance(NanogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.NanogramPerDeciliter), NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(NanogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.NanogramPerDeciliter), NanogramsPerDeciliterTolerance); AssertEx.EqualTolerance(NanogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.NanogramPerLiter), NanogramsPerLiterTolerance); AssertEx.EqualTolerance(NanogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.NanogramPerMilliliter), NanogramsPerMilliliterTolerance); - AssertEx.EqualTolerance(PicogramsPerDeciLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerDeciliter), PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(PicogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerDeciliter), PicogramsPerDeciliterTolerance); AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerLiter), PicogramsPerLiterTolerance); AssertEx.EqualTolerance(PicogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PicogramPerMilliliter), PicogramsPerMilliliterTolerance); AssertEx.EqualTolerance(PoundsPerCubicCentimeterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(DensityUnit.PoundPerCubicCentimeter), PoundsPerCubicCentimeterTolerance); @@ -683,7 +683,7 @@ public void Parse() try { var parsed = Density.Parse("1 cg/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.CentigramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -704,7 +704,7 @@ public void Parse() try { var parsed = Density.Parse("1 dg/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.DecigramsPerDeciLiter, DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.DecigramsPerDeciliter, DecigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.DecigramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -767,7 +767,7 @@ public void Parse() try { var parsed = Density.Parse("1 g/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.GramsPerDeciLiter, GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.GramsPerDeciliter, GramsPerDeciliterTolerance); Assert.Equal(DensityUnit.GramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -851,7 +851,7 @@ public void Parse() try { var parsed = Density.Parse("1 µg/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.MicrogramsPerDeciliter, MicrogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MicrogramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -886,7 +886,7 @@ public void Parse() try { var parsed = Density.Parse("1 mg/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.MilligramsPerDeciliter, MilligramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MilligramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -907,7 +907,7 @@ public void Parse() try { var parsed = Density.Parse("1 ng/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.NanogramsPerDeciliter, NanogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.NanogramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -928,7 +928,7 @@ public void Parse() try { var parsed = Density.Parse("1 pg/dl", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.PicogramPerDeciliter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -1072,7 +1072,7 @@ public void TryParse() { { Assert.True(Density.TryParse("1 cg/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.CentigramsPerDeciLiter, CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.CentigramsPerDeciliter, CentigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.CentigramPerDeciliter, parsed.Unit); } @@ -1090,7 +1090,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 dg/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.DecigramsPerDeciLiter, DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.DecigramsPerDeciliter, DecigramsPerDeciliterTolerance); Assert.Equal(DensityUnit.DecigramPerDeciliter, parsed.Unit); } @@ -1144,7 +1144,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 g/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.GramsPerDeciLiter, GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.GramsPerDeciliter, GramsPerDeciliterTolerance); Assert.Equal(DensityUnit.GramPerDeciliter, parsed.Unit); } @@ -1216,7 +1216,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 µg/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrogramsPerDeciLiter, MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.MicrogramsPerDeciliter, MicrogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MicrogramPerDeciliter, parsed.Unit); } @@ -1246,7 +1246,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 mg/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MilligramsPerDeciLiter, MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.MilligramsPerDeciliter, MilligramsPerDeciliterTolerance); Assert.Equal(DensityUnit.MilligramPerDeciliter, parsed.Unit); } @@ -1264,7 +1264,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 ng/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.NanogramsPerDeciLiter, NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.NanogramsPerDeciliter, NanogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.NanogramPerDeciliter, parsed.Unit); } @@ -1282,7 +1282,7 @@ public void TryParse() { Assert.True(Density.TryParse("1 pg/dl", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.PicogramsPerDeciLiter, PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, parsed.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance); Assert.Equal(DensityUnit.PicogramPerDeciliter, parsed.Unit); } @@ -2063,10 +2063,10 @@ public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(Dens public void ConversionRoundTrip() { Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); - AssertEx.EqualTolerance(1, Density.FromCentigramsPerDeciLiter(kilogrampercubicmeter.CentigramsPerDeciLiter).KilogramsPerCubicMeter, CentigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromCentigramsPerDeciliter(kilogrampercubicmeter.CentigramsPerDeciliter).KilogramsPerCubicMeter, CentigramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromCentigramsPerLiter(kilogrampercubicmeter.CentigramsPerLiter).KilogramsPerCubicMeter, CentigramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromCentigramsPerMilliliter(kilogrampercubicmeter.CentigramsPerMilliliter).KilogramsPerCubicMeter, CentigramsPerMilliliterTolerance); - AssertEx.EqualTolerance(1, Density.FromDecigramsPerDeciLiter(kilogrampercubicmeter.DecigramsPerDeciLiter).KilogramsPerCubicMeter, DecigramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromDecigramsPerDeciliter(kilogrampercubicmeter.DecigramsPerDeciliter).KilogramsPerCubicMeter, DecigramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromDecigramsPerLiter(kilogrampercubicmeter.DecigramsPerLiter).KilogramsPerCubicMeter, DecigramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromDecigramsPerMilliliter(kilogrampercubicmeter.DecigramsPerMilliliter).KilogramsPerCubicMeter, DecigramsPerMilliliterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicCentimeter(kilogrampercubicmeter.GramsPerCubicCentimeter).KilogramsPerCubicMeter, GramsPerCubicCentimeterTolerance); @@ -2074,7 +2074,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Density.FromGramsPerCubicInch(kilogrampercubicmeter.GramsPerCubicInch).KilogramsPerCubicMeter, GramsPerCubicInchTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMeter(kilogrampercubicmeter.GramsPerCubicMeter).KilogramsPerCubicMeter, GramsPerCubicMeterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerCubicMillimeter(kilogrampercubicmeter.GramsPerCubicMillimeter).KilogramsPerCubicMeter, GramsPerCubicMillimeterTolerance); - AssertEx.EqualTolerance(1, Density.FromGramsPerDeciLiter(kilogrampercubicmeter.GramsPerDeciLiter).KilogramsPerCubicMeter, GramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromGramsPerDeciliter(kilogrampercubicmeter.GramsPerDeciliter).KilogramsPerCubicMeter, GramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerLiter(kilogrampercubicmeter.GramsPerLiter).KilogramsPerCubicMeter, GramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromGramsPerMilliliter(kilogrampercubicmeter.GramsPerMilliliter).KilogramsPerCubicMeter, GramsPerMilliliterTolerance); AssertEx.EqualTolerance(1, Density.FromKilogramsPerCubicCentimeter(kilogrampercubicmeter.KilogramsPerCubicCentimeter).KilogramsPerCubicMeter, KilogramsPerCubicCentimeterTolerance); @@ -2084,17 +2084,17 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicFoot(kilogrampercubicmeter.KilopoundsPerCubicFoot).KilogramsPerCubicMeter, KilopoundsPerCubicFootTolerance); AssertEx.EqualTolerance(1, Density.FromKilopoundsPerCubicInch(kilogrampercubicmeter.KilopoundsPerCubicInch).KilogramsPerCubicMeter, KilopoundsPerCubicInchTolerance); AssertEx.EqualTolerance(1, Density.FromMicrogramsPerCubicMeter(kilogrampercubicmeter.MicrogramsPerCubicMeter).KilogramsPerCubicMeter, MicrogramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(1, Density.FromMicrogramsPerDeciLiter(kilogrampercubicmeter.MicrogramsPerDeciLiter).KilogramsPerCubicMeter, MicrogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromMicrogramsPerDeciliter(kilogrampercubicmeter.MicrogramsPerDeciliter).KilogramsPerCubicMeter, MicrogramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromMicrogramsPerLiter(kilogrampercubicmeter.MicrogramsPerLiter).KilogramsPerCubicMeter, MicrogramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromMicrogramsPerMilliliter(kilogrampercubicmeter.MicrogramsPerMilliliter).KilogramsPerCubicMeter, MicrogramsPerMilliliterTolerance); AssertEx.EqualTolerance(1, Density.FromMilligramsPerCubicMeter(kilogrampercubicmeter.MilligramsPerCubicMeter).KilogramsPerCubicMeter, MilligramsPerCubicMeterTolerance); - AssertEx.EqualTolerance(1, Density.FromMilligramsPerDeciLiter(kilogrampercubicmeter.MilligramsPerDeciLiter).KilogramsPerCubicMeter, MilligramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromMilligramsPerDeciliter(kilogrampercubicmeter.MilligramsPerDeciliter).KilogramsPerCubicMeter, MilligramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromMilligramsPerLiter(kilogrampercubicmeter.MilligramsPerLiter).KilogramsPerCubicMeter, MilligramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromMilligramsPerMilliliter(kilogrampercubicmeter.MilligramsPerMilliliter).KilogramsPerCubicMeter, MilligramsPerMilliliterTolerance); - AssertEx.EqualTolerance(1, Density.FromNanogramsPerDeciLiter(kilogrampercubicmeter.NanogramsPerDeciLiter).KilogramsPerCubicMeter, NanogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromNanogramsPerDeciliter(kilogrampercubicmeter.NanogramsPerDeciliter).KilogramsPerCubicMeter, NanogramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance); - AssertEx.EqualTolerance(1, Density.FromPicogramsPerDeciLiter(kilogrampercubicmeter.PicogramsPerDeciLiter).KilogramsPerCubicMeter, PicogramsPerDeciLiterTolerance); + AssertEx.EqualTolerance(1, Density.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance); AssertEx.EqualTolerance(1, Density.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance); AssertEx.EqualTolerance(1, Density.FromPicogramsPerMilliliter(kilogrampercubicmeter.PicogramsPerMilliliter).KilogramsPerCubicMeter, PicogramsPerMilliliterTolerance); AssertEx.EqualTolerance(1, Density.FromPoundsPerCubicCentimeter(kilogrampercubicmeter.PoundsPerCubicCentimeter).KilogramsPerCubicMeter, PoundsPerCubicCentimeterTolerance); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs index ca8ec9654c..3f496d9d3d 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricPotentialChangeRateTestsBase.g.cs @@ -38,74 +38,74 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class ElectricPotentialChangeRateTestsBase : QuantityTestsBase { - protected abstract double KilovoltsPerHoursInOneVoltPerSecond { get; } - protected abstract double KilovoltsPerMicrosecondsInOneVoltPerSecond { get; } - protected abstract double KilovoltsPerMinutesInOneVoltPerSecond { get; } - protected abstract double KilovoltsPerSecondsInOneVoltPerSecond { get; } - protected abstract double MegavoltsPerHoursInOneVoltPerSecond { get; } - protected abstract double MegavoltsPerMicrosecondsInOneVoltPerSecond { get; } - protected abstract double MegavoltsPerMinutesInOneVoltPerSecond { get; } - protected abstract double MegavoltsPerSecondsInOneVoltPerSecond { get; } - protected abstract double MicrovoltsPerHoursInOneVoltPerSecond { get; } - protected abstract double MicrovoltsPerMicrosecondsInOneVoltPerSecond { get; } - protected abstract double MicrovoltsPerMinutesInOneVoltPerSecond { get; } - protected abstract double MicrovoltsPerSecondsInOneVoltPerSecond { get; } - protected abstract double MillivoltsPerHoursInOneVoltPerSecond { get; } - protected abstract double MillivoltsPerMicrosecondsInOneVoltPerSecond { get; } - protected abstract double MillivoltsPerMinutesInOneVoltPerSecond { get; } - protected abstract double MillivoltsPerSecondsInOneVoltPerSecond { get; } - protected abstract double VoltsPerHoursInOneVoltPerSecond { get; } - protected abstract double VoltsPerMicrosecondsInOneVoltPerSecond { get; } - protected abstract double VoltsPerMinutesInOneVoltPerSecond { get; } - protected abstract double VoltsPerSecondsInOneVoltPerSecond { get; } + protected abstract double KilovoltsPerHourInOneVoltPerSecond { get; } + protected abstract double KilovoltsPerMicrosecondInOneVoltPerSecond { get; } + protected abstract double KilovoltsPerMinuteInOneVoltPerSecond { get; } + protected abstract double KilovoltsPerSecondInOneVoltPerSecond { get; } + protected abstract double MegavoltsPerHourInOneVoltPerSecond { get; } + protected abstract double MegavoltsPerMicrosecondInOneVoltPerSecond { get; } + protected abstract double MegavoltsPerMinuteInOneVoltPerSecond { get; } + protected abstract double MegavoltsPerSecondInOneVoltPerSecond { get; } + protected abstract double MicrovoltsPerHourInOneVoltPerSecond { get; } + protected abstract double MicrovoltsPerMicrosecondInOneVoltPerSecond { get; } + protected abstract double MicrovoltsPerMinuteInOneVoltPerSecond { get; } + protected abstract double MicrovoltsPerSecondInOneVoltPerSecond { get; } + protected abstract double MillivoltsPerHourInOneVoltPerSecond { get; } + protected abstract double MillivoltsPerMicrosecondInOneVoltPerSecond { get; } + protected abstract double MillivoltsPerMinuteInOneVoltPerSecond { get; } + protected abstract double MillivoltsPerSecondInOneVoltPerSecond { get; } + protected abstract double VoltsPerHourInOneVoltPerSecond { get; } + protected abstract double VoltsPerMicrosecondInOneVoltPerSecond { get; } + protected abstract double VoltsPerMinuteInOneVoltPerSecond { get; } + protected abstract double VoltsPerSecondInOneVoltPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global - protected virtual double KilovoltsPerHoursTolerance { get { return 1e-5; } } - protected virtual double KilovoltsPerMicrosecondsTolerance { get { return 1e-5; } } - protected virtual double KilovoltsPerMinutesTolerance { get { return 1e-5; } } - protected virtual double KilovoltsPerSecondsTolerance { get { return 1e-5; } } - protected virtual double MegavoltsPerHoursTolerance { get { return 1e-5; } } - protected virtual double MegavoltsPerMicrosecondsTolerance { get { return 1e-5; } } - protected virtual double MegavoltsPerMinutesTolerance { get { return 1e-5; } } - protected virtual double MegavoltsPerSecondsTolerance { get { return 1e-5; } } - protected virtual double MicrovoltsPerHoursTolerance { get { return 1e-5; } } - protected virtual double MicrovoltsPerMicrosecondsTolerance { get { return 1e-5; } } - protected virtual double MicrovoltsPerMinutesTolerance { get { return 1e-5; } } - protected virtual double MicrovoltsPerSecondsTolerance { get { return 1e-5; } } - protected virtual double MillivoltsPerHoursTolerance { get { return 1e-5; } } - protected virtual double MillivoltsPerMicrosecondsTolerance { get { return 1e-5; } } - protected virtual double MillivoltsPerMinutesTolerance { get { return 1e-5; } } - protected virtual double MillivoltsPerSecondsTolerance { get { return 1e-5; } } - protected virtual double VoltsPerHoursTolerance { get { return 1e-5; } } - protected virtual double VoltsPerMicrosecondsTolerance { get { return 1e-5; } } - protected virtual double VoltsPerMinutesTolerance { get { return 1e-5; } } - protected virtual double VoltsPerSecondsTolerance { get { return 1e-5; } } + protected virtual double KilovoltsPerHourTolerance { get { return 1e-5; } } + protected virtual double KilovoltsPerMicrosecondTolerance { get { return 1e-5; } } + protected virtual double KilovoltsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double KilovoltsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MegavoltsPerHourTolerance { get { return 1e-5; } } + protected virtual double MegavoltsPerMicrosecondTolerance { get { return 1e-5; } } + protected virtual double MegavoltsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MegavoltsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MicrovoltsPerHourTolerance { get { return 1e-5; } } + protected virtual double MicrovoltsPerMicrosecondTolerance { get { return 1e-5; } } + protected virtual double MicrovoltsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MicrovoltsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MillivoltsPerHourTolerance { get { return 1e-5; } } + protected virtual double MillivoltsPerMicrosecondTolerance { get { return 1e-5; } } + protected virtual double MillivoltsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MillivoltsPerSecondTolerance { get { return 1e-5; } } + protected virtual double VoltsPerHourTolerance { get { return 1e-5; } } + protected virtual double VoltsPerMicrosecondTolerance { get { return 1e-5; } } + protected virtual double VoltsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double VoltsPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(ElectricPotentialChangeRateUnit unit) { return unit switch { - ElectricPotentialChangeRateUnit.KilovoltPerHour => (KilovoltsPerHoursInOneVoltPerSecond, KilovoltsPerHoursTolerance), - ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond => (KilovoltsPerMicrosecondsInOneVoltPerSecond, KilovoltsPerMicrosecondsTolerance), - ElectricPotentialChangeRateUnit.KilovoltPerMinute => (KilovoltsPerMinutesInOneVoltPerSecond, KilovoltsPerMinutesTolerance), - ElectricPotentialChangeRateUnit.KilovoltPerSecond => (KilovoltsPerSecondsInOneVoltPerSecond, KilovoltsPerSecondsTolerance), - ElectricPotentialChangeRateUnit.MegavoltPerHour => (MegavoltsPerHoursInOneVoltPerSecond, MegavoltsPerHoursTolerance), - ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond => (MegavoltsPerMicrosecondsInOneVoltPerSecond, MegavoltsPerMicrosecondsTolerance), - ElectricPotentialChangeRateUnit.MegavoltPerMinute => (MegavoltsPerMinutesInOneVoltPerSecond, MegavoltsPerMinutesTolerance), - ElectricPotentialChangeRateUnit.MegavoltPerSecond => (MegavoltsPerSecondsInOneVoltPerSecond, MegavoltsPerSecondsTolerance), - ElectricPotentialChangeRateUnit.MicrovoltPerHour => (MicrovoltsPerHoursInOneVoltPerSecond, MicrovoltsPerHoursTolerance), - ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond => (MicrovoltsPerMicrosecondsInOneVoltPerSecond, MicrovoltsPerMicrosecondsTolerance), - ElectricPotentialChangeRateUnit.MicrovoltPerMinute => (MicrovoltsPerMinutesInOneVoltPerSecond, MicrovoltsPerMinutesTolerance), - ElectricPotentialChangeRateUnit.MicrovoltPerSecond => (MicrovoltsPerSecondsInOneVoltPerSecond, MicrovoltsPerSecondsTolerance), - ElectricPotentialChangeRateUnit.MillivoltPerHour => (MillivoltsPerHoursInOneVoltPerSecond, MillivoltsPerHoursTolerance), - ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond => (MillivoltsPerMicrosecondsInOneVoltPerSecond, MillivoltsPerMicrosecondsTolerance), - ElectricPotentialChangeRateUnit.MillivoltPerMinute => (MillivoltsPerMinutesInOneVoltPerSecond, MillivoltsPerMinutesTolerance), - ElectricPotentialChangeRateUnit.MillivoltPerSecond => (MillivoltsPerSecondsInOneVoltPerSecond, MillivoltsPerSecondsTolerance), - ElectricPotentialChangeRateUnit.VoltPerHour => (VoltsPerHoursInOneVoltPerSecond, VoltsPerHoursTolerance), - ElectricPotentialChangeRateUnit.VoltPerMicrosecond => (VoltsPerMicrosecondsInOneVoltPerSecond, VoltsPerMicrosecondsTolerance), - ElectricPotentialChangeRateUnit.VoltPerMinute => (VoltsPerMinutesInOneVoltPerSecond, VoltsPerMinutesTolerance), - ElectricPotentialChangeRateUnit.VoltPerSecond => (VoltsPerSecondsInOneVoltPerSecond, VoltsPerSecondsTolerance), + ElectricPotentialChangeRateUnit.KilovoltPerHour => (KilovoltsPerHourInOneVoltPerSecond, KilovoltsPerHourTolerance), + ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond => (KilovoltsPerMicrosecondInOneVoltPerSecond, KilovoltsPerMicrosecondTolerance), + ElectricPotentialChangeRateUnit.KilovoltPerMinute => (KilovoltsPerMinuteInOneVoltPerSecond, KilovoltsPerMinuteTolerance), + ElectricPotentialChangeRateUnit.KilovoltPerSecond => (KilovoltsPerSecondInOneVoltPerSecond, KilovoltsPerSecondTolerance), + ElectricPotentialChangeRateUnit.MegavoltPerHour => (MegavoltsPerHourInOneVoltPerSecond, MegavoltsPerHourTolerance), + ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond => (MegavoltsPerMicrosecondInOneVoltPerSecond, MegavoltsPerMicrosecondTolerance), + ElectricPotentialChangeRateUnit.MegavoltPerMinute => (MegavoltsPerMinuteInOneVoltPerSecond, MegavoltsPerMinuteTolerance), + ElectricPotentialChangeRateUnit.MegavoltPerSecond => (MegavoltsPerSecondInOneVoltPerSecond, MegavoltsPerSecondTolerance), + ElectricPotentialChangeRateUnit.MicrovoltPerHour => (MicrovoltsPerHourInOneVoltPerSecond, MicrovoltsPerHourTolerance), + ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond => (MicrovoltsPerMicrosecondInOneVoltPerSecond, MicrovoltsPerMicrosecondTolerance), + ElectricPotentialChangeRateUnit.MicrovoltPerMinute => (MicrovoltsPerMinuteInOneVoltPerSecond, MicrovoltsPerMinuteTolerance), + ElectricPotentialChangeRateUnit.MicrovoltPerSecond => (MicrovoltsPerSecondInOneVoltPerSecond, MicrovoltsPerSecondTolerance), + ElectricPotentialChangeRateUnit.MillivoltPerHour => (MillivoltsPerHourInOneVoltPerSecond, MillivoltsPerHourTolerance), + ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond => (MillivoltsPerMicrosecondInOneVoltPerSecond, MillivoltsPerMicrosecondTolerance), + ElectricPotentialChangeRateUnit.MillivoltPerMinute => (MillivoltsPerMinuteInOneVoltPerSecond, MillivoltsPerMinuteTolerance), + ElectricPotentialChangeRateUnit.MillivoltPerSecond => (MillivoltsPerSecondInOneVoltPerSecond, MillivoltsPerSecondTolerance), + ElectricPotentialChangeRateUnit.VoltPerHour => (VoltsPerHourInOneVoltPerSecond, VoltsPerHourTolerance), + ElectricPotentialChangeRateUnit.VoltPerMicrosecond => (VoltsPerMicrosecondInOneVoltPerSecond, VoltsPerMicrosecondTolerance), + ElectricPotentialChangeRateUnit.VoltPerMinute => (VoltsPerMinuteInOneVoltPerSecond, VoltsPerMinuteTolerance), + ElectricPotentialChangeRateUnit.VoltPerSecond => (VoltsPerSecondInOneVoltPerSecond, VoltsPerSecondTolerance), _ => throw new NotSupportedException() }; } @@ -198,128 +198,128 @@ public void ElectricPotentialChangeRate_QuantityInfo_ReturnsQuantityInfoDescribi [Fact] public void VoltPerSecondToElectricPotentialChangeRateUnits() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - AssertEx.EqualTolerance(KilovoltsPerHoursInOneVoltPerSecond, voltpersecond.KilovoltsPerHours, KilovoltsPerHoursTolerance); - AssertEx.EqualTolerance(KilovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(KilovoltsPerMinutesInOneVoltPerSecond, voltpersecond.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(KilovoltsPerSecondsInOneVoltPerSecond, voltpersecond.KilovoltsPerSeconds, KilovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MegavoltsPerHoursInOneVoltPerSecond, voltpersecond.MegavoltsPerHours, MegavoltsPerHoursTolerance); - AssertEx.EqualTolerance(MegavoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.MegavoltsPerMicroseconds, MegavoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MegavoltsPerMinutesInOneVoltPerSecond, voltpersecond.MegavoltsPerMinutes, MegavoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MegavoltsPerSecondsInOneVoltPerSecond, voltpersecond.MegavoltsPerSeconds, MegavoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MicrovoltsPerHoursInOneVoltPerSecond, voltpersecond.MicrovoltsPerHours, MicrovoltsPerHoursTolerance); - AssertEx.EqualTolerance(MicrovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.MicrovoltsPerMicroseconds, MicrovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MicrovoltsPerMinutesInOneVoltPerSecond, voltpersecond.MicrovoltsPerMinutes, MicrovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MicrovoltsPerSecondsInOneVoltPerSecond, voltpersecond.MicrovoltsPerSeconds, MicrovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MillivoltsPerHoursInOneVoltPerSecond, voltpersecond.MillivoltsPerHours, MillivoltsPerHoursTolerance); - AssertEx.EqualTolerance(MillivoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.MillivoltsPerMicroseconds, MillivoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MillivoltsPerMinutesInOneVoltPerSecond, voltpersecond.MillivoltsPerMinutes, MillivoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MillivoltsPerSecondsInOneVoltPerSecond, voltpersecond.MillivoltsPerSeconds, MillivoltsPerSecondsTolerance); - AssertEx.EqualTolerance(VoltsPerHoursInOneVoltPerSecond, voltpersecond.VoltsPerHours, VoltsPerHoursTolerance); - AssertEx.EqualTolerance(VoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.VoltsPerMicroseconds, VoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(VoltsPerMinutesInOneVoltPerSecond, voltpersecond.VoltsPerMinutes, VoltsPerMinutesTolerance); - AssertEx.EqualTolerance(VoltsPerSecondsInOneVoltPerSecond, voltpersecond.VoltsPerSeconds, VoltsPerSecondsTolerance); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + AssertEx.EqualTolerance(KilovoltsPerHourInOneVoltPerSecond, voltpersecond.KilovoltsPerHour, KilovoltsPerHourTolerance); + AssertEx.EqualTolerance(KilovoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.KilovoltsPerMicrosecond, KilovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(KilovoltsPerMinuteInOneVoltPerSecond, voltpersecond.KilovoltsPerMinute, KilovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(KilovoltsPerSecondInOneVoltPerSecond, voltpersecond.KilovoltsPerSecond, KilovoltsPerSecondTolerance); + AssertEx.EqualTolerance(MegavoltsPerHourInOneVoltPerSecond, voltpersecond.MegavoltsPerHour, MegavoltsPerHourTolerance); + AssertEx.EqualTolerance(MegavoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.MegavoltsPerMicrosecond, MegavoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MegavoltsPerMinuteInOneVoltPerSecond, voltpersecond.MegavoltsPerMinute, MegavoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MegavoltsPerSecondInOneVoltPerSecond, voltpersecond.MegavoltsPerSecond, MegavoltsPerSecondTolerance); + AssertEx.EqualTolerance(MicrovoltsPerHourInOneVoltPerSecond, voltpersecond.MicrovoltsPerHour, MicrovoltsPerHourTolerance); + AssertEx.EqualTolerance(MicrovoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.MicrovoltsPerMicrosecond, MicrovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MicrovoltsPerMinuteInOneVoltPerSecond, voltpersecond.MicrovoltsPerMinute, MicrovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MicrovoltsPerSecondInOneVoltPerSecond, voltpersecond.MicrovoltsPerSecond, MicrovoltsPerSecondTolerance); + AssertEx.EqualTolerance(MillivoltsPerHourInOneVoltPerSecond, voltpersecond.MillivoltsPerHour, MillivoltsPerHourTolerance); + AssertEx.EqualTolerance(MillivoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.MillivoltsPerMicrosecond, MillivoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MillivoltsPerMinuteInOneVoltPerSecond, voltpersecond.MillivoltsPerMinute, MillivoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MillivoltsPerSecondInOneVoltPerSecond, voltpersecond.MillivoltsPerSecond, MillivoltsPerSecondTolerance); + AssertEx.EqualTolerance(VoltsPerHourInOneVoltPerSecond, voltpersecond.VoltsPerHour, VoltsPerHourTolerance); + AssertEx.EqualTolerance(VoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.VoltsPerMicrosecond, VoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(VoltsPerMinuteInOneVoltPerSecond, voltpersecond.VoltsPerMinute, VoltsPerMinuteTolerance); + AssertEx.EqualTolerance(VoltsPerSecondInOneVoltPerSecond, voltpersecond.VoltsPerSecond, VoltsPerSecondTolerance); } [Fact] public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { var quantity00 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerHour); - AssertEx.EqualTolerance(1, quantity00.KilovoltsPerHours, KilovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, quantity00.KilovoltsPerHour, KilovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerHour, quantity00.Unit); var quantity01 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); - AssertEx.EqualTolerance(1, quantity01.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, quantity01.KilovoltsPerMicrosecond, KilovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, quantity01.Unit); var quantity02 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerMinute); - AssertEx.EqualTolerance(1, quantity02.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity02.KilovoltsPerMinute, KilovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMinute, quantity02.Unit); var quantity03 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.KilovoltPerSecond); - AssertEx.EqualTolerance(1, quantity03.KilovoltsPerSeconds, KilovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, quantity03.KilovoltsPerSecond, KilovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerSecond, quantity03.Unit); var quantity04 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerHour); - AssertEx.EqualTolerance(1, quantity04.MegavoltsPerHours, MegavoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, quantity04.MegavoltsPerHour, MegavoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerHour, quantity04.Unit); var quantity05 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); - AssertEx.EqualTolerance(1, quantity05.MegavoltsPerMicroseconds, MegavoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, quantity05.MegavoltsPerMicrosecond, MegavoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, quantity05.Unit); var quantity06 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerMinute); - AssertEx.EqualTolerance(1, quantity06.MegavoltsPerMinutes, MegavoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity06.MegavoltsPerMinute, MegavoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMinute, quantity06.Unit); var quantity07 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MegavoltPerSecond); - AssertEx.EqualTolerance(1, quantity07.MegavoltsPerSeconds, MegavoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, quantity07.MegavoltsPerSecond, MegavoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerSecond, quantity07.Unit); var quantity08 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerHour); - AssertEx.EqualTolerance(1, quantity08.MicrovoltsPerHours, MicrovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, quantity08.MicrovoltsPerHour, MicrovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerHour, quantity08.Unit); var quantity09 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); - AssertEx.EqualTolerance(1, quantity09.MicrovoltsPerMicroseconds, MicrovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, quantity09.MicrovoltsPerMicrosecond, MicrovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, quantity09.Unit); var quantity10 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); - AssertEx.EqualTolerance(1, quantity10.MicrovoltsPerMinutes, MicrovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity10.MicrovoltsPerMinute, MicrovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, quantity10.Unit); var quantity11 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); - AssertEx.EqualTolerance(1, quantity11.MicrovoltsPerSeconds, MicrovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, quantity11.MicrovoltsPerSecond, MicrovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, quantity11.Unit); var quantity12 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerHour); - AssertEx.EqualTolerance(1, quantity12.MillivoltsPerHours, MillivoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, quantity12.MillivoltsPerHour, MillivoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerHour, quantity12.Unit); var quantity13 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); - AssertEx.EqualTolerance(1, quantity13.MillivoltsPerMicroseconds, MillivoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, quantity13.MillivoltsPerMicrosecond, MillivoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, quantity13.Unit); var quantity14 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerMinute); - AssertEx.EqualTolerance(1, quantity14.MillivoltsPerMinutes, MillivoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity14.MillivoltsPerMinute, MillivoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMinute, quantity14.Unit); var quantity15 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.MillivoltPerSecond); - AssertEx.EqualTolerance(1, quantity15.MillivoltsPerSeconds, MillivoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, quantity15.MillivoltsPerSecond, MillivoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerSecond, quantity15.Unit); var quantity16 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerHour); - AssertEx.EqualTolerance(1, quantity16.VoltsPerHours, VoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, quantity16.VoltsPerHour, VoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerHour, quantity16.Unit); var quantity17 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); - AssertEx.EqualTolerance(1, quantity17.VoltsPerMicroseconds, VoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, quantity17.VoltsPerMicrosecond, VoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, quantity17.Unit); var quantity18 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerMinute); - AssertEx.EqualTolerance(1, quantity18.VoltsPerMinutes, VoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity18.VoltsPerMinute, VoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMinute, quantity18.Unit); var quantity19 = ElectricPotentialChangeRate.From(1, ElectricPotentialChangeRateUnit.VoltPerSecond); - AssertEx.EqualTolerance(1, quantity19.VoltsPerSeconds, VoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, quantity19.VoltsPerSecond, VoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerSecond, quantity19.Unit); } [Fact] - public void FromVoltsPerSeconds_WithInfinityValue_DoNotThrowsArgumentException() + public void FromVoltsPerSecond_WithInfinityValue_DoNotThrowsArgumentException() { - var exception1 = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.PositiveInfinity)); - var exception2 = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.NegativeInfinity)); + var exception1 = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSecond(double.PositiveInfinity)); + var exception2 = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSecond(double.NegativeInfinity)); Assert.Null(exception1); Assert.Null(exception2); } [Fact] - public void FromVoltsPerSeconds_WithNanValue_DoNotThrowsArgumentException() + public void FromVoltsPerSecond_WithNanValue_DoNotThrowsArgumentException() { - var exception = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSeconds(double.NaN)); + var exception = Record.Exception(() => ElectricPotentialChangeRate.FromVoltsPerSecond(double.NaN)); Assert.Null(exception); } @@ -327,27 +327,27 @@ public void FromVoltsPerSeconds_WithNanValue_DoNotThrowsArgumentException() [Fact] public void As() { - var voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - AssertEx.EqualTolerance(KilovoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerHour), KilovoltsPerHoursTolerance); - AssertEx.EqualTolerance(KilovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond), KilovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(KilovoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMinute), KilovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(KilovoltsPerSecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerSecond), KilovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MegavoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerHour), MegavoltsPerHoursTolerance); - AssertEx.EqualTolerance(MegavoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond), MegavoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MegavoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerMinute), MegavoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MegavoltsPerSecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerSecond), MegavoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MicrovoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerHour), MicrovoltsPerHoursTolerance); - AssertEx.EqualTolerance(MicrovoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond), MicrovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MicrovoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute), MicrovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MicrovoltsPerSecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond), MicrovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(MillivoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerHour), MillivoltsPerHoursTolerance); - AssertEx.EqualTolerance(MillivoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond), MillivoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(MillivoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerMinute), MillivoltsPerMinutesTolerance); - AssertEx.EqualTolerance(MillivoltsPerSecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerSecond), MillivoltsPerSecondsTolerance); - AssertEx.EqualTolerance(VoltsPerHoursInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerHour), VoltsPerHoursTolerance); - AssertEx.EqualTolerance(VoltsPerMicrosecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond), VoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(VoltsPerMinutesInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerMinute), VoltsPerMinutesTolerance); - AssertEx.EqualTolerance(VoltsPerSecondsInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerSecond), VoltsPerSecondsTolerance); + var voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + AssertEx.EqualTolerance(KilovoltsPerHourInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerHour), KilovoltsPerHourTolerance); + AssertEx.EqualTolerance(KilovoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond), KilovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(KilovoltsPerMinuteInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerMinute), KilovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(KilovoltsPerSecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.KilovoltPerSecond), KilovoltsPerSecondTolerance); + AssertEx.EqualTolerance(MegavoltsPerHourInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerHour), MegavoltsPerHourTolerance); + AssertEx.EqualTolerance(MegavoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond), MegavoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MegavoltsPerMinuteInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerMinute), MegavoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MegavoltsPerSecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MegavoltPerSecond), MegavoltsPerSecondTolerance); + AssertEx.EqualTolerance(MicrovoltsPerHourInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerHour), MicrovoltsPerHourTolerance); + AssertEx.EqualTolerance(MicrovoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond), MicrovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MicrovoltsPerMinuteInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute), MicrovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MicrovoltsPerSecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond), MicrovoltsPerSecondTolerance); + AssertEx.EqualTolerance(MillivoltsPerHourInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerHour), MillivoltsPerHourTolerance); + AssertEx.EqualTolerance(MillivoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond), MillivoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(MillivoltsPerMinuteInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerMinute), MillivoltsPerMinuteTolerance); + AssertEx.EqualTolerance(MillivoltsPerSecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.MillivoltPerSecond), MillivoltsPerSecondTolerance); + AssertEx.EqualTolerance(VoltsPerHourInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerHour), VoltsPerHourTolerance); + AssertEx.EqualTolerance(VoltsPerMicrosecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond), VoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(VoltsPerMinuteInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerMinute), VoltsPerMinuteTolerance); + AssertEx.EqualTolerance(VoltsPerSecondInOneVoltPerSecond, voltpersecond.As(ElectricPotentialChangeRateUnit.VoltPerSecond), VoltsPerSecondTolerance); } [Fact] @@ -373,140 +373,140 @@ public void Parse() try { var parsed = ElectricPotentialChangeRate.Parse("1 kV/h", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerHours, KilovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerHour, KilovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerHour, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 kV/μs", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerMicrosecond, KilovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 kV/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerMinute, KilovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 kV/s", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerSeconds, KilovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerSecond, KilovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 MV/h", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MegavoltsPerHours, MegavoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.MegavoltsPerHour, MegavoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerHour, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 MV/μs", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MegavoltsPerMicroseconds, MegavoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MegavoltsPerMicrosecond, MegavoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 MV/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MegavoltsPerMinutes, MegavoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MegavoltsPerMinute, MegavoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 MV/s", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MegavoltsPerSeconds, MegavoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MegavoltsPerSecond, MegavoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MegavoltPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 µV/h", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerHours, MicrovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerHour, MicrovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerHour, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 µV/μs", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMicroseconds, MicrovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMicrosecond, MicrovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 µV/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMinutes, MicrovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMinute, MicrovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 µV/s", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerSeconds, MicrovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerSecond, MicrovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 mV/h", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillivoltsPerHours, MillivoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.MillivoltsPerHour, MillivoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerHour, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 mV/μs", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillivoltsPerMicroseconds, MillivoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MillivoltsPerMicrosecond, MillivoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 mV/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillivoltsPerMinutes, MillivoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MillivoltsPerMinute, MillivoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 mV/s", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillivoltsPerSeconds, MillivoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MillivoltsPerSecond, MillivoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MillivoltPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 V/h", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.VoltsPerHours, VoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerHour, VoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerHour, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 V/μs", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.VoltsPerMicroseconds, VoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerMicrosecond, VoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 V/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.VoltsPerMinutes, VoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerMinute, VoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = ElectricPotentialChangeRate.Parse("1 V/s", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.VoltsPerSeconds, VoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerSecond, VoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -517,73 +517,73 @@ public void TryParse() { { Assert.True(ElectricPotentialChangeRate.TryParse("1 kV/h", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerHours, KilovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerHour, KilovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerHour, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 kV/μs", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerMicroseconds, KilovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerMicrosecond, KilovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 kV/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerMinutes, KilovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerMinute, KilovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerMinute, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 kV/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilovoltsPerSeconds, KilovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.KilovoltsPerSecond, KilovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.KilovoltPerSecond, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 µV/h", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerHours, MicrovoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerHour, MicrovoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerHour, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 µV/μs", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMicroseconds, MicrovoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMicrosecond, MicrovoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 µV/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMinutes, MicrovoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerMinute, MicrovoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 µV/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrovoltsPerSeconds, MicrovoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.MicrovoltsPerSecond, MicrovoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 V/h", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.VoltsPerHours, VoltsPerHoursTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerHour, VoltsPerHourTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerHour, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 V/μs", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.VoltsPerMicroseconds, VoltsPerMicrosecondsTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerMicrosecond, VoltsPerMicrosecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 V/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.VoltsPerMinutes, VoltsPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerMinute, VoltsPerMinuteTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerMinute, parsed.Unit); } { Assert.True(ElectricPotentialChangeRate.TryParse("1 V/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.VoltsPerSeconds, VoltsPerSecondsTolerance); + AssertEx.EqualTolerance(1, parsed.VoltsPerSecond, VoltsPerSecondTolerance); Assert.Equal(ElectricPotentialChangeRateUnit.VoltPerSecond, parsed.Unit); } @@ -824,63 +824,63 @@ public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(Elec [Fact] public void ConversionRoundTrip() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerHours(voltpersecond.KilovoltsPerHours).VoltsPerSeconds, KilovoltsPerHoursTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMicroseconds(voltpersecond.KilovoltsPerMicroseconds).VoltsPerSeconds, KilovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMinutes(voltpersecond.KilovoltsPerMinutes).VoltsPerSeconds, KilovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerSeconds(voltpersecond.KilovoltsPerSeconds).VoltsPerSeconds, KilovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerHours(voltpersecond.MegavoltsPerHours).VoltsPerSeconds, MegavoltsPerHoursTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMicroseconds(voltpersecond.MegavoltsPerMicroseconds).VoltsPerSeconds, MegavoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMinutes(voltpersecond.MegavoltsPerMinutes).VoltsPerSeconds, MegavoltsPerMinutesTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerSeconds(voltpersecond.MegavoltsPerSeconds).VoltsPerSeconds, MegavoltsPerSecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerHours(voltpersecond.MicrovoltsPerHours).VoltsPerSeconds, MicrovoltsPerHoursTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMicroseconds(voltpersecond.MicrovoltsPerMicroseconds).VoltsPerSeconds, MicrovoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMinutes(voltpersecond.MicrovoltsPerMinutes).VoltsPerSeconds, MicrovoltsPerMinutesTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerSeconds(voltpersecond.MicrovoltsPerSeconds).VoltsPerSeconds, MicrovoltsPerSecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerHours(voltpersecond.MillivoltsPerHours).VoltsPerSeconds, MillivoltsPerHoursTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMicroseconds(voltpersecond.MillivoltsPerMicroseconds).VoltsPerSeconds, MillivoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMinutes(voltpersecond.MillivoltsPerMinutes).VoltsPerSeconds, MillivoltsPerMinutesTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerSeconds(voltpersecond.MillivoltsPerSeconds).VoltsPerSeconds, MillivoltsPerSecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerHours(voltpersecond.VoltsPerHours).VoltsPerSeconds, VoltsPerHoursTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMicroseconds(voltpersecond.VoltsPerMicroseconds).VoltsPerSeconds, VoltsPerMicrosecondsTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMinutes(voltpersecond.VoltsPerMinutes).VoltsPerSeconds, VoltsPerMinutesTolerance); - AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerSeconds(voltpersecond.VoltsPerSeconds).VoltsPerSeconds, VoltsPerSecondsTolerance); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerHour(voltpersecond.KilovoltsPerHour).VoltsPerSecond, KilovoltsPerHourTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(voltpersecond.KilovoltsPerMicrosecond).VoltsPerSecond, KilovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerMinute(voltpersecond.KilovoltsPerMinute).VoltsPerSecond, KilovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromKilovoltsPerSecond(voltpersecond.KilovoltsPerSecond).VoltsPerSecond, KilovoltsPerSecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerHour(voltpersecond.MegavoltsPerHour).VoltsPerSecond, MegavoltsPerHourTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(voltpersecond.MegavoltsPerMicrosecond).VoltsPerSecond, MegavoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerMinute(voltpersecond.MegavoltsPerMinute).VoltsPerSecond, MegavoltsPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMegavoltsPerSecond(voltpersecond.MegavoltsPerSecond).VoltsPerSecond, MegavoltsPerSecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerHour(voltpersecond.MicrovoltsPerHour).VoltsPerSecond, MicrovoltsPerHourTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(voltpersecond.MicrovoltsPerMicrosecond).VoltsPerSecond, MicrovoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerMinute(voltpersecond.MicrovoltsPerMinute).VoltsPerSecond, MicrovoltsPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMicrovoltsPerSecond(voltpersecond.MicrovoltsPerSecond).VoltsPerSecond, MicrovoltsPerSecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerHour(voltpersecond.MillivoltsPerHour).VoltsPerSecond, MillivoltsPerHourTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(voltpersecond.MillivoltsPerMicrosecond).VoltsPerSecond, MillivoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerMinute(voltpersecond.MillivoltsPerMinute).VoltsPerSecond, MillivoltsPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromMillivoltsPerSecond(voltpersecond.MillivoltsPerSecond).VoltsPerSecond, MillivoltsPerSecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerHour(voltpersecond.VoltsPerHour).VoltsPerSecond, VoltsPerHourTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMicrosecond(voltpersecond.VoltsPerMicrosecond).VoltsPerSecond, VoltsPerMicrosecondTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerMinute(voltpersecond.VoltsPerMinute).VoltsPerSecond, VoltsPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricPotentialChangeRate.FromVoltsPerSecond(voltpersecond.VoltsPerSecond).VoltsPerSecond, VoltsPerSecondTolerance); } [Fact] public void ArithmeticOperators() { - ElectricPotentialChangeRate v = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - AssertEx.EqualTolerance(-1, -v.VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSeconds(3)-v).VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(2, (v + v).VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(10, (v*10).VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(10, (10*v).VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSeconds(10)/5).VoltsPerSeconds, VoltsPerSecondsTolerance); - AssertEx.EqualTolerance(2, ElectricPotentialChangeRate.FromVoltsPerSeconds(10)/ElectricPotentialChangeRate.FromVoltsPerSeconds(5), VoltsPerSecondsTolerance); + ElectricPotentialChangeRate v = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + AssertEx.EqualTolerance(-1, -v.VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(3)-v).VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(2, (v + v).VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(10, (v*10).VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(10, (10*v).VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(2, (ElectricPotentialChangeRate.FromVoltsPerSecond(10)/5).VoltsPerSecond, VoltsPerSecondTolerance); + AssertEx.EqualTolerance(2, ElectricPotentialChangeRate.FromVoltsPerSecond(10)/ElectricPotentialChangeRate.FromVoltsPerSecond(5), VoltsPerSecondTolerance); } [Fact] public void ComparisonOperators() { - ElectricPotentialChangeRate oneVoltPerSecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - ElectricPotentialChangeRate twoVoltsPerSeconds = ElectricPotentialChangeRate.FromVoltsPerSeconds(2); + ElectricPotentialChangeRate oneVoltPerSecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + ElectricPotentialChangeRate twoVoltsPerSecond = ElectricPotentialChangeRate.FromVoltsPerSecond(2); - Assert.True(oneVoltPerSecond < twoVoltsPerSeconds); - Assert.True(oneVoltPerSecond <= twoVoltsPerSeconds); - Assert.True(twoVoltsPerSeconds > oneVoltPerSecond); - Assert.True(twoVoltsPerSeconds >= oneVoltPerSecond); + Assert.True(oneVoltPerSecond < twoVoltsPerSecond); + Assert.True(oneVoltPerSecond <= twoVoltsPerSecond); + Assert.True(twoVoltsPerSecond > oneVoltPerSecond); + Assert.True(twoVoltsPerSecond >= oneVoltPerSecond); - Assert.False(oneVoltPerSecond > twoVoltsPerSeconds); - Assert.False(oneVoltPerSecond >= twoVoltsPerSeconds); - Assert.False(twoVoltsPerSeconds < oneVoltPerSecond); - Assert.False(twoVoltsPerSeconds <= oneVoltPerSecond); + Assert.False(oneVoltPerSecond > twoVoltsPerSecond); + Assert.False(oneVoltPerSecond >= twoVoltsPerSecond); + Assert.False(twoVoltsPerSecond < oneVoltPerSecond); + Assert.False(twoVoltsPerSecond <= oneVoltPerSecond); } [Fact] public void CompareToIsImplemented() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); Assert.Equal(0, voltpersecond.CompareTo(voltpersecond)); Assert.True(voltpersecond.CompareTo(ElectricPotentialChangeRate.Zero) > 0); Assert.True(ElectricPotentialChangeRate.Zero.CompareTo(voltpersecond) < 0); @@ -889,14 +889,14 @@ public void CompareToIsImplemented() [Fact] public void CompareToThrowsOnTypeMismatch() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); Assert.Throws(() => voltpersecond.CompareTo(new object())); } [Fact] public void CompareToThrowsOnNull() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); Assert.Throws(() => voltpersecond.CompareTo(null)); } @@ -944,29 +944,29 @@ public void Equals_Null_ReturnsFalse() [Fact] public void Equals_RelativeTolerance_IsImplemented() { - var v = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - Assert.True(v.Equals(ElectricPotentialChangeRate.FromVoltsPerSeconds(1), VoltsPerSecondsTolerance, ComparisonType.Relative)); - Assert.False(v.Equals(ElectricPotentialChangeRate.Zero, VoltsPerSecondsTolerance, ComparisonType.Relative)); + var v = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + Assert.True(v.Equals(ElectricPotentialChangeRate.FromVoltsPerSecond(1), VoltsPerSecondTolerance, ComparisonType.Relative)); + Assert.False(v.Equals(ElectricPotentialChangeRate.Zero, VoltsPerSecondTolerance, ComparisonType.Relative)); } [Fact] public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException() { - var v = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); - Assert.Throws(() => v.Equals(ElectricPotentialChangeRate.FromVoltsPerSeconds(1), -1, ComparisonType.Relative)); + var v = ElectricPotentialChangeRate.FromVoltsPerSecond(1); + Assert.Throws(() => v.Equals(ElectricPotentialChangeRate.FromVoltsPerSecond(1), -1, ComparisonType.Relative)); } [Fact] public void EqualsReturnsFalseOnTypeMismatch() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); Assert.False(voltpersecond.Equals(new object())); } [Fact] public void EqualsReturnsFalseOnNull() { - ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSeconds(1); + ElectricPotentialChangeRate voltpersecond = ElectricPotentialChangeRate.FromVoltsPerSecond(1); Assert.False(voltpersecond.Equals(null)); } @@ -1080,7 +1080,7 @@ public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixFor [InlineData("en-US")] public void ToString_NullFormat_DefaultsToGeneralFormat(string cultureName) { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); CultureInfo formatProvider = cultureName == null ? null : CultureInfo.GetCultureInfo(cultureName); @@ -1093,154 +1093,154 @@ public void ToString_NullFormat_DefaultsToGeneralFormat(string cultureName) [InlineData("g")] public void ToString_NullProvider_EqualsCurrentCulture(string format) { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(quantity.ToString(format, CultureInfo.CurrentCulture), quantity.ToString(format, null)); } [Fact] public void Convert_ToBool_ThrowsInvalidCastException() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Throws(() => Convert.ToBoolean(quantity)); } [Fact] public void Convert_ToByte_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((byte)quantity.Value, Convert.ToByte(quantity)); } [Fact] public void Convert_ToChar_ThrowsInvalidCastException() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Throws(() => Convert.ToChar(quantity)); } [Fact] public void Convert_ToDateTime_ThrowsInvalidCastException() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Throws(() => Convert.ToDateTime(quantity)); } [Fact] public void Convert_ToDecimal_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); } [Fact] public void Convert_ToDouble_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity)); } [Fact] public void Convert_ToInt16_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity)); } [Fact] public void Convert_ToInt32_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity)); } [Fact] public void Convert_ToInt64_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity)); } [Fact] public void Convert_ToSByte_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity)); } [Fact] public void Convert_ToSingle_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity)); } [Fact] public void Convert_ToString_EqualsToString() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(quantity.ToString(), Convert.ToString(quantity)); } [Fact] public void Convert_ToUInt16_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity)); } [Fact] public void Convert_ToUInt32_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity)); } [Fact] public void Convert_ToUInt64_EqualsValueAsSameType() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); } [Fact] public void Convert_ChangeType_SelfType_EqualsSelf() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(ElectricPotentialChangeRate))); } [Fact] public void Convert_ChangeType_UnitType_EqualsUnit() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(ElectricPotentialChangeRateUnit))); } [Fact] public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(ElectricPotentialChangeRate.Info, Convert.ChangeType(quantity, typeof(QuantityInfo))); } [Fact] public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(ElectricPotentialChangeRate.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions))); } [Fact] public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Throws(() => Convert.ChangeType(quantity, typeof(QuantityFormatter))); } [Fact] public void GetHashCode_Equals() { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(1.0); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(1.0); Assert.Equal(new {ElectricPotentialChangeRate.Info.Name, quantity.Value, quantity.Unit}.GetHashCode(), quantity.GetHashCode()); } @@ -1249,8 +1249,8 @@ public void GetHashCode_Equals() [InlineData(-1.0)] public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) { - var quantity = ElectricPotentialChangeRate.FromVoltsPerSeconds(value); - Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSeconds(-value), -quantity); + var quantity = ElectricPotentialChangeRate.FromVoltsPerSecond(value); + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSecond(-value), -quantity); } } } diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs index 77bb51bdee..6f5a23ad6e 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FuelEfficiencyTestsBase.g.cs @@ -38,13 +38,13 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class FuelEfficiencyTestsBase : QuantityTestsBase { - protected abstract double KilometersPerLitersInOneLiterPer100Kilometers { get; } + protected abstract double KilometersPerLiterInOneLiterPer100Kilometers { get; } protected abstract double LitersPer100KilometersInOneLiterPer100Kilometers { get; } protected abstract double MilesPerUkGallonInOneLiterPer100Kilometers { get; } protected abstract double MilesPerUsGallonInOneLiterPer100Kilometers { get; } // ReSharper disable VirtualMemberNeverOverriden.Global - protected virtual double KilometersPerLitersTolerance { get { return 1e-5; } } + protected virtual double KilometersPerLiterTolerance { get { return 1e-5; } } protected virtual double LitersPer100KilometersTolerance { get { return 1e-5; } } protected virtual double MilesPerUkGallonTolerance { get { return 1e-5; } } protected virtual double MilesPerUsGallonTolerance { get { return 1e-5; } } @@ -54,7 +54,7 @@ public abstract partial class FuelEfficiencyTestsBase : QuantityTestsBase { return unit switch { - FuelEfficiencyUnit.KilometerPerLiter => (KilometersPerLitersInOneLiterPer100Kilometers, KilometersPerLitersTolerance), + FuelEfficiencyUnit.KilometerPerLiter => (KilometersPerLiterInOneLiterPer100Kilometers, KilometersPerLiterTolerance), FuelEfficiencyUnit.LiterPer100Kilometers => (LitersPer100KilometersInOneLiterPer100Kilometers, LitersPer100KilometersTolerance), FuelEfficiencyUnit.MilePerUkGallon => (MilesPerUkGallonInOneLiterPer100Kilometers, MilesPerUkGallonTolerance), FuelEfficiencyUnit.MilePerUsGallon => (MilesPerUsGallonInOneLiterPer100Kilometers, MilesPerUsGallonTolerance), @@ -135,7 +135,7 @@ public void FuelEfficiency_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() public void LiterPer100KilometersToFuelEfficiencyUnits() { FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1); - AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.KilometersPerLiters, KilometersPerLitersTolerance); + AssertEx.EqualTolerance(KilometersPerLiterInOneLiterPer100Kilometers, literper100kilometers.KilometersPerLiter, KilometersPerLiterTolerance); AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.LitersPer100Kilometers, LitersPer100KilometersTolerance); AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.MilesPerUkGallon, MilesPerUkGallonTolerance); AssertEx.EqualTolerance(MilesPerUsGallonInOneLiterPer100Kilometers, literper100kilometers.MilesPerUsGallon, MilesPerUsGallonTolerance); @@ -145,7 +145,7 @@ public void LiterPer100KilometersToFuelEfficiencyUnits() public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { var quantity00 = FuelEfficiency.From(1, FuelEfficiencyUnit.KilometerPerLiter); - AssertEx.EqualTolerance(1, quantity00.KilometersPerLiters, KilometersPerLitersTolerance); + AssertEx.EqualTolerance(1, quantity00.KilometersPerLiter, KilometersPerLiterTolerance); Assert.Equal(FuelEfficiencyUnit.KilometerPerLiter, quantity00.Unit); var quantity01 = FuelEfficiency.From(1, FuelEfficiencyUnit.LiterPer100Kilometers); @@ -184,7 +184,7 @@ public void FromLitersPer100Kilometers_WithNanValue_DoNotThrowsArgumentException public void As() { var literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1); - AssertEx.EqualTolerance(KilometersPerLitersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.KilometerPerLiter), KilometersPerLitersTolerance); + AssertEx.EqualTolerance(KilometersPerLiterInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.KilometerPerLiter), KilometersPerLiterTolerance); AssertEx.EqualTolerance(LitersPer100KilometersInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.LiterPer100Kilometers), LitersPer100KilometersTolerance); AssertEx.EqualTolerance(MilesPerUkGallonInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.MilePerUkGallon), MilesPerUkGallonTolerance); AssertEx.EqualTolerance(MilesPerUsGallonInOneLiterPer100Kilometers, literper100kilometers.As(FuelEfficiencyUnit.MilePerUsGallon), MilesPerUsGallonTolerance); @@ -213,7 +213,7 @@ public void Parse() try { var parsed = FuelEfficiency.Parse("1 km/L", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilometersPerLiters, KilometersPerLitersTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerLiter, KilometersPerLiterTolerance); Assert.Equal(FuelEfficiencyUnit.KilometerPerLiter, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -245,7 +245,7 @@ public void TryParse() { { Assert.True(FuelEfficiency.TryParse("1 km/L", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilometersPerLiters, KilometersPerLitersTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerLiter, KilometersPerLiterTolerance); Assert.Equal(FuelEfficiencyUnit.KilometerPerLiter, parsed.Unit); } @@ -369,7 +369,7 @@ public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(Fuel public void ConversionRoundTrip() { FuelEfficiency literper100kilometers = FuelEfficiency.FromLitersPer100Kilometers(1); - AssertEx.EqualTolerance(1, FuelEfficiency.FromKilometersPerLiters(literper100kilometers.KilometersPerLiters).LitersPer100Kilometers, KilometersPerLitersTolerance); + AssertEx.EqualTolerance(1, FuelEfficiency.FromKilometersPerLiter(literper100kilometers.KilometersPerLiter).LitersPer100Kilometers, KilometersPerLiterTolerance); AssertEx.EqualTolerance(1, FuelEfficiency.FromLitersPer100Kilometers(literper100kilometers.LitersPer100Kilometers).LitersPer100Kilometers, LitersPer100KilometersTolerance); AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUkGallon(literper100kilometers.MilesPerUkGallon).LitersPer100Kilometers, MilesPerUkGallonTolerance); AssertEx.EqualTolerance(1, FuelEfficiency.FromMilesPerUsGallon(literper100kilometers.MilesPerUsGallon).LitersPer100Kilometers, MilesPerUsGallonTolerance); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs index a0e160fa42..d8e25872a8 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/SpeedTestsBase.g.cs @@ -39,9 +39,9 @@ namespace UnitsNet.Tests public abstract partial class SpeedTestsBase : QuantityTestsBase { protected abstract double CentimetersPerHourInOneMeterPerSecond { get; } - protected abstract double CentimetersPerMinutesInOneMeterPerSecond { get; } + protected abstract double CentimetersPerMinuteInOneMeterPerSecond { get; } protected abstract double CentimetersPerSecondInOneMeterPerSecond { get; } - protected abstract double DecimetersPerMinutesInOneMeterPerSecond { get; } + protected abstract double DecimetersPerMinuteInOneMeterPerSecond { get; } protected abstract double DecimetersPerSecondInOneMeterPerSecond { get; } protected abstract double FeetPerHourInOneMeterPerSecond { get; } protected abstract double FeetPerMinuteInOneMeterPerSecond { get; } @@ -50,20 +50,20 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase protected abstract double InchesPerMinuteInOneMeterPerSecond { get; } protected abstract double InchesPerSecondInOneMeterPerSecond { get; } protected abstract double KilometersPerHourInOneMeterPerSecond { get; } - protected abstract double KilometersPerMinutesInOneMeterPerSecond { get; } + protected abstract double KilometersPerMinuteInOneMeterPerSecond { get; } protected abstract double KilometersPerSecondInOneMeterPerSecond { get; } protected abstract double KnotsInOneMeterPerSecond { get; } protected abstract double MachInOneMeterPerSecond { get; } protected abstract double MetersPerHourInOneMeterPerSecond { get; } - protected abstract double MetersPerMinutesInOneMeterPerSecond { get; } + protected abstract double MetersPerMinuteInOneMeterPerSecond { get; } protected abstract double MetersPerSecondInOneMeterPerSecond { get; } - protected abstract double MicrometersPerMinutesInOneMeterPerSecond { get; } + protected abstract double MicrometersPerMinuteInOneMeterPerSecond { get; } protected abstract double MicrometersPerSecondInOneMeterPerSecond { get; } protected abstract double MilesPerHourInOneMeterPerSecond { get; } protected abstract double MillimetersPerHourInOneMeterPerSecond { get; } - protected abstract double MillimetersPerMinutesInOneMeterPerSecond { get; } + protected abstract double MillimetersPerMinuteInOneMeterPerSecond { get; } protected abstract double MillimetersPerSecondInOneMeterPerSecond { get; } - protected abstract double NanometersPerMinutesInOneMeterPerSecond { get; } + protected abstract double NanometersPerMinuteInOneMeterPerSecond { get; } protected abstract double NanometersPerSecondInOneMeterPerSecond { get; } protected abstract double UsSurveyFeetPerHourInOneMeterPerSecond { get; } protected abstract double UsSurveyFeetPerMinuteInOneMeterPerSecond { get; } @@ -74,9 +74,9 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentimetersPerHourTolerance { get { return 1e-5; } } - protected virtual double CentimetersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double CentimetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double CentimetersPerSecondTolerance { get { return 1e-5; } } - protected virtual double DecimetersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double DecimetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double DecimetersPerSecondTolerance { get { return 1e-5; } } protected virtual double FeetPerHourTolerance { get { return 1e-5; } } protected virtual double FeetPerMinuteTolerance { get { return 1e-5; } } @@ -85,20 +85,20 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase protected virtual double InchesPerMinuteTolerance { get { return 1e-5; } } protected virtual double InchesPerSecondTolerance { get { return 1e-5; } } protected virtual double KilometersPerHourTolerance { get { return 1e-5; } } - protected virtual double KilometersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double KilometersPerMinuteTolerance { get { return 1e-5; } } protected virtual double KilometersPerSecondTolerance { get { return 1e-5; } } protected virtual double KnotsTolerance { get { return 1e-5; } } protected virtual double MachTolerance { get { return 1e-5; } } protected virtual double MetersPerHourTolerance { get { return 1e-5; } } - protected virtual double MetersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double MetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double MetersPerSecondTolerance { get { return 1e-5; } } - protected virtual double MicrometersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double MicrometersPerMinuteTolerance { get { return 1e-5; } } protected virtual double MicrometersPerSecondTolerance { get { return 1e-5; } } protected virtual double MilesPerHourTolerance { get { return 1e-5; } } protected virtual double MillimetersPerHourTolerance { get { return 1e-5; } } - protected virtual double MillimetersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double MillimetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double MillimetersPerSecondTolerance { get { return 1e-5; } } - protected virtual double NanometersPerMinutesTolerance { get { return 1e-5; } } + protected virtual double NanometersPerMinuteTolerance { get { return 1e-5; } } protected virtual double NanometersPerSecondTolerance { get { return 1e-5; } } protected virtual double UsSurveyFeetPerHourTolerance { get { return 1e-5; } } protected virtual double UsSurveyFeetPerMinuteTolerance { get { return 1e-5; } } @@ -113,9 +113,9 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase return unit switch { SpeedUnit.CentimeterPerHour => (CentimetersPerHourInOneMeterPerSecond, CentimetersPerHourTolerance), - SpeedUnit.CentimeterPerMinute => (CentimetersPerMinutesInOneMeterPerSecond, CentimetersPerMinutesTolerance), + SpeedUnit.CentimeterPerMinute => (CentimetersPerMinuteInOneMeterPerSecond, CentimetersPerMinuteTolerance), SpeedUnit.CentimeterPerSecond => (CentimetersPerSecondInOneMeterPerSecond, CentimetersPerSecondTolerance), - SpeedUnit.DecimeterPerMinute => (DecimetersPerMinutesInOneMeterPerSecond, DecimetersPerMinutesTolerance), + SpeedUnit.DecimeterPerMinute => (DecimetersPerMinuteInOneMeterPerSecond, DecimetersPerMinuteTolerance), SpeedUnit.DecimeterPerSecond => (DecimetersPerSecondInOneMeterPerSecond, DecimetersPerSecondTolerance), SpeedUnit.FootPerHour => (FeetPerHourInOneMeterPerSecond, FeetPerHourTolerance), SpeedUnit.FootPerMinute => (FeetPerMinuteInOneMeterPerSecond, FeetPerMinuteTolerance), @@ -124,20 +124,20 @@ public abstract partial class SpeedTestsBase : QuantityTestsBase SpeedUnit.InchPerMinute => (InchesPerMinuteInOneMeterPerSecond, InchesPerMinuteTolerance), SpeedUnit.InchPerSecond => (InchesPerSecondInOneMeterPerSecond, InchesPerSecondTolerance), SpeedUnit.KilometerPerHour => (KilometersPerHourInOneMeterPerSecond, KilometersPerHourTolerance), - SpeedUnit.KilometerPerMinute => (KilometersPerMinutesInOneMeterPerSecond, KilometersPerMinutesTolerance), + SpeedUnit.KilometerPerMinute => (KilometersPerMinuteInOneMeterPerSecond, KilometersPerMinuteTolerance), SpeedUnit.KilometerPerSecond => (KilometersPerSecondInOneMeterPerSecond, KilometersPerSecondTolerance), SpeedUnit.Knot => (KnotsInOneMeterPerSecond, KnotsTolerance), SpeedUnit.Mach => (MachInOneMeterPerSecond, MachTolerance), SpeedUnit.MeterPerHour => (MetersPerHourInOneMeterPerSecond, MetersPerHourTolerance), - SpeedUnit.MeterPerMinute => (MetersPerMinutesInOneMeterPerSecond, MetersPerMinutesTolerance), + SpeedUnit.MeterPerMinute => (MetersPerMinuteInOneMeterPerSecond, MetersPerMinuteTolerance), SpeedUnit.MeterPerSecond => (MetersPerSecondInOneMeterPerSecond, MetersPerSecondTolerance), - SpeedUnit.MicrometerPerMinute => (MicrometersPerMinutesInOneMeterPerSecond, MicrometersPerMinutesTolerance), + SpeedUnit.MicrometerPerMinute => (MicrometersPerMinuteInOneMeterPerSecond, MicrometersPerMinuteTolerance), SpeedUnit.MicrometerPerSecond => (MicrometersPerSecondInOneMeterPerSecond, MicrometersPerSecondTolerance), SpeedUnit.MilePerHour => (MilesPerHourInOneMeterPerSecond, MilesPerHourTolerance), SpeedUnit.MillimeterPerHour => (MillimetersPerHourInOneMeterPerSecond, MillimetersPerHourTolerance), - SpeedUnit.MillimeterPerMinute => (MillimetersPerMinutesInOneMeterPerSecond, MillimetersPerMinutesTolerance), + SpeedUnit.MillimeterPerMinute => (MillimetersPerMinuteInOneMeterPerSecond, MillimetersPerMinuteTolerance), SpeedUnit.MillimeterPerSecond => (MillimetersPerSecondInOneMeterPerSecond, MillimetersPerSecondTolerance), - SpeedUnit.NanometerPerMinute => (NanometersPerMinutesInOneMeterPerSecond, NanometersPerMinutesTolerance), + SpeedUnit.NanometerPerMinute => (NanometersPerMinuteInOneMeterPerSecond, NanometersPerMinuteTolerance), SpeedUnit.NanometerPerSecond => (NanometersPerSecondInOneMeterPerSecond, NanometersPerSecondTolerance), SpeedUnit.UsSurveyFootPerHour => (UsSurveyFeetPerHourInOneMeterPerSecond, UsSurveyFeetPerHourTolerance), SpeedUnit.UsSurveyFootPerMinute => (UsSurveyFeetPerMinuteInOneMeterPerSecond, UsSurveyFeetPerMinuteTolerance), @@ -252,9 +252,9 @@ public void MeterPerSecondToSpeedUnits() { Speed meterpersecond = Speed.FromMetersPerSecond(1); AssertEx.EqualTolerance(CentimetersPerHourInOneMeterPerSecond, meterpersecond.CentimetersPerHour, CentimetersPerHourTolerance); - AssertEx.EqualTolerance(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(CentimetersPerMinuteInOneMeterPerSecond, meterpersecond.CentimetersPerMinute, CentimetersPerMinuteTolerance); AssertEx.EqualTolerance(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.CentimetersPerSecond, CentimetersPerSecondTolerance); - AssertEx.EqualTolerance(DecimetersPerMinutesInOneMeterPerSecond, meterpersecond.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(DecimetersPerMinuteInOneMeterPerSecond, meterpersecond.DecimetersPerMinute, DecimetersPerMinuteTolerance); AssertEx.EqualTolerance(DecimetersPerSecondInOneMeterPerSecond, meterpersecond.DecimetersPerSecond, DecimetersPerSecondTolerance); AssertEx.EqualTolerance(FeetPerHourInOneMeterPerSecond, meterpersecond.FeetPerHour, FeetPerHourTolerance); AssertEx.EqualTolerance(FeetPerMinuteInOneMeterPerSecond, meterpersecond.FeetPerMinute, FeetPerMinuteTolerance); @@ -263,20 +263,20 @@ public void MeterPerSecondToSpeedUnits() AssertEx.EqualTolerance(InchesPerMinuteInOneMeterPerSecond, meterpersecond.InchesPerMinute, InchesPerMinuteTolerance); AssertEx.EqualTolerance(InchesPerSecondInOneMeterPerSecond, meterpersecond.InchesPerSecond, InchesPerSecondTolerance); AssertEx.EqualTolerance(KilometersPerHourInOneMeterPerSecond, meterpersecond.KilometersPerHour, KilometersPerHourTolerance); - AssertEx.EqualTolerance(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(KilometersPerMinuteInOneMeterPerSecond, meterpersecond.KilometersPerMinute, KilometersPerMinuteTolerance); AssertEx.EqualTolerance(KilometersPerSecondInOneMeterPerSecond, meterpersecond.KilometersPerSecond, KilometersPerSecondTolerance); AssertEx.EqualTolerance(KnotsInOneMeterPerSecond, meterpersecond.Knots, KnotsTolerance); AssertEx.EqualTolerance(MachInOneMeterPerSecond, meterpersecond.Mach, MachTolerance); AssertEx.EqualTolerance(MetersPerHourInOneMeterPerSecond, meterpersecond.MetersPerHour, MetersPerHourTolerance); - AssertEx.EqualTolerance(MetersPerMinutesInOneMeterPerSecond, meterpersecond.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(MetersPerMinuteInOneMeterPerSecond, meterpersecond.MetersPerMinute, MetersPerMinuteTolerance); AssertEx.EqualTolerance(MetersPerSecondInOneMeterPerSecond, meterpersecond.MetersPerSecond, MetersPerSecondTolerance); - AssertEx.EqualTolerance(MicrometersPerMinutesInOneMeterPerSecond, meterpersecond.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(MicrometersPerMinuteInOneMeterPerSecond, meterpersecond.MicrometersPerMinute, MicrometersPerMinuteTolerance); AssertEx.EqualTolerance(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.MicrometersPerSecond, MicrometersPerSecondTolerance); AssertEx.EqualTolerance(MilesPerHourInOneMeterPerSecond, meterpersecond.MilesPerHour, MilesPerHourTolerance); AssertEx.EqualTolerance(MillimetersPerHourInOneMeterPerSecond, meterpersecond.MillimetersPerHour, MillimetersPerHourTolerance); - AssertEx.EqualTolerance(MillimetersPerMinutesInOneMeterPerSecond, meterpersecond.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(MillimetersPerMinuteInOneMeterPerSecond, meterpersecond.MillimetersPerMinute, MillimetersPerMinuteTolerance); AssertEx.EqualTolerance(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.MillimetersPerSecond, MillimetersPerSecondTolerance); - AssertEx.EqualTolerance(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(NanometersPerMinuteInOneMeterPerSecond, meterpersecond.NanometersPerMinute, NanometersPerMinuteTolerance); AssertEx.EqualTolerance(NanometersPerSecondInOneMeterPerSecond, meterpersecond.NanometersPerSecond, NanometersPerSecondTolerance); AssertEx.EqualTolerance(UsSurveyFeetPerHourInOneMeterPerSecond, meterpersecond.UsSurveyFeetPerHour, UsSurveyFeetPerHourTolerance); AssertEx.EqualTolerance(UsSurveyFeetPerMinuteInOneMeterPerSecond, meterpersecond.UsSurveyFeetPerMinute, UsSurveyFeetPerMinuteTolerance); @@ -294,7 +294,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.CentimeterPerHour, quantity00.Unit); var quantity01 = Speed.From(1, SpeedUnit.CentimeterPerMinute); - AssertEx.EqualTolerance(1, quantity01.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity01.CentimetersPerMinute, CentimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.CentimeterPerMinute, quantity01.Unit); var quantity02 = Speed.From(1, SpeedUnit.CentimeterPerSecond); @@ -302,7 +302,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.CentimeterPerSecond, quantity02.Unit); var quantity03 = Speed.From(1, SpeedUnit.DecimeterPerMinute); - AssertEx.EqualTolerance(1, quantity03.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity03.DecimetersPerMinute, DecimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.DecimeterPerMinute, quantity03.Unit); var quantity04 = Speed.From(1, SpeedUnit.DecimeterPerSecond); @@ -338,7 +338,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.KilometerPerHour, quantity11.Unit); var quantity12 = Speed.From(1, SpeedUnit.KilometerPerMinute); - AssertEx.EqualTolerance(1, quantity12.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity12.KilometersPerMinute, KilometersPerMinuteTolerance); Assert.Equal(SpeedUnit.KilometerPerMinute, quantity12.Unit); var quantity13 = Speed.From(1, SpeedUnit.KilometerPerSecond); @@ -358,7 +358,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.MeterPerHour, quantity16.Unit); var quantity17 = Speed.From(1, SpeedUnit.MeterPerMinute); - AssertEx.EqualTolerance(1, quantity17.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity17.MetersPerMinute, MetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MeterPerMinute, quantity17.Unit); var quantity18 = Speed.From(1, SpeedUnit.MeterPerSecond); @@ -366,7 +366,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.MeterPerSecond, quantity18.Unit); var quantity19 = Speed.From(1, SpeedUnit.MicrometerPerMinute); - AssertEx.EqualTolerance(1, quantity19.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity19.MicrometersPerMinute, MicrometersPerMinuteTolerance); Assert.Equal(SpeedUnit.MicrometerPerMinute, quantity19.Unit); var quantity20 = Speed.From(1, SpeedUnit.MicrometerPerSecond); @@ -382,7 +382,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.MillimeterPerHour, quantity22.Unit); var quantity23 = Speed.From(1, SpeedUnit.MillimeterPerMinute); - AssertEx.EqualTolerance(1, quantity23.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity23.MillimetersPerMinute, MillimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MillimeterPerMinute, quantity23.Unit); var quantity24 = Speed.From(1, SpeedUnit.MillimeterPerSecond); @@ -390,7 +390,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(SpeedUnit.MillimeterPerSecond, quantity24.Unit); var quantity25 = Speed.From(1, SpeedUnit.NanometerPerMinute); - AssertEx.EqualTolerance(1, quantity25.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, quantity25.NanometersPerMinute, NanometersPerMinuteTolerance); Assert.Equal(SpeedUnit.NanometerPerMinute, quantity25.Unit); var quantity26 = Speed.From(1, SpeedUnit.NanometerPerSecond); @@ -446,9 +446,9 @@ public void As() { var meterpersecond = Speed.FromMetersPerSecond(1); AssertEx.EqualTolerance(CentimetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerHour), CentimetersPerHourTolerance); - AssertEx.EqualTolerance(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerMinute), CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(CentimetersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerMinute), CentimetersPerMinuteTolerance); AssertEx.EqualTolerance(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerSecond), CentimetersPerSecondTolerance); - AssertEx.EqualTolerance(DecimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.DecimeterPerMinute), DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(DecimetersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.DecimeterPerMinute), DecimetersPerMinuteTolerance); AssertEx.EqualTolerance(DecimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.DecimeterPerSecond), DecimetersPerSecondTolerance); AssertEx.EqualTolerance(FeetPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.FootPerHour), FeetPerHourTolerance); AssertEx.EqualTolerance(FeetPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.FootPerMinute), FeetPerMinuteTolerance); @@ -457,20 +457,20 @@ public void As() AssertEx.EqualTolerance(InchesPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.InchPerMinute), InchesPerMinuteTolerance); AssertEx.EqualTolerance(InchesPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.InchPerSecond), InchesPerSecondTolerance); AssertEx.EqualTolerance(KilometersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerHour), KilometersPerHourTolerance); - AssertEx.EqualTolerance(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerMinute), KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(KilometersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerMinute), KilometersPerMinuteTolerance); AssertEx.EqualTolerance(KilometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerSecond), KilometersPerSecondTolerance); AssertEx.EqualTolerance(KnotsInOneMeterPerSecond, meterpersecond.As(SpeedUnit.Knot), KnotsTolerance); AssertEx.EqualTolerance(MachInOneMeterPerSecond, meterpersecond.As(SpeedUnit.Mach), MachTolerance); AssertEx.EqualTolerance(MetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerHour), MetersPerHourTolerance); - AssertEx.EqualTolerance(MetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerMinute), MetersPerMinutesTolerance); + AssertEx.EqualTolerance(MetersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerMinute), MetersPerMinuteTolerance); AssertEx.EqualTolerance(MetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerSecond), MetersPerSecondTolerance); - AssertEx.EqualTolerance(MicrometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerMinute), MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(MicrometersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerMinute), MicrometersPerMinuteTolerance); AssertEx.EqualTolerance(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerSecond), MicrometersPerSecondTolerance); AssertEx.EqualTolerance(MilesPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MilePerHour), MilesPerHourTolerance); AssertEx.EqualTolerance(MillimetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerHour), MillimetersPerHourTolerance); - AssertEx.EqualTolerance(MillimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerMinute), MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(MillimetersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerMinute), MillimetersPerMinuteTolerance); AssertEx.EqualTolerance(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerSecond), MillimetersPerSecondTolerance); - AssertEx.EqualTolerance(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerMinute), NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(NanometersPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerMinute), NanometersPerMinuteTolerance); AssertEx.EqualTolerance(NanometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerSecond), NanometersPerSecondTolerance); AssertEx.EqualTolerance(UsSurveyFeetPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.UsSurveyFootPerHour), UsSurveyFeetPerHourTolerance); AssertEx.EqualTolerance(UsSurveyFeetPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.UsSurveyFootPerMinute), UsSurveyFeetPerMinuteTolerance); @@ -517,14 +517,14 @@ public void Parse() try { var parsed = Speed.Parse("1 cm/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.CentimetersPerMinute, CentimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.CentimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 см/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.CentimetersPerMinute, CentimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.CentimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -545,14 +545,14 @@ public void Parse() try { var parsed = Speed.Parse("1 dm/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.DecimetersPerMinute, DecimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.DecimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 дм/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.DecimetersPerMinute, DecimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.DecimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -650,14 +650,14 @@ public void Parse() try { var parsed = Speed.Parse("1 km/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerMinute, KilometersPerMinuteTolerance); Assert.Equal(SpeedUnit.KilometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 км/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerMinute, KilometersPerMinuteTolerance); Assert.Equal(SpeedUnit.KilometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -762,14 +762,14 @@ public void Parse() try { var parsed = Speed.Parse("1 m/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MetersPerMinute, MetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 м/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MetersPerMinute, MetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -790,14 +790,14 @@ public void Parse() try { var parsed = Speed.Parse("1 µm/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrometersPerMinute, MicrometersPerMinuteTolerance); Assert.Equal(SpeedUnit.MicrometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 мкм/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrometersPerMinute, MicrometersPerMinuteTolerance); Assert.Equal(SpeedUnit.MicrometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -846,14 +846,14 @@ public void Parse() try { var parsed = Speed.Parse("1 mm/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MillimetersPerMinute, MillimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MillimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 мм/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MillimetersPerMinute, MillimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MillimeterPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -874,14 +874,14 @@ public void Parse() try { var parsed = Speed.Parse("1 nm/min", CultureInfo.GetCultureInfo("en-US")); - AssertEx.EqualTolerance(1, parsed.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.NanometersPerMinute, NanometersPerMinuteTolerance); Assert.Equal(SpeedUnit.NanometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } try { var parsed = Speed.Parse("1 нм/мин", CultureInfo.GetCultureInfo("ru-RU")); - AssertEx.EqualTolerance(1, parsed.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.NanometersPerMinute, NanometersPerMinuteTolerance); Assert.Equal(SpeedUnit.NanometerPerMinute, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } @@ -960,13 +960,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 cm/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.CentimetersPerMinute, CentimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.CentimeterPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 см/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.CentimetersPerMinutes, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.CentimetersPerMinute, CentimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.CentimeterPerMinute, parsed.Unit); } @@ -984,13 +984,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 dm/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.DecimetersPerMinute, DecimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.DecimeterPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 дм/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.DecimetersPerMinutes, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.DecimetersPerMinute, DecimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.DecimeterPerMinute, parsed.Unit); } @@ -1074,13 +1074,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 km/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerMinute, KilometersPerMinuteTolerance); Assert.Equal(SpeedUnit.KilometerPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 км/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.KilometersPerMinutes, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.KilometersPerMinute, KilometersPerMinuteTolerance); Assert.Equal(SpeedUnit.KilometerPerMinute, parsed.Unit); } @@ -1170,13 +1170,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 m/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MetersPerMinute, MetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MeterPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 м/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MetersPerMinutes, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MetersPerMinute, MetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MeterPerMinute, parsed.Unit); } @@ -1194,13 +1194,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 µm/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrometersPerMinute, MicrometersPerMinuteTolerance); Assert.Equal(SpeedUnit.MicrometerPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 мкм/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MicrometersPerMinutes, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MicrometersPerMinute, MicrometersPerMinuteTolerance); Assert.Equal(SpeedUnit.MicrometerPerMinute, parsed.Unit); } @@ -1242,13 +1242,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 mm/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MillimetersPerMinute, MillimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MillimeterPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 мм/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.MillimetersPerMinutes, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.MillimetersPerMinute, MillimetersPerMinuteTolerance); Assert.Equal(SpeedUnit.MillimeterPerMinute, parsed.Unit); } @@ -1266,13 +1266,13 @@ public void TryParse() { Assert.True(Speed.TryParse("1 nm/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.NanometersPerMinute, NanometersPerMinuteTolerance); Assert.Equal(SpeedUnit.NanometerPerMinute, parsed.Unit); } { Assert.True(Speed.TryParse("1 нм/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); - AssertEx.EqualTolerance(1, parsed.NanometersPerMinutes, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, parsed.NanometersPerMinute, NanometersPerMinuteTolerance); Assert.Equal(SpeedUnit.NanometerPerMinute, parsed.Unit); } @@ -2076,9 +2076,9 @@ public void ConversionRoundTrip() { Speed meterpersecond = Speed.FromMetersPerSecond(1); AssertEx.EqualTolerance(1, Speed.FromCentimetersPerHour(meterpersecond.CentimetersPerHour).MetersPerSecond, CentimetersPerHourTolerance); - AssertEx.EqualTolerance(1, Speed.FromCentimetersPerMinutes(meterpersecond.CentimetersPerMinutes).MetersPerSecond, CentimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromCentimetersPerMinute(meterpersecond.CentimetersPerMinute).MetersPerSecond, CentimetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond, CentimetersPerSecondTolerance); - AssertEx.EqualTolerance(1, Speed.FromDecimetersPerMinutes(meterpersecond.DecimetersPerMinutes).MetersPerSecond, DecimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromDecimetersPerMinute(meterpersecond.DecimetersPerMinute).MetersPerSecond, DecimetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond, DecimetersPerSecondTolerance); AssertEx.EqualTolerance(1, Speed.FromFeetPerHour(meterpersecond.FeetPerHour).MetersPerSecond, FeetPerHourTolerance); AssertEx.EqualTolerance(1, Speed.FromFeetPerMinute(meterpersecond.FeetPerMinute).MetersPerSecond, FeetPerMinuteTolerance); @@ -2087,20 +2087,20 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Speed.FromInchesPerMinute(meterpersecond.InchesPerMinute).MetersPerSecond, InchesPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond, InchesPerSecondTolerance); AssertEx.EqualTolerance(1, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance); - AssertEx.EqualTolerance(1, Speed.FromKilometersPerMinutes(meterpersecond.KilometersPerMinutes).MetersPerSecond, KilometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromKilometersPerMinute(meterpersecond.KilometersPerMinute).MetersPerSecond, KilometersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance); AssertEx.EqualTolerance(1, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance); AssertEx.EqualTolerance(1, Speed.FromMach(meterpersecond.Mach).MetersPerSecond, MachTolerance); AssertEx.EqualTolerance(1, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance); - AssertEx.EqualTolerance(1, Speed.FromMetersPerMinutes(meterpersecond.MetersPerMinutes).MetersPerSecond, MetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromMetersPerMinute(meterpersecond.MetersPerMinute).MetersPerSecond, MetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance); - AssertEx.EqualTolerance(1, Speed.FromMicrometersPerMinutes(meterpersecond.MicrometersPerMinutes).MetersPerSecond, MicrometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromMicrometersPerMinute(meterpersecond.MicrometersPerMinute).MetersPerSecond, MicrometersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance); AssertEx.EqualTolerance(1, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance); AssertEx.EqualTolerance(1, Speed.FromMillimetersPerHour(meterpersecond.MillimetersPerHour).MetersPerSecond, MillimetersPerHourTolerance); - AssertEx.EqualTolerance(1, Speed.FromMillimetersPerMinutes(meterpersecond.MillimetersPerMinutes).MetersPerSecond, MillimetersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromMillimetersPerMinute(meterpersecond.MillimetersPerMinute).MetersPerSecond, MillimetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond, MillimetersPerSecondTolerance); - AssertEx.EqualTolerance(1, Speed.FromNanometersPerMinutes(meterpersecond.NanometersPerMinutes).MetersPerSecond, NanometersPerMinutesTolerance); + AssertEx.EqualTolerance(1, Speed.FromNanometersPerMinute(meterpersecond.NanometersPerMinute).MetersPerSecond, NanometersPerMinuteTolerance); AssertEx.EqualTolerance(1, Speed.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond, NanometersPerSecondTolerance); AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerHour(meterpersecond.UsSurveyFeetPerHour).MetersPerSecond, UsSurveyFeetPerHourTolerance); AssertEx.EqualTolerance(1, Speed.FromUsSurveyFeetPerMinute(meterpersecond.UsSurveyFeetPerMinute).MetersPerSecond, UsSurveyFeetPerMinuteTolerance); diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs index 16df8c83d3..96765f4989 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs @@ -68,10 +68,10 @@ static Density() Info = new QuantityInfo("Density", new UnitInfo[] { - new UnitInfo(DensityUnit.CentigramPerDeciliter, "CentigramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.CentigramPerDeciliter, "CentigramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.CentigramPerLiter, "CentigramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.CentigramPerMilliliter, "CentigramsPerMilliliter", BaseUnits.Undefined, "Density"), - new UnitInfo(DensityUnit.DecigramPerDeciliter, "DecigramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.DecigramPerDeciliter, "DecigramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.DecigramPerLiter, "DecigramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.DecigramPerMilliliter, "DecigramsPerMilliliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.GramPerCubicCentimeter, "GramsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Gram), "Density"), @@ -79,7 +79,7 @@ static Density() new UnitInfo(DensityUnit.GramPerCubicInch, "GramsPerCubicInch", new BaseUnits(length: LengthUnit.Inch, mass: MassUnit.Gram), "Density"), new UnitInfo(DensityUnit.GramPerCubicMeter, "GramsPerCubicMeter", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Gram), "Density"), new UnitInfo(DensityUnit.GramPerCubicMillimeter, "GramsPerCubicMillimeter", new BaseUnits(length: LengthUnit.Millimeter, mass: MassUnit.Gram), "Density"), - new UnitInfo(DensityUnit.GramPerDeciliter, "GramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.GramPerDeciliter, "GramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.GramPerLiter, "GramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.GramPerMilliliter, "GramsPerMilliliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.KilogramPerCubicCentimeter, "KilogramsPerCubicCentimeter", BaseUnits.Undefined, "Density"), @@ -89,17 +89,17 @@ static Density() new UnitInfo(DensityUnit.KilopoundPerCubicFoot, "KilopoundsPerCubicFoot", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.KilopoundPerCubicInch, "KilopoundsPerCubicInch", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MicrogramPerCubicMeter, "MicrogramsPerCubicMeter", BaseUnits.Undefined, "Density"), - new UnitInfo(DensityUnit.MicrogramPerDeciliter, "MicrogramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.MicrogramPerDeciliter, "MicrogramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MicrogramPerLiter, "MicrogramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MicrogramPerMilliliter, "MicrogramsPerMilliliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MilligramPerCubicMeter, "MilligramsPerCubicMeter", BaseUnits.Undefined, "Density"), - new UnitInfo(DensityUnit.MilligramPerDeciliter, "MilligramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.MilligramPerDeciliter, "MilligramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MilligramPerLiter, "MilligramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.MilligramPerMilliliter, "MilligramsPerMilliliter", BaseUnits.Undefined, "Density"), - new UnitInfo(DensityUnit.NanogramPerDeciliter, "NanogramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.NanogramPerDeciliter, "NanogramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.NanogramPerLiter, "NanogramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.NanogramPerMilliliter, "NanogramsPerMilliliter", BaseUnits.Undefined, "Density"), - new UnitInfo(DensityUnit.PicogramPerDeciliter, "PicogramsPerDeciLiter", BaseUnits.Undefined, "Density"), + new UnitInfo(DensityUnit.PicogramPerDeciliter, "PicogramsPerDeciliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.PicogramPerLiter, "PicogramsPerLiter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.PicogramPerMilliliter, "PicogramsPerMilliliter", BaseUnits.Undefined, "Density"), new UnitInfo(DensityUnit.PoundPerCubicCentimeter, "PoundsPerCubicCentimeter", new BaseUnits(length: LengthUnit.Centimeter, mass: MassUnit.Pound), "Density"), @@ -225,7 +225,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double CentigramsPerDeciLiter => As(DensityUnit.CentigramPerDeciliter); + public double CentigramsPerDeciliter => As(DensityUnit.CentigramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -240,7 +240,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double DecigramsPerDeciLiter => As(DensityUnit.DecigramPerDeciliter); + public double DecigramsPerDeciliter => As(DensityUnit.DecigramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -280,7 +280,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double GramsPerDeciLiter => As(DensityUnit.GramPerDeciliter); + public double GramsPerDeciliter => As(DensityUnit.GramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -330,7 +330,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double MicrogramsPerDeciLiter => As(DensityUnit.MicrogramPerDeciliter); + public double MicrogramsPerDeciliter => As(DensityUnit.MicrogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -350,7 +350,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double MilligramsPerDeciLiter => As(DensityUnit.MilligramPerDeciliter); + public double MilligramsPerDeciliter => As(DensityUnit.MilligramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -365,7 +365,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double NanogramsPerDeciLiter => As(DensityUnit.NanogramPerDeciliter); + public double NanogramsPerDeciliter => As(DensityUnit.NanogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -380,7 +380,7 @@ public Density(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double PicogramsPerDeciLiter => As(DensityUnit.PicogramPerDeciliter); + public double PicogramsPerDeciliter => As(DensityUnit.PicogramPerDeciliter); /// /// Gets a value of this quantity converted into @@ -624,7 +624,7 @@ public static string GetAbbreviation(DensityUnit unit, IFormatProvider? provider /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromCentigramsPerDeciLiter(QuantityValue centigramsperdeciliter) + public static Density FromCentigramsPerDeciliter(QuantityValue centigramsperdeciliter) { double value = (double) centigramsperdeciliter; return new Density(value, DensityUnit.CentigramPerDeciliter); @@ -654,7 +654,7 @@ public static Density FromCentigramsPerMilliliter(QuantityValue centigramspermil /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromDecigramsPerDeciLiter(QuantityValue decigramsperdeciliter) + public static Density FromDecigramsPerDeciliter(QuantityValue decigramsperdeciliter) { double value = (double) decigramsperdeciliter; return new Density(value, DensityUnit.DecigramPerDeciliter); @@ -734,7 +734,7 @@ public static Density FromGramsPerCubicMillimeter(QuantityValue gramspercubicmil /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromGramsPerDeciLiter(QuantityValue gramsperdeciliter) + public static Density FromGramsPerDeciliter(QuantityValue gramsperdeciliter) { double value = (double) gramsperdeciliter; return new Density(value, DensityUnit.GramPerDeciliter); @@ -834,7 +834,7 @@ public static Density FromMicrogramsPerCubicMeter(QuantityValue microgramspercub /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromMicrogramsPerDeciLiter(QuantityValue microgramsperdeciliter) + public static Density FromMicrogramsPerDeciliter(QuantityValue microgramsperdeciliter) { double value = (double) microgramsperdeciliter; return new Density(value, DensityUnit.MicrogramPerDeciliter); @@ -874,7 +874,7 @@ public static Density FromMilligramsPerCubicMeter(QuantityValue milligramspercub /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromMilligramsPerDeciLiter(QuantityValue milligramsperdeciliter) + public static Density FromMilligramsPerDeciliter(QuantityValue milligramsperdeciliter) { double value = (double) milligramsperdeciliter; return new Density(value, DensityUnit.MilligramPerDeciliter); @@ -904,7 +904,7 @@ public static Density FromMilligramsPerMilliliter(QuantityValue milligramspermil /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromNanogramsPerDeciLiter(QuantityValue nanogramsperdeciliter) + public static Density FromNanogramsPerDeciliter(QuantityValue nanogramsperdeciliter) { double value = (double) nanogramsperdeciliter; return new Density(value, DensityUnit.NanogramPerDeciliter); @@ -934,7 +934,7 @@ public static Density FromNanogramsPerMilliliter(QuantityValue nanogramspermilli /// Creates a from . /// /// If value is NaN or Infinity. - public static Density FromPicogramsPerDeciLiter(QuantityValue picogramsperdeciliter) + public static Density FromPicogramsPerDeciliter(QuantityValue picogramsperdeciliter) { double value = (double) picogramsperdeciliter; return new Density(value, DensityUnit.PicogramPerDeciliter); diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index a81925629a..eb3232e1b8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -65,26 +65,26 @@ static ElectricPotentialChangeRate() Info = new QuantityInfo("ElectricPotentialChangeRate", new UnitInfo[] { - new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerHour, "KilovoltsPerHours", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, "KilovoltsPerMicroseconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerMinute, "KilovoltsPerMinutes", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerSecond, "KilovoltsPerSeconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerHour, "MegavoltsPerHours", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, "MegavoltsPerMicroseconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerMinute, "MegavoltsPerMinutes", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerSecond, "MegavoltsPerSeconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerHour, "MicrovoltsPerHours", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, "MicrovoltsPerMicroseconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, "MicrovoltsPerMinutes", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, "MicrovoltsPerSeconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerHour, "MillivoltsPerHours", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, "MillivoltsPerMicroseconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerMinute, "MillivoltsPerMinutes", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerSecond, "MillivoltsPerSeconds", BaseUnits.Undefined, "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerHour, "VoltsPerHours", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, "VoltsPerMicroseconds", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerMinute, "VoltsPerMinutes", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), - new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerSecond, "VoltsPerSeconds", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerHour, "KilovoltsPerHour", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond, "KilovoltsPerMicrosecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerMinute, "KilovoltsPerMinute", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.KilovoltPerSecond, "KilovoltsPerSecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerHour, "MegavoltsPerHour", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond, "MegavoltsPerMicrosecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerMinute, "MegavoltsPerMinute", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MegavoltPerSecond, "MegavoltsPerSecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerHour, "MicrovoltsPerHour", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond, "MicrovoltsPerMicrosecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerMinute, "MicrovoltsPerMinute", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MicrovoltPerSecond, "MicrovoltsPerSecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerHour, "MillivoltsPerHour", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond, "MillivoltsPerMicrosecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerMinute, "MillivoltsPerMinute", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.MillivoltPerSecond, "MillivoltsPerSecond", BaseUnits.Undefined, "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerHour, "VoltsPerHour", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Hour, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerMicrosecond, "VoltsPerMicrosecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerMinute, "VoltsPerMinute", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), + new UnitInfo(ElectricPotentialChangeRateUnit.VoltPerSecond, "VoltsPerSecond", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere), "ElectricPotentialChangeRate"), }, BaseUnit, Zero, BaseDimensions); @@ -191,102 +191,102 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerHours => As(ElectricPotentialChangeRateUnit.KilovoltPerHour); + public double KilovoltsPerHour => As(ElectricPotentialChangeRateUnit.KilovoltPerHour); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); + public double KilovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute); + public double KilovoltsPerMinute => As(ElectricPotentialChangeRateUnit.KilovoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double KilovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond); + public double KilovoltsPerSecond => As(ElectricPotentialChangeRateUnit.KilovoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerHours => As(ElectricPotentialChangeRateUnit.MegavoltPerHour); + public double MegavoltsPerHour => As(ElectricPotentialChangeRateUnit.MegavoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); + public double MegavoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute); + public double MegavoltsPerMinute => As(ElectricPotentialChangeRateUnit.MegavoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MegavoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond); + public double MegavoltsPerSecond => As(ElectricPotentialChangeRateUnit.MegavoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerHours => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour); + public double MicrovoltsPerHour => As(ElectricPotentialChangeRateUnit.MicrovoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); + public double MicrovoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute); + public double MicrovoltsPerMinute => As(ElectricPotentialChangeRateUnit.MicrovoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MicrovoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond); + public double MicrovoltsPerSecond => As(ElectricPotentialChangeRateUnit.MicrovoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerHours => As(ElectricPotentialChangeRateUnit.MillivoltPerHour); + public double MillivoltsPerHour => As(ElectricPotentialChangeRateUnit.MillivoltPerHour); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); + public double MillivoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerMinutes => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute); + public double MillivoltsPerMinute => As(ElectricPotentialChangeRateUnit.MillivoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double MillivoltsPerSeconds => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond); + public double MillivoltsPerSecond => As(ElectricPotentialChangeRateUnit.MillivoltPerSecond); /// /// Gets a value of this quantity converted into /// - public double VoltsPerHours => As(ElectricPotentialChangeRateUnit.VoltPerHour); + public double VoltsPerHour => As(ElectricPotentialChangeRateUnit.VoltPerHour); /// /// Gets a value of this quantity converted into /// - public double VoltsPerMicroseconds => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond); + public double VoltsPerMicrosecond => As(ElectricPotentialChangeRateUnit.VoltPerMicrosecond); /// /// Gets a value of this quantity converted into /// - public double VoltsPerMinutes => As(ElectricPotentialChangeRateUnit.VoltPerMinute); + public double VoltsPerMinute => As(ElectricPotentialChangeRateUnit.VoltPerMinute); /// /// Gets a value of this quantity converted into /// - public double VoltsPerSeconds => As(ElectricPotentialChangeRateUnit.VoltPerSecond); + public double VoltsPerSecond => As(ElectricPotentialChangeRateUnit.VoltPerSecond); #endregion @@ -373,9 +373,9 @@ public static string GetAbbreviation(ElectricPotentialChangeRateUnit unit, IForm /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerHours(QuantityValue kilovoltsperhours) + public static ElectricPotentialChangeRate FromKilovoltsPerHour(QuantityValue kilovoltsperhour) { - double value = (double) kilovoltsperhours; + double value = (double) kilovoltsperhour; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour); } @@ -383,9 +383,9 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHours(QuantityValue ki /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(QuantityValue kilovoltspermicroseconds) + public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(QuantityValue kilovoltspermicrosecond) { - double value = (double) kilovoltspermicroseconds; + double value = (double) kilovoltspermicrosecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); } @@ -393,9 +393,9 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(QuantityV /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(QuantityValue kilovoltsperminutes) + public static ElectricPotentialChangeRate FromKilovoltsPerMinute(QuantityValue kilovoltsperminute) { - double value = (double) kilovoltsperminutes; + double value = (double) kilovoltsperminute; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute); } @@ -403,9 +403,9 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(QuantityValue kilovoltsperseconds) + public static ElectricPotentialChangeRate FromKilovoltsPerSecond(QuantityValue kilovoltspersecond) { - double value = (double) kilovoltsperseconds; + double value = (double) kilovoltspersecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond); } @@ -413,9 +413,9 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerHours(QuantityValue megavoltsperhours) + public static ElectricPotentialChangeRate FromMegavoltsPerHour(QuantityValue megavoltsperhour) { - double value = (double) megavoltsperhours; + double value = (double) megavoltsperhour; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour); } @@ -423,9 +423,9 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHours(QuantityValue me /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(QuantityValue megavoltspermicroseconds) + public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(QuantityValue megavoltspermicrosecond) { - double value = (double) megavoltspermicroseconds; + double value = (double) megavoltspermicrosecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); } @@ -433,9 +433,9 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(QuantityV /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(QuantityValue megavoltsperminutes) + public static ElectricPotentialChangeRate FromMegavoltsPerMinute(QuantityValue megavoltsperminute) { - double value = (double) megavoltsperminutes; + double value = (double) megavoltsperminute; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute); } @@ -443,9 +443,9 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(QuantityValue megavoltsperseconds) + public static ElectricPotentialChangeRate FromMegavoltsPerSecond(QuantityValue megavoltspersecond) { - double value = (double) megavoltsperseconds; + double value = (double) megavoltspersecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond); } @@ -453,9 +453,9 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerHours(QuantityValue microvoltsperhours) + public static ElectricPotentialChangeRate FromMicrovoltsPerHour(QuantityValue microvoltsperhour) { - double value = (double) microvoltsperhours; + double value = (double) microvoltsperhour; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour); } @@ -463,9 +463,9 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHours(QuantityValue m /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(QuantityValue microvoltspermicroseconds) + public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(QuantityValue microvoltspermicrosecond) { - double value = (double) microvoltspermicroseconds; + double value = (double) microvoltspermicrosecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); } @@ -473,9 +473,9 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(Quantity /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(QuantityValue microvoltsperminutes) + public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(QuantityValue microvoltsperminute) { - double value = (double) microvoltsperminutes; + double value = (double) microvoltsperminute; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); } @@ -483,9 +483,9 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(QuantityValue microvoltsperseconds) + public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(QuantityValue microvoltspersecond) { - double value = (double) microvoltsperseconds; + double value = (double) microvoltspersecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); } @@ -493,9 +493,9 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerHours(QuantityValue millivoltsperhours) + public static ElectricPotentialChangeRate FromMillivoltsPerHour(QuantityValue millivoltsperhour) { - double value = (double) millivoltsperhours; + double value = (double) millivoltsperhour; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour); } @@ -503,9 +503,9 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHours(QuantityValue m /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(QuantityValue millivoltspermicroseconds) + public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(QuantityValue millivoltspermicrosecond) { - double value = (double) millivoltspermicroseconds; + double value = (double) millivoltspermicrosecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); } @@ -513,9 +513,9 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(Quantity /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(QuantityValue millivoltsperminutes) + public static ElectricPotentialChangeRate FromMillivoltsPerMinute(QuantityValue millivoltsperminute) { - double value = (double) millivoltsperminutes; + double value = (double) millivoltsperminute; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute); } @@ -523,9 +523,9 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(QuantityValue millivoltsperseconds) + public static ElectricPotentialChangeRate FromMillivoltsPerSecond(QuantityValue millivoltspersecond) { - double value = (double) millivoltsperseconds; + double value = (double) millivoltspersecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond); } @@ -533,9 +533,9 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerHours(QuantityValue voltsperhours) + public static ElectricPotentialChangeRate FromVoltsPerHour(QuantityValue voltsperhour) { - double value = (double) voltsperhours; + double value = (double) voltsperhour; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour); } @@ -543,9 +543,9 @@ public static ElectricPotentialChangeRate FromVoltsPerHours(QuantityValue voltsp /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(QuantityValue voltspermicroseconds) + public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(QuantityValue voltspermicrosecond) { - double value = (double) voltspermicroseconds; + double value = (double) voltspermicrosecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); } @@ -553,9 +553,9 @@ public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(QuantityValue /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerMinutes(QuantityValue voltsperminutes) + public static ElectricPotentialChangeRate FromVoltsPerMinute(QuantityValue voltsperminute) { - double value = (double) voltsperminutes; + double value = (double) voltsperminute; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute); } @@ -563,9 +563,9 @@ public static ElectricPotentialChangeRate FromVoltsPerMinutes(QuantityValue volt /// Creates a from . /// /// If value is NaN or Infinity. - public static ElectricPotentialChangeRate FromVoltsPerSeconds(QuantityValue voltsperseconds) + public static ElectricPotentialChangeRate FromVoltsPerSecond(QuantityValue voltspersecond) { - double value = (double) voltsperseconds; + double value = (double) voltspersecond; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond); } @@ -767,7 +767,7 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Elect /// Get ratio value from dividing by . public static double operator /(ElectricPotentialChangeRate left, ElectricPotentialChangeRate right) { - return left.VoltsPerSeconds / right.VoltsPerSeconds; + return left.VoltsPerSecond / right.VoltsPerSecond; } #endregion diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs index 1e0f2a3a1d..65b7903c2a 100644 --- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -68,7 +68,7 @@ static FuelEfficiency() Info = new QuantityInfo("FuelEfficiency", new UnitInfo[] { - new UnitInfo(FuelEfficiencyUnit.KilometerPerLiter, "KilometersPerLiters", BaseUnits.Undefined, "FuelEfficiency"), + new UnitInfo(FuelEfficiencyUnit.KilometerPerLiter, "KilometersPerLiter", BaseUnits.Undefined, "FuelEfficiency"), new UnitInfo(FuelEfficiencyUnit.LiterPer100Kilometers, "LitersPer100Kilometers", BaseUnits.Undefined, "FuelEfficiency"), new UnitInfo(FuelEfficiencyUnit.MilePerUkGallon, "MilesPerUkGallon", BaseUnits.Undefined, "FuelEfficiency"), new UnitInfo(FuelEfficiencyUnit.MilePerUsGallon, "MilesPerUsGallon", BaseUnits.Undefined, "FuelEfficiency"), @@ -178,7 +178,7 @@ public FuelEfficiency(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double KilometersPerLiters => As(FuelEfficiencyUnit.KilometerPerLiter); + public double KilometersPerLiter => As(FuelEfficiencyUnit.KilometerPerLiter); /// /// Gets a value of this quantity converted into @@ -248,9 +248,9 @@ public static string GetAbbreviation(FuelEfficiencyUnit unit, IFormatProvider? p /// Creates a from . /// /// If value is NaN or Infinity. - public static FuelEfficiency FromKilometersPerLiters(QuantityValue kilometersperliters) + public static FuelEfficiency FromKilometersPerLiter(QuantityValue kilometersperliter) { - double value = (double) kilometersperliters; + double value = (double) kilometersperliter; return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter); } diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs index bed6e9c6c7..2d5a5bd3e6 100644 --- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs @@ -66,9 +66,9 @@ static Speed() new UnitInfo[] { new UnitInfo(SpeedUnit.CentimeterPerHour, "CentimetersPerHour", BaseUnits.Undefined, "Speed"), - new UnitInfo(SpeedUnit.CentimeterPerMinute, "CentimetersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.CentimeterPerMinute, "CentimetersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.CentimeterPerSecond, "CentimetersPerSecond", BaseUnits.Undefined, "Speed"), - new UnitInfo(SpeedUnit.DecimeterPerMinute, "DecimetersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.DecimeterPerMinute, "DecimetersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.DecimeterPerSecond, "DecimetersPerSecond", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.FootPerHour, "FeetPerHour", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Hour), "Speed"), new UnitInfo(SpeedUnit.FootPerMinute, "FeetPerMinute", new BaseUnits(length: LengthUnit.Foot, time: DurationUnit.Minute), "Speed"), @@ -77,20 +77,20 @@ static Speed() new UnitInfo(SpeedUnit.InchPerMinute, "InchesPerMinute", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Minute), "Speed"), new UnitInfo(SpeedUnit.InchPerSecond, "InchesPerSecond", new BaseUnits(length: LengthUnit.Inch, time: DurationUnit.Second), "Speed"), new UnitInfo(SpeedUnit.KilometerPerHour, "KilometersPerHour", BaseUnits.Undefined, "Speed"), - new UnitInfo(SpeedUnit.KilometerPerMinute, "KilometersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.KilometerPerMinute, "KilometersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.KilometerPerSecond, "KilometersPerSecond", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.Knot, "Knots", new BaseUnits(length: LengthUnit.NauticalMile, time: DurationUnit.Hour), "Speed"), new UnitInfo(SpeedUnit.Mach, "Mach", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.MeterPerHour, "MetersPerHour", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Hour), "Speed"), - new UnitInfo(SpeedUnit.MeterPerMinute, "MetersPerMinutes", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute), "Speed"), + new UnitInfo(SpeedUnit.MeterPerMinute, "MetersPerMinute", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Minute), "Speed"), new UnitInfo(SpeedUnit.MeterPerSecond, "MetersPerSecond", new BaseUnits(length: LengthUnit.Meter, time: DurationUnit.Second), "Speed"), - new UnitInfo(SpeedUnit.MicrometerPerMinute, "MicrometersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.MicrometerPerMinute, "MicrometersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.MicrometerPerSecond, "MicrometersPerSecond", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.MilePerHour, "MilesPerHour", new BaseUnits(length: LengthUnit.Mile, time: DurationUnit.Hour), "Speed"), new UnitInfo(SpeedUnit.MillimeterPerHour, "MillimetersPerHour", BaseUnits.Undefined, "Speed"), - new UnitInfo(SpeedUnit.MillimeterPerMinute, "MillimetersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.MillimeterPerMinute, "MillimetersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.MillimeterPerSecond, "MillimetersPerSecond", BaseUnits.Undefined, "Speed"), - new UnitInfo(SpeedUnit.NanometerPerMinute, "NanometersPerMinutes", BaseUnits.Undefined, "Speed"), + new UnitInfo(SpeedUnit.NanometerPerMinute, "NanometersPerMinute", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.NanometerPerSecond, "NanometersPerSecond", BaseUnits.Undefined, "Speed"), new UnitInfo(SpeedUnit.UsSurveyFootPerHour, "UsSurveyFeetPerHour", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Hour), "Speed"), new UnitInfo(SpeedUnit.UsSurveyFootPerMinute, "UsSurveyFeetPerMinute", new BaseUnits(length: LengthUnit.UsSurveyFoot, time: DurationUnit.Minute), "Speed"), @@ -209,7 +209,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double CentimetersPerMinutes => As(SpeedUnit.CentimeterPerMinute); + public double CentimetersPerMinute => As(SpeedUnit.CentimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -219,7 +219,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double DecimetersPerMinutes => As(SpeedUnit.DecimeterPerMinute); + public double DecimetersPerMinute => As(SpeedUnit.DecimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -264,7 +264,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double KilometersPerMinutes => As(SpeedUnit.KilometerPerMinute); + public double KilometersPerMinute => As(SpeedUnit.KilometerPerMinute); /// /// Gets a value of this quantity converted into @@ -289,7 +289,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double MetersPerMinutes => As(SpeedUnit.MeterPerMinute); + public double MetersPerMinute => As(SpeedUnit.MeterPerMinute); /// /// Gets a value of this quantity converted into @@ -299,7 +299,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double MicrometersPerMinutes => As(SpeedUnit.MicrometerPerMinute); + public double MicrometersPerMinute => As(SpeedUnit.MicrometerPerMinute); /// /// Gets a value of this quantity converted into @@ -319,7 +319,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double MillimetersPerMinutes => As(SpeedUnit.MillimeterPerMinute); + public double MillimetersPerMinute => As(SpeedUnit.MillimeterPerMinute); /// /// Gets a value of this quantity converted into @@ -329,7 +329,7 @@ public Speed(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double NanometersPerMinutes => As(SpeedUnit.NanometerPerMinute); + public double NanometersPerMinute => As(SpeedUnit.NanometerPerMinute); /// /// Gets a value of this quantity converted into @@ -487,9 +487,9 @@ public static Speed FromCentimetersPerHour(QuantityValue centimetersperhour) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromCentimetersPerMinutes(QuantityValue centimetersperminutes) + public static Speed FromCentimetersPerMinute(QuantityValue centimetersperminute) { - double value = (double) centimetersperminutes; + double value = (double) centimetersperminute; return new Speed(value, SpeedUnit.CentimeterPerMinute); } @@ -507,9 +507,9 @@ public static Speed FromCentimetersPerSecond(QuantityValue centimeterspersecond) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromDecimetersPerMinutes(QuantityValue decimetersperminutes) + public static Speed FromDecimetersPerMinute(QuantityValue decimetersperminute) { - double value = (double) decimetersperminutes; + double value = (double) decimetersperminute; return new Speed(value, SpeedUnit.DecimeterPerMinute); } @@ -597,9 +597,9 @@ public static Speed FromKilometersPerHour(QuantityValue kilometersperhour) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromKilometersPerMinutes(QuantityValue kilometersperminutes) + public static Speed FromKilometersPerMinute(QuantityValue kilometersperminute) { - double value = (double) kilometersperminutes; + double value = (double) kilometersperminute; return new Speed(value, SpeedUnit.KilometerPerMinute); } @@ -647,9 +647,9 @@ public static Speed FromMetersPerHour(QuantityValue metersperhour) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMetersPerMinutes(QuantityValue metersperminutes) + public static Speed FromMetersPerMinute(QuantityValue metersperminute) { - double value = (double) metersperminutes; + double value = (double) metersperminute; return new Speed(value, SpeedUnit.MeterPerMinute); } @@ -667,9 +667,9 @@ public static Speed FromMetersPerSecond(QuantityValue meterspersecond) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMicrometersPerMinutes(QuantityValue micrometersperminutes) + public static Speed FromMicrometersPerMinute(QuantityValue micrometersperminute) { - double value = (double) micrometersperminutes; + double value = (double) micrometersperminute; return new Speed(value, SpeedUnit.MicrometerPerMinute); } @@ -707,9 +707,9 @@ public static Speed FromMillimetersPerHour(QuantityValue millimetersperhour) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromMillimetersPerMinutes(QuantityValue millimetersperminutes) + public static Speed FromMillimetersPerMinute(QuantityValue millimetersperminute) { - double value = (double) millimetersperminutes; + double value = (double) millimetersperminute; return new Speed(value, SpeedUnit.MillimeterPerMinute); } @@ -727,9 +727,9 @@ public static Speed FromMillimetersPerSecond(QuantityValue millimeterspersecond) /// Creates a from . /// /// If value is NaN or Infinity. - public static Speed FromNanometersPerMinutes(QuantityValue nanometersperminutes) + public static Speed FromNanometersPerMinute(QuantityValue nanometersperminute) { - double value = (double) nanometersperminutes; + double value = (double) nanometersperminute; return new Speed(value, SpeedUnit.NanometerPerMinute); } diff --git a/UnitsNet/GeneratedCode/Resources/Density.restext b/UnitsNet/GeneratedCode/Resources/Density.restext index d2a222cc08..1ba86bbd7a 100644 --- a/UnitsNet/GeneratedCode/Resources/Density.restext +++ b/UnitsNet/GeneratedCode/Resources/Density.restext @@ -1,7 +1,7 @@ -CentigramsPerDeciLiter=cg/dl +CentigramsPerDeciliter=cg/dl CentigramsPerLiter=cg/L CentigramsPerMilliliter=cg/ml -DecigramsPerDeciLiter=dg/dl +DecigramsPerDeciliter=dg/dl DecigramsPerLiter=dg/L DecigramsPerMilliliter=dg/ml GramsPerCubicCentimeter=g/cm³ @@ -9,7 +9,7 @@ GramsPerCubicFoot=g/ft³ GramsPerCubicInch=g/in³ GramsPerCubicMeter=g/m³ GramsPerCubicMillimeter=g/mm³ -GramsPerDeciLiter=g/dl +GramsPerDeciliter=g/dl GramsPerLiter=g/L GramsPerMilliliter=g/ml KilogramsPerCubicCentimeter=kg/cm³ @@ -19,17 +19,17 @@ KilogramsPerLiter=kg/l KilopoundsPerCubicFoot=kip/ft³ KilopoundsPerCubicInch=kip/in³ MicrogramsPerCubicMeter=µg/m³ -MicrogramsPerDeciLiter=µg/dl +MicrogramsPerDeciliter=µg/dl MicrogramsPerLiter=µg/L MicrogramsPerMilliliter=µg/ml MilligramsPerCubicMeter=mg/m³ -MilligramsPerDeciLiter=mg/dl +MilligramsPerDeciliter=mg/dl MilligramsPerLiter=mg/L MilligramsPerMilliliter=mg/ml -NanogramsPerDeciLiter=ng/dl +NanogramsPerDeciliter=ng/dl NanogramsPerLiter=ng/L NanogramsPerMilliliter=ng/ml -PicogramsPerDeciLiter=pg/dl +PicogramsPerDeciliter=pg/dl PicogramsPerLiter=pg/L PicogramsPerMilliliter=pg/ml PoundsPerCubicCentimeter=lb/cm³ diff --git a/UnitsNet/GeneratedCode/Resources/ElectricPotentialChangeRate.restext b/UnitsNet/GeneratedCode/Resources/ElectricPotentialChangeRate.restext index 23e9c0726c..e1bfdee63f 100644 --- a/UnitsNet/GeneratedCode/Resources/ElectricPotentialChangeRate.restext +++ b/UnitsNet/GeneratedCode/Resources/ElectricPotentialChangeRate.restext @@ -1,20 +1,20 @@ -KilovoltsPerHours=kV/h -KilovoltsPerMicroseconds=kV/μs -KilovoltsPerMinutes=kV/min -KilovoltsPerSeconds=kV/s -MegavoltsPerHours=MV/h -MegavoltsPerMicroseconds=MV/μs -MegavoltsPerMinutes=MV/min -MegavoltsPerSeconds=MV/s -MicrovoltsPerHours=µV/h -MicrovoltsPerMicroseconds=µV/μs -MicrovoltsPerMinutes=µV/min -MicrovoltsPerSeconds=µV/s -MillivoltsPerHours=mV/h -MillivoltsPerMicroseconds=mV/μs -MillivoltsPerMinutes=mV/min -MillivoltsPerSeconds=mV/s -VoltsPerHours=V/h -VoltsPerMicroseconds=V/μs -VoltsPerMinutes=V/min -VoltsPerSeconds=V/s +KilovoltsPerHour=kV/h +KilovoltsPerMicrosecond=kV/μs +KilovoltsPerMinute=kV/min +KilovoltsPerSecond=kV/s +MegavoltsPerHour=MV/h +MegavoltsPerMicrosecond=MV/μs +MegavoltsPerMinute=MV/min +MegavoltsPerSecond=MV/s +MicrovoltsPerHour=µV/h +MicrovoltsPerMicrosecond=µV/μs +MicrovoltsPerMinute=µV/min +MicrovoltsPerSecond=µV/s +MillivoltsPerHour=mV/h +MillivoltsPerMicrosecond=mV/μs +MillivoltsPerMinute=mV/min +MillivoltsPerSecond=mV/s +VoltsPerHour=V/h +VoltsPerMicrosecond=V/μs +VoltsPerMinute=V/min +VoltsPerSecond=V/s diff --git a/UnitsNet/GeneratedCode/Resources/FuelEfficiency.restext b/UnitsNet/GeneratedCode/Resources/FuelEfficiency.restext index 600f577506..3440466d12 100644 --- a/UnitsNet/GeneratedCode/Resources/FuelEfficiency.restext +++ b/UnitsNet/GeneratedCode/Resources/FuelEfficiency.restext @@ -1,4 +1,4 @@ -KilometersPerLiters=km/L +KilometersPerLiter=km/L LitersPer100Kilometers=L/100km MilesPerUkGallon=mpg (imp.) MilesPerUsGallon=mpg (U.S.) diff --git a/UnitsNet/GeneratedCode/Resources/Speed.restext b/UnitsNet/GeneratedCode/Resources/Speed.restext index c98cc42920..f4fee81ddf 100644 --- a/UnitsNet/GeneratedCode/Resources/Speed.restext +++ b/UnitsNet/GeneratedCode/Resources/Speed.restext @@ -1,7 +1,7 @@ CentimetersPerHour=cm/h -CentimetersPerMinutes=cm/min +CentimetersPerMinute=cm/min CentimetersPerSecond=cm/s -DecimetersPerMinutes=dm/min +DecimetersPerMinute=dm/min DecimetersPerSecond=dm/s FeetPerHour=ft/h FeetPerMinute=ft/min @@ -10,20 +10,20 @@ InchesPerHour=in/h InchesPerMinute=in/min InchesPerSecond=in/s KilometersPerHour=km/h -KilometersPerMinutes=km/min +KilometersPerMinute=km/min KilometersPerSecond=km/s Knots=kn,kt,knot,knots Mach=M,Ma,MN,MACH MetersPerHour=m/h -MetersPerMinutes=m/min +MetersPerMinute=m/min MetersPerSecond=m/s -MicrometersPerMinutes=µm/min +MicrometersPerMinute=µm/min MicrometersPerSecond=µm/s MilesPerHour=mph MillimetersPerHour=mm/h -MillimetersPerMinutes=mm/min +MillimetersPerMinute=mm/min MillimetersPerSecond=mm/s -NanometersPerMinutes=nm/min +NanometersPerMinute=nm/min NanometersPerSecond=nm/s UsSurveyFeetPerHour=ftUS/h UsSurveyFeetPerMinute=ftUS/min diff --git a/UnitsNet/GeneratedCode/Resources/Speed.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/Speed.ru-RU.restext index 96968602f0..407649cdd5 100644 --- a/UnitsNet/GeneratedCode/Resources/Speed.ru-RU.restext +++ b/UnitsNet/GeneratedCode/Resources/Speed.ru-RU.restext @@ -1,24 +1,24 @@ CentimetersPerHour=см/ч -CentimetersPerMinutes=см/мин +CentimetersPerMinute=см/мин CentimetersPerSecond=см/с -DecimetersPerMinutes=дм/мин +DecimetersPerMinute=дм/мин DecimetersPerSecond=дм/с FeetPerHour=фут/ч FeetPerMinute=фут/мин FeetPerSecond=фут/с KilometersPerHour=км/ч -KilometersPerMinutes=км/мин +KilometersPerMinute=км/мин KilometersPerSecond=км/с Knots=уз. Mach=мах MetersPerHour=м/ч -MetersPerMinutes=м/мин +MetersPerMinute=м/мин MetersPerSecond=м/с -MicrometersPerMinutes=мкм/мин +MicrometersPerMinute=мкм/мин MicrometersPerSecond=мкм/с MilesPerHour=миль/ч MillimetersPerHour=мм/ч -MillimetersPerMinutes=мм/мин +MillimetersPerMinute=мм/мин MillimetersPerSecond=мм/с -NanometersPerMinutes=нм/мин +NanometersPerMinute=нм/мин NanometersPerSecond=нм/с