diff --git a/Common/UnitDefinitions/Torque.json b/Common/UnitDefinitions/Torque.json
index d19cebd6ad..4b45482a28 100644
--- a/Common/UnitDefinitions/Torque.json
+++ b/Common/UnitDefinitions/Torque.json
@@ -56,6 +56,30 @@
}
]
},
+ {
+ "SingularName": "OunceForceFoot",
+ "PluralName": "OunceForceFeet",
+ "FromUnitToBaseFunc": "{x} * (4.4482216152605 / 16) * 0.3048",
+ "FromBaseToUnitFunc": "{x} / ((4.4482216152605 / 16) * 0.3048)",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "ozf·ft" ]
+ }
+ ]
+ },
+ {
+ "SingularName": "OunceForceInch",
+ "PluralName": "OunceForceInches",
+ "FromUnitToBaseFunc": "{x} * (4.4482216152605 / 16) * 2.54e-2",
+ "FromBaseToUnitFunc": "{x} / ((4.4482216152605 / 16) * 2.54e-2)",
+ "Localization": [
+ {
+ "Culture": "en-US",
+ "Abbreviations": [ "ozf·in" ]
+ }
+ ]
+ },
{
"SingularName": "PoundalFoot",
"PluralName": "PoundalFeet",
diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json
index 178c2b2055..321101ca9d 100644
--- a/Common/UnitEnumValues.g.json
+++ b/Common/UnitEnumValues.g.json
@@ -1536,7 +1536,9 @@
"PoundForceInch": 22,
"TonneForceCentimeter": 23,
"TonneForceMeter": 24,
- "TonneForceMillimeter": 25
+ "TonneForceMillimeter": 25,
+ "OunceForceFoot": 26,
+ "OunceForceInch": 27
},
"TorquePerLength": {
"KilogramForceCentimeterPerMeter": 1,
diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
index cf28ae5f83..5dc5d1e1c0 100644
--- a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -100,6 +100,14 @@ public void NumberToNewtonMetersTest() =>
public void NumberToNewtonMillimetersTest() =>
Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters);
+ [Fact]
+ public void NumberToOunceForceFeetTest() =>
+ Assert.Equal(Torque.FromOunceForceFeet(2), 2.OunceForceFeet);
+
+ [Fact]
+ public void NumberToOunceForceInchesTest() =>
+ Assert.Equal(Torque.FromOunceForceInches(2), 2.OunceForceInches);
+
[Fact]
public void NumberToPoundalFeetTest() =>
Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet);
diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
index 1f146d4cbe..58025df50d 100644
--- a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -194,6 +194,22 @@ public Torque NewtonMillimeters
=> Torque.FromNewtonMillimeters(value.ToDouble(null));
#endif
+ ///
+ public Torque OunceForceFeet
+#if NET7_0_OR_GREATER
+ => Torque.FromOunceForceFeet(double.CreateChecked(value));
+#else
+ => Torque.FromOunceForceFeet(value.ToDouble(null));
+#endif
+
+ ///
+ public Torque OunceForceInches
+#if NET7_0_OR_GREATER
+ => Torque.FromOunceForceInches(double.CreateChecked(value));
+#else
+ => Torque.FromOunceForceInches(value.ToDouble(null));
+#endif
+
///
public Torque PoundalFeet
#if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
index b2e9768911..041cfc7580 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -100,6 +100,14 @@ public void NumberToNewtonMetersTest() =>
public void NumberToNewtonMillimetersTest() =>
Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters());
+ [Fact]
+ public void NumberToOunceForceFeetTest() =>
+ Assert.Equal(Torque.FromOunceForceFeet(2), 2.OunceForceFeet());
+
+ [Fact]
+ public void NumberToOunceForceInchesTest() =>
+ Assert.Equal(Torque.FromOunceForceInches(2), 2.OunceForceInches());
+
[Fact]
public void NumberToPoundalFeetTest() =>
Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet());
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
index 8fcea0a9be..3dce75963c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -241,6 +241,28 @@ public static Torque NewtonMillimeters(this T value)
=> Torque.FromNewtonMillimeters(value.ToDouble(null));
#endif
+ ///
+ public static Torque OunceForceFeet(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+ => Torque.FromOunceForceFeet(double.CreateChecked(value));
+#else
+ , IConvertible
+ => Torque.FromOunceForceFeet(value.ToDouble(null));
+#endif
+
+ ///
+ public static Torque OunceForceInches(this T value)
+ where T : notnull
+#if NET7_0_OR_GREATER
+ , INumber
+ => Torque.FromOunceForceInches(double.CreateChecked(value));
+#else
+ , IConvertible
+ => Torque.FromOunceForceInches(value.ToDouble(null));
+#endif
+
///
public static Torque PoundalFeet(this T value)
where T : notnull
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index ec29e22398..e20a0c98cb 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -45,6 +45,10 @@ public class TorqueTests : TorqueTestsBase
protected override double NewtonMillimetersInOneNewtonMeter => 1000;
+ protected override double OunceForceFeetInOneNewtonMeter => 11.800994388436246;
+
+ protected override double OunceForceInchesInOneNewtonMeter => 141.61193266123496;
+
protected override double PoundForceFeetInOneNewtonMeter => 0.737562149277;
protected override double PoundForceInchesInOneNewtonMeter => 8.85074579;
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
index 3965db12a5..c08c5bd897 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/TorqueTestsBase.g.cs
@@ -59,6 +59,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
protected abstract double NewtonCentimetersInOneNewtonMeter { get; }
protected abstract double NewtonMetersInOneNewtonMeter { get; }
protected abstract double NewtonMillimetersInOneNewtonMeter { get; }
+ protected abstract double OunceForceFeetInOneNewtonMeter { get; }
+ protected abstract double OunceForceInchesInOneNewtonMeter { get; }
protected abstract double PoundalFeetInOneNewtonMeter { get; }
protected abstract double PoundForceFeetInOneNewtonMeter { get; }
protected abstract double PoundForceInchesInOneNewtonMeter { get; }
@@ -86,6 +88,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
protected virtual double NewtonCentimetersTolerance { get { return 1e-5; } }
protected virtual double NewtonMetersTolerance { get { return 1e-5; } }
protected virtual double NewtonMillimetersTolerance { get { return 1e-5; } }
+ protected virtual double OunceForceFeetTolerance { get { return 1e-5; } }
+ protected virtual double OunceForceInchesTolerance { get { return 1e-5; } }
protected virtual double PoundalFeetTolerance { get { return 1e-5; } }
protected virtual double PoundForceFeetTolerance { get { return 1e-5; } }
protected virtual double PoundForceInchesTolerance { get { return 1e-5; } }
@@ -117,6 +121,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
TorqueUnit.NewtonCentimeter => (NewtonCentimetersInOneNewtonMeter, NewtonCentimetersTolerance),
TorqueUnit.NewtonMeter => (NewtonMetersInOneNewtonMeter, NewtonMetersTolerance),
TorqueUnit.NewtonMillimeter => (NewtonMillimetersInOneNewtonMeter, NewtonMillimetersTolerance),
+ TorqueUnit.OunceForceFoot => (OunceForceFeetInOneNewtonMeter, OunceForceFeetTolerance),
+ TorqueUnit.OunceForceInch => (OunceForceInchesInOneNewtonMeter, OunceForceInchesTolerance),
TorqueUnit.PoundalFoot => (PoundalFeetInOneNewtonMeter, PoundalFeetTolerance),
TorqueUnit.PoundForceFoot => (PoundForceFeetInOneNewtonMeter, PoundForceFeetTolerance),
TorqueUnit.PoundForceInch => (PoundForceInchesInOneNewtonMeter, PoundForceInchesTolerance),
@@ -148,6 +154,8 @@ public abstract partial class TorqueTestsBase : QuantityTestsBase
new object[] { TorqueUnit.NewtonCentimeter },
new object[] { TorqueUnit.NewtonMeter },
new object[] { TorqueUnit.NewtonMillimeter },
+ new object[] { TorqueUnit.OunceForceFoot },
+ new object[] { TorqueUnit.OunceForceInch },
new object[] { TorqueUnit.PoundalFoot },
new object[] { TorqueUnit.PoundForceFoot },
new object[] { TorqueUnit.PoundForceInch },
@@ -244,6 +252,8 @@ public void NewtonMeterToTorqueUnits()
AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.NewtonCentimeters, NewtonCentimetersTolerance);
AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.NewtonMeters, NewtonMetersTolerance);
AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.NewtonMillimeters, NewtonMillimetersTolerance);
+ AssertEx.EqualTolerance(OunceForceFeetInOneNewtonMeter, newtonmeter.OunceForceFeet, OunceForceFeetTolerance);
+ AssertEx.EqualTolerance(OunceForceInchesInOneNewtonMeter, newtonmeter.OunceForceInches, OunceForceInchesTolerance);
AssertEx.EqualTolerance(PoundalFeetInOneNewtonMeter, newtonmeter.PoundalFeet, PoundalFeetTolerance);
AssertEx.EqualTolerance(PoundForceFeetInOneNewtonMeter, newtonmeter.PoundForceFeet, PoundForceFeetTolerance);
AssertEx.EqualTolerance(PoundForceInchesInOneNewtonMeter, newtonmeter.PoundForceInches, PoundForceInchesTolerance);
@@ -304,6 +314,8 @@ public void As()
AssertEx.EqualTolerance(NewtonCentimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonCentimeter), NewtonCentimetersTolerance);
AssertEx.EqualTolerance(NewtonMetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMeter), NewtonMetersTolerance);
AssertEx.EqualTolerance(NewtonMillimetersInOneNewtonMeter, newtonmeter.As(TorqueUnit.NewtonMillimeter), NewtonMillimetersTolerance);
+ AssertEx.EqualTolerance(OunceForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.OunceForceFoot), OunceForceFeetTolerance);
+ AssertEx.EqualTolerance(OunceForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.OunceForceInch), OunceForceInchesTolerance);
AssertEx.EqualTolerance(PoundalFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundalFoot), PoundalFeetTolerance);
AssertEx.EqualTolerance(PoundForceFeetInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundForceFoot), PoundForceFeetTolerance);
AssertEx.EqualTolerance(PoundForceInchesInOneNewtonMeter, newtonmeter.As(TorqueUnit.PoundForceInch), PoundForceInchesTolerance);
@@ -395,6 +407,8 @@ public void ToUnit_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
[InlineData("en-US", "4.2 N·cm", TorqueUnit.NewtonCentimeter, 4.2)]
[InlineData("en-US", "4.2 N·m", TorqueUnit.NewtonMeter, 4.2)]
[InlineData("en-US", "4.2 N·mm", TorqueUnit.NewtonMillimeter, 4.2)]
+ [InlineData("en-US", "4.2 ozf·ft", TorqueUnit.OunceForceFoot, 4.2)]
+ [InlineData("en-US", "4.2 ozf·in", TorqueUnit.OunceForceInch, 4.2)]
[InlineData("en-US", "4.2 pdl·ft", TorqueUnit.PoundalFoot, 4.2)]
[InlineData("en-US", "4.2 lbf·ft", TorqueUnit.PoundForceFoot, 4.2)]
[InlineData("en-US", "4.2 lbf·in", TorqueUnit.PoundForceInch, 4.2)]
@@ -432,6 +446,8 @@ public void Parse(string culture, string quantityString, TorqueUnit expectedUnit
[InlineData("en-US", "4.2 N·cm", TorqueUnit.NewtonCentimeter, 4.2)]
[InlineData("en-US", "4.2 N·m", TorqueUnit.NewtonMeter, 4.2)]
[InlineData("en-US", "4.2 N·mm", TorqueUnit.NewtonMillimeter, 4.2)]
+ [InlineData("en-US", "4.2 ozf·ft", TorqueUnit.OunceForceFoot, 4.2)]
+ [InlineData("en-US", "4.2 ozf·in", TorqueUnit.OunceForceInch, 4.2)]
[InlineData("en-US", "4.2 pdl·ft", TorqueUnit.PoundalFoot, 4.2)]
[InlineData("en-US", "4.2 lbf·ft", TorqueUnit.PoundForceFoot, 4.2)]
[InlineData("en-US", "4.2 lbf·in", TorqueUnit.PoundForceInch, 4.2)]
@@ -469,6 +485,8 @@ public void TryParse(string culture, string quantityString, TorqueUnit expectedU
[InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("N·m", TorqueUnit.NewtonMeter)]
[InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("lbf·in", TorqueUnit.PoundForceInch)]
@@ -503,6 +521,8 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, TorqueUni
[InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("N·m", TorqueUnit.NewtonMeter)]
[InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("lbf·in", TorqueUnit.PoundForceInch)]
@@ -537,6 +557,8 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string
[InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
[InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
@@ -573,6 +595,8 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, To
[InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
[InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
@@ -608,6 +632,8 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, TorqueUni
[InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("N·m", TorqueUnit.NewtonMeter)]
[InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("lbf·in", TorqueUnit.PoundForceInch)]
@@ -642,6 +668,8 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Torque
[InlineData("N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("N·m", TorqueUnit.NewtonMeter)]
[InlineData("N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("lbf·in", TorqueUnit.PoundForceInch)]
@@ -676,6 +704,8 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri
[InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
[InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
@@ -712,6 +742,8 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation,
[InlineData("en-US", "N·cm", TorqueUnit.NewtonCentimeter)]
[InlineData("en-US", "N·m", TorqueUnit.NewtonMeter)]
[InlineData("en-US", "N·mm", TorqueUnit.NewtonMillimeter)]
+ [InlineData("en-US", "ozf·ft", TorqueUnit.OunceForceFoot)]
+ [InlineData("en-US", "ozf·in", TorqueUnit.OunceForceInch)]
[InlineData("en-US", "pdl·ft", TorqueUnit.PoundalFoot)]
[InlineData("en-US", "lbf·ft", TorqueUnit.PoundForceFoot)]
[InlineData("en-US", "lbf·in", TorqueUnit.PoundForceInch)]
@@ -747,6 +779,8 @@ public void TryParseUnit_WithCulture(string culture, string abbreviation, Torque
[InlineData("en-US", TorqueUnit.NewtonCentimeter, "N·cm")]
[InlineData("en-US", TorqueUnit.NewtonMeter, "N·m")]
[InlineData("en-US", TorqueUnit.NewtonMillimeter, "N·mm")]
+ [InlineData("en-US", TorqueUnit.OunceForceFoot, "ozf·ft")]
+ [InlineData("en-US", TorqueUnit.OunceForceInch, "ozf·in")]
[InlineData("en-US", TorqueUnit.PoundalFoot, "pdl·ft")]
[InlineData("en-US", TorqueUnit.PoundForceFoot, "lbf·ft")]
[InlineData("en-US", TorqueUnit.PoundForceInch, "lbf·in")]
@@ -859,6 +893,8 @@ public void ConversionRoundTrip()
AssertEx.EqualTolerance(1, Torque.FromNewtonCentimeters(newtonmeter.NewtonCentimeters).NewtonMeters, NewtonCentimetersTolerance);
AssertEx.EqualTolerance(1, Torque.FromNewtonMeters(newtonmeter.NewtonMeters).NewtonMeters, NewtonMetersTolerance);
AssertEx.EqualTolerance(1, Torque.FromNewtonMillimeters(newtonmeter.NewtonMillimeters).NewtonMeters, NewtonMillimetersTolerance);
+ AssertEx.EqualTolerance(1, Torque.FromOunceForceFeet(newtonmeter.OunceForceFeet).NewtonMeters, OunceForceFeetTolerance);
+ AssertEx.EqualTolerance(1, Torque.FromOunceForceInches(newtonmeter.OunceForceInches).NewtonMeters, OunceForceInchesTolerance);
AssertEx.EqualTolerance(1, Torque.FromPoundalFeet(newtonmeter.PoundalFeet).NewtonMeters, PoundalFeetTolerance);
AssertEx.EqualTolerance(1, Torque.FromPoundForceFeet(newtonmeter.PoundForceFeet).NewtonMeters, PoundForceFeetTolerance);
AssertEx.EqualTolerance(1, Torque.FromPoundForceInches(newtonmeter.PoundForceInches).NewtonMeters, PoundForceInchesTolerance);
@@ -1040,6 +1076,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
Assert.Equal("1 N·cm", new Torque(1, TorqueUnit.NewtonCentimeter).ToString());
Assert.Equal("1 N·m", new Torque(1, TorqueUnit.NewtonMeter).ToString());
Assert.Equal("1 N·mm", new Torque(1, TorqueUnit.NewtonMillimeter).ToString());
+ Assert.Equal("1 ozf·ft", new Torque(1, TorqueUnit.OunceForceFoot).ToString());
+ Assert.Equal("1 ozf·in", new Torque(1, TorqueUnit.OunceForceInch).ToString());
Assert.Equal("1 pdl·ft", new Torque(1, TorqueUnit.PoundalFoot).ToString());
Assert.Equal("1 lbf·ft", new Torque(1, TorqueUnit.PoundForceFoot).ToString());
Assert.Equal("1 lbf·in", new Torque(1, TorqueUnit.PoundForceInch).ToString());
@@ -1073,6 +1111,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
Assert.Equal("1 N·cm", new Torque(1, TorqueUnit.NewtonCentimeter).ToString(swedishCulture));
Assert.Equal("1 N·m", new Torque(1, TorqueUnit.NewtonMeter).ToString(swedishCulture));
Assert.Equal("1 N·mm", new Torque(1, TorqueUnit.NewtonMillimeter).ToString(swedishCulture));
+ Assert.Equal("1 ozf·ft", new Torque(1, TorqueUnit.OunceForceFoot).ToString(swedishCulture));
+ Assert.Equal("1 ozf·in", new Torque(1, TorqueUnit.OunceForceInch).ToString(swedishCulture));
Assert.Equal("1 pdl·ft", new Torque(1, TorqueUnit.PoundalFoot).ToString(swedishCulture));
Assert.Equal("1 lbf·ft", new Torque(1, TorqueUnit.PoundForceFoot).ToString(swedishCulture));
Assert.Equal("1 lbf·in", new Torque(1, TorqueUnit.PoundForceInch).ToString(swedishCulture));
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 8a260baeef..850e55b59f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -143,6 +143,8 @@ public static IEnumerable> GetDefaultMappings()
yield return new (TorqueUnit.NewtonCentimeter, "NewtonCentimeter", "NewtonCentimeters", BaseUnits.Undefined);
yield return new (TorqueUnit.NewtonMeter, "NewtonMeter", "NewtonMeters", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second));
yield return new (TorqueUnit.NewtonMillimeter, "NewtonMillimeter", "NewtonMillimeters", BaseUnits.Undefined);
+ yield return new (TorqueUnit.OunceForceFoot, "OunceForceFoot", "OunceForceFeet", BaseUnits.Undefined);
+ yield return new (TorqueUnit.OunceForceInch, "OunceForceInch", "OunceForceInches", BaseUnits.Undefined);
yield return new (TorqueUnit.PoundalFoot, "PoundalFoot", "PoundalFeet", BaseUnits.Undefined);
yield return new (TorqueUnit.PoundForceFoot, "PoundForceFoot", "PoundForceFeet", BaseUnits.Undefined);
yield return new (TorqueUnit.PoundForceInch, "PoundForceInch", "PoundForceInches", BaseUnits.Undefined);
@@ -349,6 +351,16 @@ public Torque(double value, UnitSystem unitSystem)
///
public double NewtonMillimeters => As(TorqueUnit.NewtonMillimeter);
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double OunceForceFeet => As(TorqueUnit.OunceForceFoot);
+
+ ///
+ /// Gets a value of this quantity converted into
+ ///
+ public double OunceForceInches => As(TorqueUnit.OunceForceInch);
+
///
/// Gets a value of this quantity converted into
///
@@ -408,6 +420,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter)
unitConverter.SetConversionFunction(TorqueUnit.MegapoundForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
unitConverter.SetConversionFunction(TorqueUnit.NewtonCentimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMillimeter, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
+ unitConverter.SetConversionFunction(TorqueUnit.OunceForceFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
+ unitConverter.SetConversionFunction(TorqueUnit.OunceForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
unitConverter.SetConversionFunction(TorqueUnit.PoundalFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
unitConverter.SetConversionFunction(TorqueUnit.PoundForceFoot, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
unitConverter.SetConversionFunction(TorqueUnit.PoundForceInch, TorqueUnit.NewtonMeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMeter));
@@ -437,6 +451,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter)
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceInch, quantity => quantity.ToUnit(TorqueUnit.MegapoundForceInch));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.NewtonCentimeter, quantity => quantity.ToUnit(TorqueUnit.NewtonCentimeter));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.NewtonMillimeter, quantity => quantity.ToUnit(TorqueUnit.NewtonMillimeter));
+ unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.OunceForceFoot, quantity => quantity.ToUnit(TorqueUnit.OunceForceFoot));
+ unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.OunceForceInch, quantity => quantity.ToUnit(TorqueUnit.OunceForceInch));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.PoundalFoot, quantity => quantity.ToUnit(TorqueUnit.PoundalFoot));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceFoot, quantity => quantity.ToUnit(TorqueUnit.PoundForceFoot));
unitConverter.SetConversionFunction(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceInch, quantity => quantity.ToUnit(TorqueUnit.PoundForceInch));
@@ -622,6 +638,22 @@ public static Torque FromNewtonMillimeters(double value)
return new Torque(value, TorqueUnit.NewtonMillimeter);
}
+ ///
+ /// Creates a from .
+ ///
+ public static Torque FromOunceForceFeet(double value)
+ {
+ return new Torque(value, TorqueUnit.OunceForceFoot);
+ }
+
+ ///
+ /// Creates a from .
+ ///
+ public static Torque FromOunceForceInches(double value)
+ {
+ return new Torque(value, TorqueUnit.OunceForceInch);
+ }
+
///
/// Creates a from .
///
@@ -1127,6 +1159,8 @@ private bool TryToUnit(TorqueUnit unit, [NotNullWhen(true)] out Torque? converte
(TorqueUnit.MegapoundForceInch, TorqueUnit.NewtonMeter) => new Torque((_value * 4.4482216152605 * 2.54e-2) * 1e6d, TorqueUnit.NewtonMeter),
(TorqueUnit.NewtonCentimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 0.01, TorqueUnit.NewtonMeter),
(TorqueUnit.NewtonMillimeter, TorqueUnit.NewtonMeter) => new Torque(_value * 0.001, TorqueUnit.NewtonMeter),
+ (TorqueUnit.OunceForceFoot, TorqueUnit.NewtonMeter) => new Torque(_value * (4.4482216152605 / 16) * 0.3048, TorqueUnit.NewtonMeter),
+ (TorqueUnit.OunceForceInch, TorqueUnit.NewtonMeter) => new Torque(_value * (4.4482216152605 / 16) * 2.54e-2, TorqueUnit.NewtonMeter),
(TorqueUnit.PoundalFoot, TorqueUnit.NewtonMeter) => new Torque(_value * 0.138254954376 * 0.3048, TorqueUnit.NewtonMeter),
(TorqueUnit.PoundForceFoot, TorqueUnit.NewtonMeter) => new Torque(_value * 4.4482216152605 * 0.3048, TorqueUnit.NewtonMeter),
(TorqueUnit.PoundForceInch, TorqueUnit.NewtonMeter) => new Torque(_value * 4.4482216152605 * 2.54e-2, TorqueUnit.NewtonMeter),
@@ -1153,6 +1187,8 @@ private bool TryToUnit(TorqueUnit unit, [NotNullWhen(true)] out Torque? converte
(TorqueUnit.NewtonMeter, TorqueUnit.MegapoundForceInch) => new Torque((_value / (4.4482216152605 * 2.54e-2)) / 1e6d, TorqueUnit.MegapoundForceInch),
(TorqueUnit.NewtonMeter, TorqueUnit.NewtonCentimeter) => new Torque(_value * 100, TorqueUnit.NewtonCentimeter),
(TorqueUnit.NewtonMeter, TorqueUnit.NewtonMillimeter) => new Torque(_value * 1000, TorqueUnit.NewtonMillimeter),
+ (TorqueUnit.NewtonMeter, TorqueUnit.OunceForceFoot) => new Torque(_value / ((4.4482216152605 / 16) * 0.3048), TorqueUnit.OunceForceFoot),
+ (TorqueUnit.NewtonMeter, TorqueUnit.OunceForceInch) => new Torque(_value / ((4.4482216152605 / 16) * 2.54e-2), TorqueUnit.OunceForceInch),
(TorqueUnit.NewtonMeter, TorqueUnit.PoundalFoot) => new Torque(_value / (0.138254954376 * 0.3048), TorqueUnit.PoundalFoot),
(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceFoot) => new Torque(_value / (4.4482216152605 * 0.3048), TorqueUnit.PoundForceFoot),
(TorqueUnit.NewtonMeter, TorqueUnit.PoundForceInch) => new Torque(_value / (4.4482216152605 * 2.54e-2), TorqueUnit.PoundForceInch),
diff --git a/UnitsNet/GeneratedCode/Resources/Torque.restext b/UnitsNet/GeneratedCode/Resources/Torque.restext
index ce23b5c2b3..e884b3a0c8 100644
--- a/UnitsNet/GeneratedCode/Resources/Torque.restext
+++ b/UnitsNet/GeneratedCode/Resources/Torque.restext
@@ -17,6 +17,8 @@ MegapoundForceInches=Mlbf·in
NewtonCentimeters=N·cm
NewtonMeters=N·m
NewtonMillimeters=N·mm
+OunceForceFeet=ozf·ft
+OunceForceInches=ozf·in
PoundalFeet=pdl·ft
PoundForceFeet=lbf·ft
PoundForceInches=lbf·in
diff --git a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
index 74ad9eb231..5244b7b15c 100644
--- a/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/TorqueUnit.g.cs
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
//
// This code was generated by \generate-code.bat.
//
@@ -44,6 +44,8 @@ public enum TorqueUnit
NewtonCentimeter = 17,
NewtonMeter = 18,
NewtonMillimeter = 19,
+ OunceForceFoot = 26,
+ OunceForceInch = 27,
PoundalFoot = 20,
PoundForceFoot = 21,
PoundForceInch = 22,