From b748d2170b8f8ec9a90b765183c6af5cbb2f2452 Mon Sep 17 00:00:00 2001 From: tongbong Date: Mon, 29 Feb 2016 17:41:25 +0100 Subject: [PATCH] Add more units for ForceChangeRate --- .../CustomCode/ForceChangeRateTests.cs | 7 +- .../ForceChangeRateTestsBase.g.cs | 36 ++++++ .../Enums/ForceChangeRateUnit.g.cs | 6 + .../UnitClasses/ForceChangeRate.g.cs | 120 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 30 +++++ .../UnitDefinitions/ForceChangeRate.json | 1 + 6 files changed, 199 insertions(+), 1 deletion(-) diff --git a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs index cc58539eff..3276019844 100644 --- a/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs @@ -23,7 +23,12 @@ namespace UnitsNet.Tests.CustomCode { public class ForceChangeRateTests : ForceChangeRateTestsBase { - // TODO Override properties in base class here + protected override double KilonewtonsPerSecondInOneNewtonPerSecond => 1E-3; protected override double NewtonsPerSecondInOneNewtonPerSecond => 1; + protected override double DecinewtonsPerSecondInOneNewtonPerSecond => 1E1; + protected override double CentinewtonsPerSecondInOneNewtonPerSecond => 1E2; + protected override double MillinewtonsPerSecondInOneNewtonPerSecond => 1E3; + protected override double MicronewtonsPerSecondInOneNewtonPerSecond => 1E6; + protected override double NanonewtonsPerSecondInOneNewtonPerSecond => 1E9; } } \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index c521f78f26..8cdac4b27e 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -36,9 +36,21 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class ForceChangeRateTestsBase { + protected abstract double CentinewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double DecinewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double KilonewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double MicronewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double MillinewtonsPerSecondInOneNewtonPerSecond { get; } + protected abstract double NanonewtonsPerSecondInOneNewtonPerSecond { get; } protected abstract double NewtonsPerSecondInOneNewtonPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double CentinewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double DecinewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double KilonewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MicronewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double MillinewtonsPerSecondTolerance { get { return 1e-5; } } + protected virtual double NanonewtonsPerSecondTolerance { get { return 1e-5; } } protected virtual double NewtonsPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -46,12 +58,24 @@ public abstract partial class ForceChangeRateTestsBase public void NewtonPerSecondToForceChangeRateUnits() { ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); + Assert.AreEqual(CentinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.CentinewtonsPerSecond, CentinewtonsPerSecondTolerance); + Assert.AreEqual(DecinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.DecinewtonsPerSecond, DecinewtonsPerSecondTolerance); + Assert.AreEqual(KilonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.KilonewtonsPerSecond, KilonewtonsPerSecondTolerance); + Assert.AreEqual(MicronewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.MicronewtonsPerSecond, MicronewtonsPerSecondTolerance); + Assert.AreEqual(MillinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.MillinewtonsPerSecond, MillinewtonsPerSecondTolerance); + Assert.AreEqual(NanonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.NanonewtonsPerSecond, NanonewtonsPerSecondTolerance); Assert.AreEqual(NewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.NewtonsPerSecond, NewtonsPerSecondTolerance); } [Test] public void FromValueAndUnit() { + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.CentinewtonPerSecond).CentinewtonsPerSecond, CentinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.DecinewtonPerSecond).DecinewtonsPerSecond, DecinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.KilonewtonPerSecond).KilonewtonsPerSecond, KilonewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.MicronewtonPerSecond).MicronewtonsPerSecond, MicronewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.MillinewtonPerSecond).MillinewtonsPerSecond, MillinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.NanonewtonPerSecond).NanonewtonsPerSecond, NanonewtonsPerSecondTolerance); Assert.AreEqual(1, ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance); } @@ -59,6 +83,12 @@ public void FromValueAndUnit() public void As() { var newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); + Assert.AreEqual(CentinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.CentinewtonPerSecond), CentinewtonsPerSecondTolerance); + Assert.AreEqual(DecinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.DecinewtonPerSecond), DecinewtonsPerSecondTolerance); + Assert.AreEqual(KilonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.KilonewtonPerSecond), KilonewtonsPerSecondTolerance); + Assert.AreEqual(MicronewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.MicronewtonPerSecond), MicronewtonsPerSecondTolerance); + Assert.AreEqual(MillinewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.MillinewtonPerSecond), MillinewtonsPerSecondTolerance); + Assert.AreEqual(NanonewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.NanonewtonPerSecond), NanonewtonsPerSecondTolerance); Assert.AreEqual(NewtonsPerSecondInOneNewtonPerSecond, newtonpersecond.As(ForceChangeRateUnit.NewtonPerSecond), NewtonsPerSecondTolerance); } @@ -66,6 +96,12 @@ public void As() public void ConversionRoundTrip() { ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); + Assert.AreEqual(1, ForceChangeRate.FromCentinewtonsPerSecond(newtonpersecond.CentinewtonsPerSecond).NewtonsPerSecond, CentinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.FromDecinewtonsPerSecond(newtonpersecond.DecinewtonsPerSecond).NewtonsPerSecond, DecinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.FromKilonewtonsPerSecond(newtonpersecond.KilonewtonsPerSecond).NewtonsPerSecond, KilonewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.FromMicronewtonsPerSecond(newtonpersecond.MicronewtonsPerSecond).NewtonsPerSecond, MicronewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.FromMillinewtonsPerSecond(newtonpersecond.MillinewtonsPerSecond).NewtonsPerSecond, MillinewtonsPerSecondTolerance); + Assert.AreEqual(1, ForceChangeRate.FromNanonewtonsPerSecond(newtonpersecond.NanonewtonsPerSecond).NewtonsPerSecond, NanonewtonsPerSecondTolerance); Assert.AreEqual(1, ForceChangeRate.FromNewtonsPerSecond(newtonpersecond.NewtonsPerSecond).NewtonsPerSecond, NewtonsPerSecondTolerance); } diff --git a/UnitsNet/GeneratedCode/Enums/ForceChangeRateUnit.g.cs b/UnitsNet/GeneratedCode/Enums/ForceChangeRateUnit.g.cs index de6b503add..a1a1996592 100644 --- a/UnitsNet/GeneratedCode/Enums/ForceChangeRateUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/ForceChangeRateUnit.g.cs @@ -25,6 +25,12 @@ namespace UnitsNet.Units public enum ForceChangeRateUnit { Undefined = 0, + CentinewtonPerSecond, + DecinewtonPerSecond, + KilonewtonPerSecond, + MicronewtonPerSecond, + MillinewtonPerSecond, + NanonewtonPerSecond, NewtonPerSecond, } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 3fec0d7ad0..2db204a23c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -54,6 +54,54 @@ public static ForceChangeRateUnit BaseUnit get { return ForceChangeRateUnit.NewtonPerSecond; } } + /// + /// Get ForceChangeRate in CentinewtonsPerSecond. + /// + public double CentinewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e-2d; } + } + + /// + /// Get ForceChangeRate in DecinewtonsPerSecond. + /// + public double DecinewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e-1d; } + } + + /// + /// Get ForceChangeRate in KilonewtonsPerSecond. + /// + public double KilonewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e3d; } + } + + /// + /// Get ForceChangeRate in MicronewtonsPerSecond. + /// + public double MicronewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e-6d; } + } + + /// + /// Get ForceChangeRate in MillinewtonsPerSecond. + /// + public double MillinewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e-3d; } + } + + /// + /// Get ForceChangeRate in NanonewtonsPerSecond. + /// + public double NanonewtonsPerSecond + { + get { return (_newtonsPerSecond) / 1e-9d; } + } + /// /// Get ForceChangeRate in NewtonsPerSecond. /// @@ -71,6 +119,54 @@ public static ForceChangeRate Zero get { return new ForceChangeRate(); } } + /// + /// Get ForceChangeRate from CentinewtonsPerSecond. + /// + public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonspersecond) + { + return new ForceChangeRate((centinewtonspersecond) * 1e-2d); + } + + /// + /// Get ForceChangeRate from DecinewtonsPerSecond. + /// + public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonspersecond) + { + return new ForceChangeRate((decinewtonspersecond) * 1e-1d); + } + + /// + /// Get ForceChangeRate from KilonewtonsPerSecond. + /// + public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonspersecond) + { + return new ForceChangeRate((kilonewtonspersecond) * 1e3d); + } + + /// + /// Get ForceChangeRate from MicronewtonsPerSecond. + /// + public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonspersecond) + { + return new ForceChangeRate((micronewtonspersecond) * 1e-6d); + } + + /// + /// Get ForceChangeRate from MillinewtonsPerSecond. + /// + public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonspersecond) + { + return new ForceChangeRate((millinewtonspersecond) * 1e-3d); + } + + /// + /// Get ForceChangeRate from NanonewtonsPerSecond. + /// + public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonspersecond) + { + return new ForceChangeRate((nanonewtonspersecond) * 1e-9d); + } + /// /// Get ForceChangeRate from NewtonsPerSecond. /// @@ -90,6 +186,18 @@ public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit) { switch (fromUnit) { + case ForceChangeRateUnit.CentinewtonPerSecond: + return FromCentinewtonsPerSecond(value); + case ForceChangeRateUnit.DecinewtonPerSecond: + return FromDecinewtonsPerSecond(value); + case ForceChangeRateUnit.KilonewtonPerSecond: + return FromKilonewtonsPerSecond(value); + case ForceChangeRateUnit.MicronewtonPerSecond: + return FromMicronewtonsPerSecond(value); + case ForceChangeRateUnit.MillinewtonPerSecond: + return FromMillinewtonsPerSecond(value); + case ForceChangeRateUnit.NanonewtonPerSecond: + return FromNanonewtonsPerSecond(value); case ForceChangeRateUnit.NewtonPerSecond: return FromNewtonsPerSecond(value); @@ -225,6 +333,18 @@ public double As(ForceChangeRateUnit unit) { switch (unit) { + case ForceChangeRateUnit.CentinewtonPerSecond: + return CentinewtonsPerSecond; + case ForceChangeRateUnit.DecinewtonPerSecond: + return DecinewtonsPerSecond; + case ForceChangeRateUnit.KilonewtonPerSecond: + return KilonewtonsPerSecond; + case ForceChangeRateUnit.MicronewtonPerSecond: + return MicronewtonsPerSecond; + case ForceChangeRateUnit.MillinewtonPerSecond: + return MillinewtonsPerSecond; + case ForceChangeRateUnit.NanonewtonPerSecond: + return NanonewtonsPerSecond; case ForceChangeRateUnit.NewtonPerSecond: return NewtonsPerSecond; diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 93920aace2..8248e293b7 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -613,6 +613,36 @@ private static readonly ReadOnlyCollection DefaultLocalization new UnitLocalization(typeof (ForceChangeRateUnit), new[] { + new CulturesForEnumValue((int) ForceChangeRateUnit.CentinewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "cN/s"), + }), + new CulturesForEnumValue((int) ForceChangeRateUnit.DecinewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "dN/s"), + }), + new CulturesForEnumValue((int) ForceChangeRateUnit.KilonewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "kN/s"), + }), + new CulturesForEnumValue((int) ForceChangeRateUnit.MicronewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "μN/s"), + }), + new CulturesForEnumValue((int) ForceChangeRateUnit.MillinewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "mN/s"), + }), + new CulturesForEnumValue((int) ForceChangeRateUnit.NanonewtonPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "nN/s"), + }), new CulturesForEnumValue((int) ForceChangeRateUnit.NewtonPerSecond, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/ForceChangeRate.json b/UnitsNet/Scripts/UnitDefinitions/ForceChangeRate.json index 7d6d131eee..ef1e9f0878 100644 --- a/UnitsNet/Scripts/UnitDefinitions/ForceChangeRate.json +++ b/UnitsNet/Scripts/UnitDefinitions/ForceChangeRate.json @@ -8,6 +8,7 @@ "PluralName": "NewtonsPerSecond", "FromUnitToBaseFunc": "x", "FromBaseToUnitFunc": "x", + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo" ], "Localization": [ { "Culture": "en-US",