angularsen · angularsen · Feb 29, 2016 · Feb 29, 2016
diff --git 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;
     }
 }
diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs
@@ -36,36 +36,72 @@ 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
 
         [Test]
         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);
         }
 
         [Test]
         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);
         }
 
         [Test]
         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
@@ -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
@@ -54,6 +54,54 @@ public static ForceChangeRateUnit BaseUnit
             get { return ForceChangeRateUnit.NewtonPerSecond; }
         }
 
+        /// <summary>
+        ///     Get ForceChangeRate in CentinewtonsPerSecond.
+        /// </summary>
+        public double CentinewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e-2d; }
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate in DecinewtonsPerSecond.
+        /// </summary>
+        public double DecinewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e-1d; }
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate in KilonewtonsPerSecond.
+        /// </summary>
+        public double KilonewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e3d; }
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate in MicronewtonsPerSecond.
+        /// </summary>
+        public double MicronewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e-6d; }
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate in MillinewtonsPerSecond.
+        /// </summary>
+        public double MillinewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e-3d; }
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate in NanonewtonsPerSecond.
+        /// </summary>
+        public double NanonewtonsPerSecond
+        {
+            get { return (_newtonsPerSecond) / 1e-9d; }
+        }
+
         /// <summary>
         ///     Get ForceChangeRate in NewtonsPerSecond.
         /// </summary>
@@ -71,6 +119,54 @@ public static ForceChangeRate Zero
             get { return new ForceChangeRate(); }
         }
 
+        /// <summary>
+        ///     Get ForceChangeRate from CentinewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonspersecond)
+        {
+            return new ForceChangeRate((centinewtonspersecond) * 1e-2d);
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate from DecinewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonspersecond)
+        {
+            return new ForceChangeRate((decinewtonspersecond) * 1e-1d);
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate from KilonewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonspersecond)
+        {
+            return new ForceChangeRate((kilonewtonspersecond) * 1e3d);
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate from MicronewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonspersecond)
+        {
+            return new ForceChangeRate((micronewtonspersecond) * 1e-6d);
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate from MillinewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonspersecond)
+        {
+            return new ForceChangeRate((millinewtonspersecond) * 1e-3d);
+        }
+
+        /// <summary>
+        ///     Get ForceChangeRate from NanonewtonsPerSecond.
+        /// </summary>
+        public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonspersecond)
+        {
+            return new ForceChangeRate((nanonewtonspersecond) * 1e-9d);
+        }
+
         /// <summary>
         ///     Get ForceChangeRate from NewtonsPerSecond.
         /// </summary>
@@ -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
@@ -613,6 +613,36 @@ private static readonly ReadOnlyCollection<UnitLocalization> 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
@@ -8,6 +8,7 @@
       "PluralName": "NewtonsPerSecond",
       "FromUnitToBaseFunc": "x",
       "FromBaseToUnitFunc": "x",
+      "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo" ],
       "Localization": [
         {
           "Culture": "en-US",