From 0232bea32509699b62ea0f997c2ff0e057459bd0 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Mon, 14 Dec 2015 14:51:00 +0100
Subject: [PATCH 1/4] Added mass flow, specific energy and some units

---
 ...nitsNet.Serialization.JsonNet.Tests.csproj |   3 +
 UnitsNet.Tests/CustomCode/AngleTests.cs       |  16 +
 UnitsNet.Tests/CustomCode/LengthTests.cs      |   8 +
 .../CustomCode/RotationalSpeedTests.cs        |  10 +
 UnitsNet.Tests/CustomCode/SpeedTests.cs       |   9 +
 .../GeneratedCode/AngleTestsBase.g.cs         |  12 +
 .../GeneratedCode/LengthTestsBase.g.cs        |   6 +
 .../RotationalSpeedTestsBase.g.cs             |   6 +
 .../SpecificEnergyTestsBase.g.cs              | 203 +++++++
 .../GeneratedCode/SpeedTestsBase.g.cs         |   6 +
 UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs   |   2 +
 UnitsNet/GeneratedCode/Enums/LengthUnit.g.cs  |   1 +
 .../GeneratedCode/Enums/MassFlowUnit.g.cs     |  31 ++
 .../Enums/RotationalSpeedUnit.g.cs            |   1 +
 .../Enums/SpecificEnergyUnit.g.cs             |  36 ++
 UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs   |   1 +
 UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs |  40 ++
 .../GeneratedCode/UnitClasses/Length.g.cs     |  20 +
 .../GeneratedCode/UnitClasses/MassFlow.g.cs   | 412 ++++++++++++++
 .../UnitClasses/RotationalSpeed.g.cs          |  20 +
 .../UnitClasses/SpecificEnergy.g.cs           | 512 ++++++++++++++++++
 UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs |  20 +
 .../GeneratedCode/UnitSystem.Default.g.cs     |  79 +++
 UnitsNet/Scripts/UnitDefinitions/Angle.json   |  26 +-
 UnitsNet/Scripts/UnitDefinitions/Length.json  |  16 +
 .../Scripts/UnitDefinitions/MassFlow.json     |  31 ++
 .../UnitDefinitions/RotationalSpeed.json      |  14 +-
 .../UnitDefinitions/SpecificEnergy.json       |  47 ++
 UnitsNet/Scripts/UnitDefinitions/Speed.json   |  12 +
 29 files changed, 1598 insertions(+), 2 deletions(-)
 create mode 100644 UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
 create mode 100644 UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
 create mode 100644 UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
 create mode 100644 UnitsNet/Scripts/UnitDefinitions/MassFlow.json
 create mode 100644 UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
index d24fc02fc6..7d6fe10699 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
@@ -67,6 +67,9 @@
       <Name>UnitsNet.Net35</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index 965e3c5364..59f9ff86a9 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -35,9 +35,25 @@ protected override double GradiansInOneDegree
             get { return 400/360.0; }
         }
 
+        protected override double MinutesOfArcInOneDegree
+        {
+            get
+            {
+                return 60.0;
+            }
+        }
+
         protected override double RadiansInOneDegree
         {
             get { return Math.PI/2/90; }
         }
+
+        protected override double SecondsOfArcInOneDegree
+        {
+            get
+            {
+                return 3600.0;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index a880495060..0d4d3d3a2d 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -19,6 +19,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using System;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class LengthTests : LengthTestsBase
@@ -87,5 +89,11 @@ protected override double YardsInOneMeter
         {
             get { return 1.09361; }
         }
+
+        protected override double NauticalMilesInOneMeter
+        {
+            get
+            { return 5.3996E-04; }
+        }
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index 264b42680d..9d0e934f83 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -19,10 +19,20 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using System;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class RotationalSpeedTests : RotationalSpeedTestsBase
     {
+        protected override double RadiansPerSecondInOneRevolutionPerSecond
+        {
+            get
+            {
+                return 2 * Math.PI;
+            }
+        }
+
         protected override double RevolutionsPerMinuteInOneRevolutionPerSecond
         {
             get { return 1.0*60; }
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 38db48de94..ec3c549715 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -19,6 +19,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using System;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class SpeedTests : SpeedTestsBase
@@ -79,5 +81,12 @@ protected override double KilometersPerSecondInOneMeterPerSecond
             get { return 1E-3; }
         }
 
+        protected override double MetersPerHourInOneMeterPerSecond
+        {
+            get
+            {
+                return 3600.0;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
index 4a6735d542..864ef2cb34 100644
--- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
@@ -38,12 +38,16 @@ public abstract partial class AngleTestsBase
     {
         protected abstract double DegreesInOneDegree { get; }
         protected abstract double GradiansInOneDegree { get; }
+        protected abstract double MinutesOfArcInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
+        protected abstract double SecondsOfArcInOneDegree { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double DegreesTolerance { get { return 1e-5; } }
         protected virtual double GradiansTolerance { get { return 1e-5; } }
+        protected virtual double MinutesOfArcTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
+        protected virtual double SecondsOfArcTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
@@ -52,7 +56,9 @@ public void DegreeToAngleUnits()
             Angle degree = Angle.FromDegrees(1);
             Assert.AreEqual(DegreesInOneDegree, degree.Degrees, DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.Gradians, GradiansTolerance);
+            Assert.AreEqual(MinutesOfArcInOneDegree, degree.MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.Radians, RadiansTolerance);
+            Assert.AreEqual(SecondsOfArcInOneDegree, degree.SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
@@ -60,7 +66,9 @@ public void FromValueAndUnit()
         {
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Degree).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Gradian).Gradians, GradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.MinuteOfArc).MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.SecondOfArc).SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
@@ -69,7 +77,9 @@ public void As()
             var degree = Angle.FromDegrees(1);
             Assert.AreEqual(DegreesInOneDegree, degree.As(AngleUnit.Degree), DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.As(AngleUnit.Gradian), GradiansTolerance);
+            Assert.AreEqual(MinutesOfArcInOneDegree, degree.As(AngleUnit.MinuteOfArc), MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
+            Assert.AreEqual(SecondsOfArcInOneDegree, degree.As(AngleUnit.SecondOfArc), SecondsOfArcTolerance);
         }
 
         [Test]
@@ -78,7 +88,9 @@ public void ConversionRoundTrip()
             Angle degree = Angle.FromDegrees(1);
             Assert.AreEqual(1, Angle.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
+            Assert.AreEqual(1, Angle.FromMinutesOfArc(degree.MinutesOfArc).Degrees, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
+            Assert.AreEqual(1, Angle.FromSecondsOfArc(degree.SecondsOfArc).Degrees, SecondsOfArcTolerance);
         }
 
         [Test]
diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
index 200e7e538e..a7f4b0a82f 100644
--- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
@@ -48,6 +48,7 @@ public abstract partial class LengthTestsBase
         protected abstract double MilesInOneMeter { get; }
         protected abstract double MillimetersInOneMeter { get; }
         protected abstract double NanometersInOneMeter { get; }
+        protected abstract double NauticalMilesInOneMeter { get; }
         protected abstract double YardsInOneMeter { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
@@ -63,6 +64,7 @@ public abstract partial class LengthTestsBase
         protected virtual double MilesTolerance { get { return 1e-5; } }
         protected virtual double MillimetersTolerance { get { return 1e-5; } }
         protected virtual double NanometersTolerance { get { return 1e-5; } }
+        protected virtual double NauticalMilesTolerance { get { return 1e-5; } }
         protected virtual double YardsTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
@@ -82,6 +84,7 @@ public void MeterToLengthUnits()
             Assert.AreEqual(MilesInOneMeter, meter.Miles, MilesTolerance);
             Assert.AreEqual(MillimetersInOneMeter, meter.Millimeters, MillimetersTolerance);
             Assert.AreEqual(NanometersInOneMeter, meter.Nanometers, NanometersTolerance);
+            Assert.AreEqual(NauticalMilesInOneMeter, meter.NauticalMiles, NauticalMilesTolerance);
             Assert.AreEqual(YardsInOneMeter, meter.Yards, YardsTolerance);
         }
 
@@ -100,6 +103,7 @@ public void FromValueAndUnit()
             Assert.AreEqual(1, Length.From(1, LengthUnit.Mile).Miles, MilesTolerance);
             Assert.AreEqual(1, Length.From(1, LengthUnit.Millimeter).Millimeters, MillimetersTolerance);
             Assert.AreEqual(1, Length.From(1, LengthUnit.Nanometer).Nanometers, NanometersTolerance);
+            Assert.AreEqual(1, Length.From(1, LengthUnit.NauticalMile).NauticalMiles, NauticalMilesTolerance);
             Assert.AreEqual(1, Length.From(1, LengthUnit.Yard).Yards, YardsTolerance);
         }
 
@@ -119,6 +123,7 @@ public void As()
             Assert.AreEqual(MilesInOneMeter, meter.As(LengthUnit.Mile), MilesTolerance);
             Assert.AreEqual(MillimetersInOneMeter, meter.As(LengthUnit.Millimeter), MillimetersTolerance);
             Assert.AreEqual(NanometersInOneMeter, meter.As(LengthUnit.Nanometer), NanometersTolerance);
+            Assert.AreEqual(NauticalMilesInOneMeter, meter.As(LengthUnit.NauticalMile), NauticalMilesTolerance);
             Assert.AreEqual(YardsInOneMeter, meter.As(LengthUnit.Yard), YardsTolerance);
         }
 
@@ -138,6 +143,7 @@ public void ConversionRoundTrip()
             Assert.AreEqual(1, Length.FromMiles(meter.Miles).Meters, MilesTolerance);
             Assert.AreEqual(1, Length.FromMillimeters(meter.Millimeters).Meters, MillimetersTolerance);
             Assert.AreEqual(1, Length.FromNanometers(meter.Nanometers).Meters, NanometersTolerance);
+            Assert.AreEqual(1, Length.FromNauticalMiles(meter.NauticalMiles).Meters, NauticalMilesTolerance);
             Assert.AreEqual(1, Length.FromYards(meter.Yards).Meters, YardsTolerance);
         }
 
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
index fa01f014e9..c19e55c6aa 100644
--- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
@@ -36,10 +36,12 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class RotationalSpeedTestsBase
     {
+        protected abstract double RadiansPerSecondInOneRevolutionPerSecond { get; }
         protected abstract double RevolutionsPerMinuteInOneRevolutionPerSecond { get; }
         protected abstract double RevolutionsPerSecondInOneRevolutionPerSecond { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } }
         protected virtual double RevolutionsPerMinuteTolerance { get { return 1e-5; } }
         protected virtual double RevolutionsPerSecondTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
@@ -48,6 +50,7 @@ public abstract partial class RotationalSpeedTestsBase
         public void RevolutionPerSecondToRotationalSpeedUnits()
         {
             RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1);
+            Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerMinute, RevolutionsPerMinuteTolerance);
             Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerSecond, RevolutionsPerSecondTolerance);
         }
@@ -55,6 +58,7 @@ public void RevolutionPerSecondToRotationalSpeedUnits()
         [Test]
         public void FromValueAndUnit()
         {
+            Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute).RevolutionsPerMinute, RevolutionsPerMinuteTolerance);
             Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance);
         }
@@ -63,6 +67,7 @@ public void FromValueAndUnit()
         public void As()
         {
             var revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1);
+            Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RadianPerSecond), RadiansPerSecondTolerance);
             Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerMinute), RevolutionsPerMinuteTolerance);
             Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerSecond), RevolutionsPerSecondTolerance);
         }
@@ -71,6 +76,7 @@ public void As()
         public void ConversionRoundTrip()
         {
             RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1);
+            Assert.AreEqual(1, RotationalSpeed.FromRadiansPerSecond(revolutionpersecond.RadiansPerSecond).RevolutionsPerSecond, RadiansPerSecondTolerance);
             Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(revolutionpersecond.RevolutionsPerMinute).RevolutionsPerSecond, RevolutionsPerMinuteTolerance);
             Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(revolutionpersecond.RevolutionsPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance);
         }
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
new file mode 100644
index 0000000000..3abbda3723
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
@@ -0,0 +1,203 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using NUnit.Framework;
+using UnitsNet.Units;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of SpecificEnergy.
+    /// </summary>
+    [TestFixture]
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class SpecificEnergyTestsBase
+    {
+        protected abstract double JoulesPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double KiloCaloriesPerGramInOneJoulePerKiloGram { get; }
+        protected abstract double KilojoulesPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double KilowattHoursPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double MegajoulesPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double MegawattHoursPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double WattHoursPerKiloGramInOneJoulePerKiloGram { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double JoulesPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double KiloCaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double KilowattHoursPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double MegawattHoursPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double WattHoursPerKiloGramTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Test]
+        public void JoulePerKiloGramToSpecificEnergyUnits()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
+            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
+            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
+            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
+            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+        }
+
+        [Test]
+        public void FromValueAndUnit()
+        {
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KiloCaloriePerGram).KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKiloGram).KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKiloGram).KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKiloGram).MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKiloGram).MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKiloGram).WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+        }
+
+        [Test]
+        public void As()
+        {
+            var jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKiloGram), JoulesPerKiloGramTolerance);
+            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KiloCaloriePerGram), KiloCaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKiloGram), KilojoulesPerKiloGramTolerance);
+            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKiloGram), KilowattHoursPerKiloGramTolerance);
+            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKiloGram), MegajoulesPerKiloGramTolerance);
+            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKiloGram), MegawattHoursPerKiloGramTolerance);
+            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKiloGram), WattHoursPerKiloGramTolerance);
+        }
+
+        [Test]
+        public void ConversionRoundTrip()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.AreEqual(1, SpecificEnergy.FromJoulesPerKiloGram(jouleperkilogram.JoulesPerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKiloCaloriesPerGram(jouleperkilogram.KiloCaloriesPerGram).JoulesPerKiloGram, KiloCaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilojoulesPerKiloGram(jouleperkilogram.KilojoulesPerKiloGram).JoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilowattHoursPerKiloGram(jouleperkilogram.KilowattHoursPerKiloGram).JoulesPerKiloGram, KilowattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegajoulesPerKiloGram(jouleperkilogram.MegajoulesPerKiloGram).JoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegawattHoursPerKiloGram(jouleperkilogram.MegawattHoursPerKiloGram).JoulesPerKiloGram, MegawattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromWattHoursPerKiloGram(jouleperkilogram.WattHoursPerKiloGram).JoulesPerKiloGram, WattHoursPerKiloGramTolerance);
+        }
+
+        [Test]
+        public void ArithmeticOperators()
+        {
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.AreEqual(-1, -v.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(3)-v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(2, (v + v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(10, (v*10).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(10, (10*v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(10)/5).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
+            Assert.AreEqual(2, SpecificEnergy.FromJoulesPerKiloGram(10)/SpecificEnergy.FromJoulesPerKiloGram(5), JoulesPerKiloGramTolerance);
+        }
+
+        [Test]
+        public void ComparisonOperators()
+        {
+            SpecificEnergy oneJoulePerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy twoJoulesPerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(2);
+
+            Assert.True(oneJoulePerKiloGram < twoJoulesPerKiloGram);
+            Assert.True(oneJoulePerKiloGram <= twoJoulesPerKiloGram);
+            Assert.True(twoJoulesPerKiloGram > oneJoulePerKiloGram);
+            Assert.True(twoJoulesPerKiloGram >= oneJoulePerKiloGram);
+
+            Assert.False(oneJoulePerKiloGram > twoJoulesPerKiloGram);
+            Assert.False(oneJoulePerKiloGram >= twoJoulesPerKiloGram);
+            Assert.False(twoJoulesPerKiloGram < oneJoulePerKiloGram);
+            Assert.False(twoJoulesPerKiloGram <= oneJoulePerKiloGram);
+        }
+
+        [Test]
+        public void CompareToIsImplemented()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.AreEqual(0, jouleperkilogram.CompareTo(jouleperkilogram));
+            Assert.Greater(jouleperkilogram.CompareTo(SpecificEnergy.Zero), 0);
+            Assert.Less(SpecificEnergy.Zero.CompareTo(jouleperkilogram), 0);
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentException))]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            jouleperkilogram.CompareTo(new object());
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void CompareToThrowsOnNull()
+        { 
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            jouleperkilogram.CompareTo(null);
+        }
+
+
+        [Test]
+        public void EqualityOperators()
+        {
+            SpecificEnergy a = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy b = SpecificEnergy.FromJoulesPerKiloGram(2);
+
+// ReSharper disable EqualExpressionComparison
+            Assert.True(a == a); 
+            Assert.True(a != b);
+
+            Assert.False(a == b);
+            Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Test]
+        public void EqualsIsImplemented()
+        {
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.IsTrue(v.Equals(SpecificEnergy.FromJoulesPerKiloGram(1)));
+            Assert.IsFalse(v.Equals(SpecificEnergy.Zero));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.IsFalse(jouleperkilogram.Equals(new object()));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnNull()
+        {
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            Assert.IsFalse(jouleperkilogram.Equals(null));
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
index dd6ef76e1f..39839231d8 100644
--- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
@@ -42,6 +42,7 @@ public abstract partial class SpeedTestsBase
         protected abstract double KilometersPerHourInOneMeterPerSecond { get; }
         protected abstract double KilometersPerSecondInOneMeterPerSecond { get; }
         protected abstract double KnotsInOneMeterPerSecond { get; }
+        protected abstract double MetersPerHourInOneMeterPerSecond { get; }
         protected abstract double MetersPerSecondInOneMeterPerSecond { get; }
         protected abstract double MicrometersPerSecondInOneMeterPerSecond { get; }
         protected abstract double MilesPerHourInOneMeterPerSecond { get; }
@@ -55,6 +56,7 @@ public abstract partial class SpeedTestsBase
         protected virtual double KilometersPerHourTolerance { get { return 1e-5; } }
         protected virtual double KilometersPerSecondTolerance { get { return 1e-5; } }
         protected virtual double KnotsTolerance { get { return 1e-5; } }
+        protected virtual double MetersPerHourTolerance { get { return 1e-5; } }
         protected virtual double MetersPerSecondTolerance { get { return 1e-5; } }
         protected virtual double MicrometersPerSecondTolerance { get { return 1e-5; } }
         protected virtual double MilesPerHourTolerance { get { return 1e-5; } }
@@ -72,6 +74,7 @@ public void MeterPerSecondToSpeedUnits()
             Assert.AreEqual(KilometersPerHourInOneMeterPerSecond, meterpersecond.KilometersPerHour, KilometersPerHourTolerance);
             Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.KilometersPerSecond, KilometersPerSecondTolerance);
             Assert.AreEqual(KnotsInOneMeterPerSecond, meterpersecond.Knots, KnotsTolerance);
+            Assert.AreEqual(MetersPerHourInOneMeterPerSecond, meterpersecond.MetersPerHour, MetersPerHourTolerance);
             Assert.AreEqual(MetersPerSecondInOneMeterPerSecond, meterpersecond.MetersPerSecond, MetersPerSecondTolerance);
             Assert.AreEqual(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.MicrometersPerSecond, MicrometersPerSecondTolerance);
             Assert.AreEqual(MilesPerHourInOneMeterPerSecond, meterpersecond.MilesPerHour, MilesPerHourTolerance);
@@ -88,6 +91,7 @@ public void FromValueAndUnit()
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerHour).KilometersPerHour, KilometersPerHourTolerance);
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerSecond).KilometersPerSecond, KilometersPerSecondTolerance);
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.Knot).Knots, KnotsTolerance);
+            Assert.AreEqual(1, Speed.From(1, SpeedUnit.MeterPerHour).MetersPerHour, MetersPerHourTolerance);
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.MeterPerSecond).MetersPerSecond, MetersPerSecondTolerance);
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.MicrometerPerSecond).MicrometersPerSecond, MicrometersPerSecondTolerance);
             Assert.AreEqual(1, Speed.From(1, SpeedUnit.MilePerHour).MilesPerHour, MilesPerHourTolerance);
@@ -105,6 +109,7 @@ public void As()
             Assert.AreEqual(KilometersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerHour), KilometersPerHourTolerance);
             Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerSecond), KilometersPerSecondTolerance);
             Assert.AreEqual(KnotsInOneMeterPerSecond, meterpersecond.As(SpeedUnit.Knot), KnotsTolerance);
+            Assert.AreEqual(MetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerHour), MetersPerHourTolerance);
             Assert.AreEqual(MetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerSecond), MetersPerSecondTolerance);
             Assert.AreEqual(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerSecond), MicrometersPerSecondTolerance);
             Assert.AreEqual(MilesPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MilePerHour), MilesPerHourTolerance);
@@ -122,6 +127,7 @@ public void ConversionRoundTrip()
             Assert.AreEqual(1, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance);
             Assert.AreEqual(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance);
             Assert.AreEqual(1, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance);
+            Assert.AreEqual(1, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance);
             Assert.AreEqual(1, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance);
             Assert.AreEqual(1, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance);
             Assert.AreEqual(1, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance);
diff --git a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
index 83d7b5b74f..ac96746f64 100644
--- a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
@@ -27,6 +27,8 @@ public enum AngleUnit
         Undefined = 0,
         Degree,
         Gradian,
+        MinuteOfArc,
         Radian,
+        SecondOfArc,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/LengthUnit.g.cs b/UnitsNet/GeneratedCode/Enums/LengthUnit.g.cs
index 1136b3d77b..3991e1c3eb 100644
--- a/UnitsNet/GeneratedCode/Enums/LengthUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/LengthUnit.g.cs
@@ -37,6 +37,7 @@ public enum LengthUnit
         Mile,
         Millimeter,
         Nanometer,
+        NauticalMile,
         Yard,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
new file mode 100644
index 0000000000..1f7887259e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
@@ -0,0 +1,31 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Units
+{
+    public enum MassFlowUnit
+    {
+        Undefined = 0,
+        KiloGramPerSecond,
+        TonnePerDay,
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs
index 6a585982ab..7f17328fd8 100644
--- a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs
@@ -25,6 +25,7 @@ namespace UnitsNet.Units
     public enum RotationalSpeedUnit
     {
         Undefined = 0,
+        RadianPerSecond,
         RevolutionPerMinute,
         RevolutionPerSecond,
     }
diff --git a/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
new file mode 100644
index 0000000000..09eeb9b8da
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
@@ -0,0 +1,36 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Units
+{
+    public enum SpecificEnergyUnit
+    {
+        Undefined = 0,
+        JoulePerKiloGram,
+        KiloCaloriePerGram,
+        KilojoulePerKiloGram,
+        KilowattHourPerKiloGram,
+        MegajoulePerKiloGram,
+        MegawattHourPerKiloGram,
+        WattHourPerKiloGram,
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs
index dc69664c6e..85d89edaa5 100644
--- a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs
@@ -31,6 +31,7 @@ public enum SpeedUnit
         KilometerPerHour,
         KilometerPerSecond,
         Knot,
+        MeterPerHour,
         MeterPerSecond,
         MicrometerPerSecond,
         MilePerHour,
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
index 1c948afbc3..9f16981d83 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
@@ -70,6 +70,14 @@ public double Gradians
             get { return _degrees/0.9; }
         }
 
+        /// <summary>
+        ///     Get Angle in MinutesOfArc.
+        /// </summary>
+        public double MinutesOfArc
+        {
+            get { return _degrees*60; }
+        }
+
         /// <summary>
         ///     Get Angle in Radians.
         /// </summary>
@@ -78,6 +86,14 @@ public double Radians
             get { return _degrees/180*Math.PI; }
         }
 
+        /// <summary>
+        ///     Get Angle in SecondsOfArc.
+        /// </summary>
+        public double SecondsOfArc
+        {
+            get { return _degrees*3600; }
+        }
+
         #endregion
 
         #region Static 
@@ -103,6 +119,14 @@ public static Angle FromGradians(double gradians)
             return new Angle(gradians*0.9);
         }
 
+        /// <summary>
+        ///     Get Angle from MinutesOfArc.
+        /// </summary>
+        public static Angle FromMinutesOfArc(double minutesofarc)
+        {
+            return new Angle(minutesofarc/60);
+        }
+
         /// <summary>
         ///     Get Angle from Radians.
         /// </summary>
@@ -111,6 +135,14 @@ public static Angle FromRadians(double radians)
             return new Angle(radians*180/Math.PI);
         }
 
+        /// <summary>
+        ///     Get Angle from SecondsOfArc.
+        /// </summary>
+        public static Angle FromSecondsOfArc(double secondsofarc)
+        {
+            return new Angle(secondsofarc/3600);
+        }
+
 
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="AngleUnit" /> to <see cref="Angle" />.
@@ -126,8 +158,12 @@ public static Angle From(double value, AngleUnit fromUnit)
                     return FromDegrees(value);
                 case AngleUnit.Gradian:
                     return FromGradians(value);
+                case AngleUnit.MinuteOfArc:
+                    return FromMinutesOfArc(value);
                 case AngleUnit.Radian:
                     return FromRadians(value);
+                case AngleUnit.SecondOfArc:
+                    return FromSecondsOfArc(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -265,8 +301,12 @@ public double As(AngleUnit unit)
                     return Degrees;
                 case AngleUnit.Gradian:
                     return Gradians;
+                case AngleUnit.MinuteOfArc:
+                    return MinutesOfArc;
                 case AngleUnit.Radian:
                     return Radians;
+                case AngleUnit.SecondOfArc:
+                    return SecondsOfArc;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs
index a39fff52a8..5a74f3bd41 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs
@@ -150,6 +150,14 @@ public double Nanometers
             get { return (_meters) / 1e-9d; }
         }
 
+        /// <summary>
+        ///     Get Length in NauticalMiles.
+        /// </summary>
+        public double NauticalMiles
+        {
+            get { return _meters/1852; }
+        }
+
         /// <summary>
         ///     Get Length in Yards.
         /// </summary>
@@ -263,6 +271,14 @@ public static Length FromNanometers(double nanometers)
             return new Length((nanometers) * 1e-9d);
         }
 
+        /// <summary>
+        ///     Get Length from NauticalMiles.
+        /// </summary>
+        public static Length FromNauticalMiles(double nauticalmiles)
+        {
+            return new Length(nauticalmiles*1852);
+        }
+
         /// <summary>
         ///     Get Length from Yards.
         /// </summary>
@@ -306,6 +322,8 @@ public static Length From(double value, LengthUnit fromUnit)
                     return FromMillimeters(value);
                 case LengthUnit.Nanometer:
                     return FromNanometers(value);
+                case LengthUnit.NauticalMile:
+                    return FromNauticalMiles(value);
                 case LengthUnit.Yard:
                     return FromYards(value);
 
@@ -465,6 +483,8 @@ public double As(LengthUnit unit)
                     return Millimeters;
                 case LengthUnit.Nanometer:
                     return Nanometers;
+                case LengthUnit.NauticalMile:
+                    return NauticalMiles;
                 case LengthUnit.Yard:
                     return Yards;
 
diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
new file mode 100644
index 0000000000..d3b0e38bb4
--- /dev/null
+++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
@@ -0,0 +1,412 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Linq;
+using JetBrains.Annotations;
+using UnitsNet.Units;
+
+// ReSharper disable once CheckNamespace
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     
+    /// </summary>
+    // ReSharper disable once PartialTypeWithSinglePart
+    public partial struct MassFlow : IComparable, IComparable<MassFlow>
+    {
+        /// <summary>
+        ///     Base unit of MassFlow.
+        /// </summary>
+        private readonly double _kiloGramsPerSecond;
+
+        public MassFlow(double kilogramspersecond) : this()
+        {
+            _kiloGramsPerSecond = kilogramspersecond;
+        }
+
+        #region Properties
+
+        public static MassFlowUnit BaseUnit
+        {
+            get { return MassFlowUnit.KiloGramPerSecond; }
+        }
+
+        /// <summary>
+        ///     Get MassFlow in KiloGramsPerSecond.
+        /// </summary>
+        public double KiloGramsPerSecond
+        {
+            get { return _kiloGramsPerSecond; }
+        }
+
+        /// <summary>
+        ///     Get MassFlow in TonnesPerDay.
+        /// </summary>
+        public double TonnesPerDay
+        {
+            get { return _kiloGramsPerSecond/86.4000; }
+        }
+
+        #endregion
+
+        #region Static 
+
+        public static MassFlow Zero
+        {
+            get { return new MassFlow(); }
+        }
+
+        /// <summary>
+        ///     Get MassFlow from KiloGramsPerSecond.
+        /// </summary>
+        public static MassFlow FromKiloGramsPerSecond(double kilogramspersecond)
+        {
+            return new MassFlow(kilogramspersecond);
+        }
+
+        /// <summary>
+        ///     Get MassFlow from TonnesPerDay.
+        /// </summary>
+        public static MassFlow FromTonnesPerDay(double tonnesperday)
+        {
+            return new MassFlow(tonnesperday*86.4000);
+        }
+
+
+        /// <summary>
+        ///     Dynamically convert from value and unit enum <see cref="MassFlowUnit" /> to <see cref="MassFlow" />.
+        /// </summary>
+        /// <param name="value">Value to convert from.</param>
+        /// <param name="fromUnit">Unit to convert from.</param>
+        /// <returns>MassFlow unit value.</returns>
+        public static MassFlow From(double value, MassFlowUnit fromUnit)
+        {
+            switch (fromUnit)
+            {
+                case MassFlowUnit.KiloGramPerSecond:
+                    return FromKiloGramsPerSecond(value);
+                case MassFlowUnit.TonnePerDay:
+                    return FromTonnesPerDay(value);
+
+                default:
+                    throw new NotImplementedException("fromUnit: " + fromUnit);
+            }
+        }
+
+        /// <summary>
+        ///     Get unit abbreviation string.
+        /// </summary>
+        /// <param name="unit">Unit to get abbreviation for.</param>
+        /// <param name="culture">Culture to use for localization. Defaults to Thread.CurrentUICulture.</param>
+        /// <returns>Unit abbreviation string.</returns>
+        [UsedImplicitly]
+        public static string GetAbbreviation(MassFlowUnit unit, CultureInfo culture = null)
+        {
+            return UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit);
+        }
+
+        #endregion
+
+        #region Arithmetic Operators
+
+        public static MassFlow operator -(MassFlow right)
+        {
+            return new MassFlow(-right._kiloGramsPerSecond);
+        }
+
+        public static MassFlow operator +(MassFlow left, MassFlow right)
+        {
+            return new MassFlow(left._kiloGramsPerSecond + right._kiloGramsPerSecond);
+        }
+
+        public static MassFlow operator -(MassFlow left, MassFlow right)
+        {
+            return new MassFlow(left._kiloGramsPerSecond - right._kiloGramsPerSecond);
+        }
+
+        public static MassFlow operator *(double left, MassFlow right)
+        {
+            return new MassFlow(left*right._kiloGramsPerSecond);
+        }
+
+        public static MassFlow operator *(MassFlow left, double right)
+        {
+            return new MassFlow(left._kiloGramsPerSecond*(double)right);
+        }
+
+        public static MassFlow operator /(MassFlow left, double right)
+        {
+            return new MassFlow(left._kiloGramsPerSecond/(double)right);
+        }
+
+        public static double operator /(MassFlow left, MassFlow right)
+        {
+            return Convert.ToDouble(left._kiloGramsPerSecond/right._kiloGramsPerSecond);
+        }
+
+        #endregion
+
+        #region Equality / IComparable
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null) throw new ArgumentNullException("obj");
+            if (!(obj is MassFlow)) throw new ArgumentException("Expected type MassFlow.", "obj");
+            return CompareTo((MassFlow) obj);
+        }
+
+        public int CompareTo(MassFlow other)
+        {
+            return _kiloGramsPerSecond.CompareTo(other._kiloGramsPerSecond);
+        }
+
+        public static bool operator <=(MassFlow left, MassFlow right)
+        {
+            return left._kiloGramsPerSecond <= right._kiloGramsPerSecond;
+        }
+
+        public static bool operator >=(MassFlow left, MassFlow right)
+        {
+            return left._kiloGramsPerSecond >= right._kiloGramsPerSecond;
+        }
+
+        public static bool operator <(MassFlow left, MassFlow right)
+        {
+            return left._kiloGramsPerSecond < right._kiloGramsPerSecond;
+        }
+
+        public static bool operator >(MassFlow left, MassFlow right)
+        {
+            return left._kiloGramsPerSecond > right._kiloGramsPerSecond;
+        }
+
+        public static bool operator ==(MassFlow left, MassFlow right)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return left._kiloGramsPerSecond == right._kiloGramsPerSecond;
+        }
+
+        public static bool operator !=(MassFlow left, MassFlow right)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return left._kiloGramsPerSecond != right._kiloGramsPerSecond;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+
+            return _kiloGramsPerSecond.Equals(((MassFlow) obj)._kiloGramsPerSecond);
+        }
+
+        public override int GetHashCode()
+        {
+            return _kiloGramsPerSecond.GetHashCode();
+        }
+
+        #endregion
+
+        #region Conversion
+
+        /// <summary>
+        ///     Convert to the unit representation <paramref name="unit" />.
+        /// </summary>
+        /// <returns>Value in new unit if successful, exception otherwise.</returns>
+        /// <exception cref="NotImplementedException">If conversion was not successful.</exception>
+        public double As(MassFlowUnit unit)
+        {
+            switch (unit)
+            {
+                case MassFlowUnit.KiloGramPerSecond:
+                    return KiloGramsPerSecond;
+                case MassFlowUnit.TonnePerDay:
+                    return TonnesPerDay;
+
+                default:
+                    throw new NotImplementedException("unit: " + unit);
+            }
+        }
+
+        #endregion
+
+        #region Parsing
+
+        /// <summary>
+        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <example>
+        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="ArgumentException">
+        ///     Expected string to have one or two pairs of quantity and unit in the format
+        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in" 
+        /// </exception>
+        public static MassFlow Parse(string str, IFormatProvider formatProvider = null)
+        {
+            if (str == null) throw new ArgumentNullException("str");
+
+            var numFormat = formatProvider != null ?
+                (NumberFormatInfo) formatProvider.GetFormat(typeof (NumberFormatInfo)) :
+                NumberFormatInfo.CurrentInfo;
+
+            var numRegex = string.Format(@"[\d., {0}{1}]*\d",  // allows digits, dots, commas, and spaces in the quantity (must end in digit)
+                            numFormat.NumberGroupSeparator,    // adds provided (or current) culture's group separator
+                            numFormat.NumberDecimalSeparator); // adds provided (or current) culture's decimal separator
+            var exponentialRegex = @"(?:[eE][-+]?\d+)?)";
+            var regexString = string.Format(@"(?:\s*(?<value>[-+]?{0}{1}{2}{3})?{4}{5}",
+                            numRegex,                // capture base (integral) Quantity value
+                            exponentialRegex,        // capture exponential (if any), end of Quantity capturing
+                            @"\s?",                  // ignore whitespace (allows both "1kg", "1 kg")
+                            @"(?<unit>[^\s\d,]+)",   // capture Unit (non-whitespace) input
+                            @"(and)?,?",             // allow "and" & "," separators between quantities
+                            @"(?<invalid>[a-z]*)?"); // capture invalid input
+
+            var quantities = ParseWithRegex(regexString, str, formatProvider);
+            if (quantities.Count == 0)
+            {
+                throw new ArgumentException(
+                    "Expected string to have at least one pair of quantity and unit in the format"
+                    + " \"&lt;quantity&gt; &lt;unit&gt;\". Eg. \"5.5 m\" or \"1ft 2in\"");
+            }
+            return quantities.Aggregate((x, y) => x + y);
+        }
+
+        /// <summary>
+        ///     Parse a string given a particular regular expression.
+        /// </summary>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        private static List<MassFlow> ParseWithRegex(string regexString, string str, IFormatProvider formatProvider = null)
+        {
+            var regex = new Regex(regexString);
+            MatchCollection matches = regex.Matches(str.Trim());
+            var converted = new List<MassFlow>();
+
+            foreach (Match match in matches)
+            {
+                GroupCollection groups = match.Groups;
+
+                var valueString = groups["value"].Value;
+                var unitString = groups["unit"].Value;
+                if (groups["invalid"].Value != "")
+                {
+                    var newEx = new UnitsNetException("Invalid string detected: " + groups["invalid"].Value);
+                    newEx.Data["input"] = str;
+                    newEx.Data["matched value"] = valueString;
+                    newEx.Data["matched unit"] = unitString;
+                    newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                    throw newEx;
+                }
+                if (valueString == "" && unitString == "") continue;
+
+                try
+                {
+                    MassFlowUnit unit = ParseUnit(unitString, formatProvider);
+                    double value = double.Parse(valueString, formatProvider);
+
+                    converted.Add(From(value, unit));
+                }
+                catch (Exception ex)
+                {
+                    var newEx = new UnitsNetException("Error parsing string.", ex);
+                    newEx.Data["input"] = str;
+                    newEx.Data["matched value"] = valueString;
+                    newEx.Data["matched unit"] = unitString;
+                    newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                    throw newEx;
+                }
+            }
+            return converted;
+        }
+
+        /// <summary>
+        ///     Parse a unit string.
+        /// </summary>
+        /// <example>
+        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider = null)
+        {
+            if (str == null) throw new ArgumentNullException("str");
+            var unitSystem = UnitSystem.GetCached(formatProvider);
+
+            var unit = unitSystem.Parse<MassFlowUnit>(str.Trim());
+
+            if (unit == MassFlowUnit.Undefined)
+            {
+                var newEx = new UnitsNetException("Error parsing string. The unit is not a recognized MassFlowUnit.");
+                newEx.Data["input"] = str;
+                newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                throw newEx;
+            }
+
+            return unit;
+        }
+
+        #endregion
+
+        /// <summary>
+        ///     Get default string representation of value and unit.
+        /// </summary>
+        /// <returns>String representation.</returns>
+        public override string ToString()
+        {
+            return ToString(MassFlowUnit.KiloGramPerSecond);
+        }
+
+        /// <summary>
+        ///     Get string representation of value and unit.
+        /// </summary>
+        /// <param name="unit">Unit representation to use.</param>
+        /// <param name="culture">Culture to use for localization and number formatting.</param>
+        /// <param name="significantDigitsAfterRadix">The number of significant digits after the radix point.</param>
+        /// <returns>String representation.</returns>
+        [UsedImplicitly]
+        public string ToString(MassFlowUnit unit, CultureInfo culture = null, int significantDigitsAfterRadix = 2)
+        {
+            return ToString(unit, culture, UnitFormatter.GetFormat(As(unit), significantDigitsAfterRadix));
+        }
+
+        /// <summary>
+        ///     Get string representation of value and unit.
+        /// </summary>
+        /// <param name="culture">Culture to use for localization and number formatting.</param>
+        /// <param name="unit">Unit representation to use.</param>
+        /// <param name="format">String format to use. Default:  "{0:0.##} {1} for value and unit abbreviation respectively."</param>
+        /// <param name="args">Arguments for string format. Value and unit are implictly included as arguments 0 and 1.</param>
+        /// <returns>String representation.</returns>
+        [UsedImplicitly]
+        public string ToString(MassFlowUnit unit, CultureInfo culture, string format, params object[] args)
+        {
+            return string.Format(culture, format, UnitFormatter.GetFormatArgs(unit, As(unit), culture, args));
+        }
+    }
+}
diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs
index 3186657470..1685378504 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs
@@ -54,6 +54,14 @@ public static RotationalSpeedUnit BaseUnit
             get { return RotationalSpeedUnit.RevolutionPerSecond; }
         }
 
+        /// <summary>
+        ///     Get RotationalSpeed in RadiansPerSecond.
+        /// </summary>
+        public double RadiansPerSecond
+        {
+            get { return _revolutionsPerSecond*6.2831853072; }
+        }
+
         /// <summary>
         ///     Get RotationalSpeed in RevolutionsPerMinute.
         /// </summary>
@@ -79,6 +87,14 @@ public static RotationalSpeed Zero
             get { return new RotationalSpeed(); }
         }
 
+        /// <summary>
+        ///     Get RotationalSpeed from RadiansPerSecond.
+        /// </summary>
+        public static RotationalSpeed FromRadiansPerSecond(double radianspersecond)
+        {
+            return new RotationalSpeed(radianspersecond/6.2831853072);
+        }
+
         /// <summary>
         ///     Get RotationalSpeed from RevolutionsPerMinute.
         /// </summary>
@@ -106,6 +122,8 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit)
         {
             switch (fromUnit)
             {
+                case RotationalSpeedUnit.RadianPerSecond:
+                    return FromRadiansPerSecond(value);
                 case RotationalSpeedUnit.RevolutionPerMinute:
                     return FromRevolutionsPerMinute(value);
                 case RotationalSpeedUnit.RevolutionPerSecond:
@@ -243,6 +261,8 @@ public double As(RotationalSpeedUnit unit)
         {
             switch (unit)
             {
+                case RotationalSpeedUnit.RadianPerSecond:
+                    return RadiansPerSecond;
                 case RotationalSpeedUnit.RevolutionPerMinute:
                     return RevolutionsPerMinute;
                 case RotationalSpeedUnit.RevolutionPerSecond:
diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
new file mode 100644
index 0000000000..447ce6b37e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
@@ -0,0 +1,512 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.Linq;
+using JetBrains.Annotations;
+using UnitsNet.Units;
+
+// ReSharper disable once CheckNamespace
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     The SpecificEnergy
+    /// </summary>
+    // ReSharper disable once PartialTypeWithSinglePart
+    public partial struct SpecificEnergy : IComparable, IComparable<SpecificEnergy>
+    {
+        /// <summary>
+        ///     Base unit of SpecificEnergy.
+        /// </summary>
+        private readonly double _joulesPerKiloGram;
+
+        public SpecificEnergy(double joulesperkilogram) : this()
+        {
+            _joulesPerKiloGram = joulesperkilogram;
+        }
+
+        #region Properties
+
+        public static SpecificEnergyUnit BaseUnit
+        {
+            get { return SpecificEnergyUnit.JoulePerKiloGram; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in JoulesPerKiloGram.
+        /// </summary>
+        public double JoulesPerKiloGram
+        {
+            get { return _joulesPerKiloGram; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in KiloCaloriesPerGram.
+        /// </summary>
+        public double KiloCaloriesPerGram
+        {
+            get { return _joulesPerKiloGram/4.184e6; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in KilojoulesPerKiloGram.
+        /// </summary>
+        public double KilojoulesPerKiloGram
+        {
+            get { return (_joulesPerKiloGram) / 1e3d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in KilowattHoursPerKiloGram.
+        /// </summary>
+        public double KilowattHoursPerKiloGram
+        {
+            get { return (_joulesPerKiloGram/3.6e3) / 1e3d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in MegajoulesPerKiloGram.
+        /// </summary>
+        public double MegajoulesPerKiloGram
+        {
+            get { return (_joulesPerKiloGram) / 1e6d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in MegawattHoursPerKiloGram.
+        /// </summary>
+        public double MegawattHoursPerKiloGram
+        {
+            get { return (_joulesPerKiloGram/3.6e3) / 1e6d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in WattHoursPerKiloGram.
+        /// </summary>
+        public double WattHoursPerKiloGram
+        {
+            get { return _joulesPerKiloGram/3.6e3; }
+        }
+
+        #endregion
+
+        #region Static 
+
+        public static SpecificEnergy Zero
+        {
+            get { return new SpecificEnergy(); }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from JoulesPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromJoulesPerKiloGram(double joulesperkilogram)
+        {
+            return new SpecificEnergy(joulesperkilogram);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from KiloCaloriesPerGram.
+        /// </summary>
+        public static SpecificEnergy FromKiloCaloriesPerGram(double kilocaloriespergram)
+        {
+            return new SpecificEnergy(kilocaloriespergram*4.184e6);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from KilojoulesPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromKilojoulesPerKiloGram(double kilojoulesperkilogram)
+        {
+            return new SpecificEnergy((kilojoulesperkilogram) * 1e3d);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from KilowattHoursPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromKilowattHoursPerKiloGram(double kilowatthoursperkilogram)
+        {
+            return new SpecificEnergy((kilowatthoursperkilogram*3.6e3) * 1e3d);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from MegajoulesPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromMegajoulesPerKiloGram(double megajoulesperkilogram)
+        {
+            return new SpecificEnergy((megajoulesperkilogram) * 1e6d);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from MegawattHoursPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromMegawattHoursPerKiloGram(double megawatthoursperkilogram)
+        {
+            return new SpecificEnergy((megawatthoursperkilogram*3.6e3) * 1e6d);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from WattHoursPerKiloGram.
+        /// </summary>
+        public static SpecificEnergy FromWattHoursPerKiloGram(double watthoursperkilogram)
+        {
+            return new SpecificEnergy(watthoursperkilogram*3.6e3);
+        }
+
+
+        /// <summary>
+        ///     Dynamically convert from value and unit enum <see cref="SpecificEnergyUnit" /> to <see cref="SpecificEnergy" />.
+        /// </summary>
+        /// <param name="value">Value to convert from.</param>
+        /// <param name="fromUnit">Unit to convert from.</param>
+        /// <returns>SpecificEnergy unit value.</returns>
+        public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
+        {
+            switch (fromUnit)
+            {
+                case SpecificEnergyUnit.JoulePerKiloGram:
+                    return FromJoulesPerKiloGram(value);
+                case SpecificEnergyUnit.KiloCaloriePerGram:
+                    return FromKiloCaloriesPerGram(value);
+                case SpecificEnergyUnit.KilojoulePerKiloGram:
+                    return FromKilojoulesPerKiloGram(value);
+                case SpecificEnergyUnit.KilowattHourPerKiloGram:
+                    return FromKilowattHoursPerKiloGram(value);
+                case SpecificEnergyUnit.MegajoulePerKiloGram:
+                    return FromMegajoulesPerKiloGram(value);
+                case SpecificEnergyUnit.MegawattHourPerKiloGram:
+                    return FromMegawattHoursPerKiloGram(value);
+                case SpecificEnergyUnit.WattHourPerKiloGram:
+                    return FromWattHoursPerKiloGram(value);
+
+                default:
+                    throw new NotImplementedException("fromUnit: " + fromUnit);
+            }
+        }
+
+        /// <summary>
+        ///     Get unit abbreviation string.
+        /// </summary>
+        /// <param name="unit">Unit to get abbreviation for.</param>
+        /// <param name="culture">Culture to use for localization. Defaults to Thread.CurrentUICulture.</param>
+        /// <returns>Unit abbreviation string.</returns>
+        [UsedImplicitly]
+        public static string GetAbbreviation(SpecificEnergyUnit unit, CultureInfo culture = null)
+        {
+            return UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit);
+        }
+
+        #endregion
+
+        #region Arithmetic Operators
+
+        public static SpecificEnergy operator -(SpecificEnergy right)
+        {
+            return new SpecificEnergy(-right._joulesPerKiloGram);
+        }
+
+        public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right)
+        {
+            return new SpecificEnergy(left._joulesPerKiloGram + right._joulesPerKiloGram);
+        }
+
+        public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right)
+        {
+            return new SpecificEnergy(left._joulesPerKiloGram - right._joulesPerKiloGram);
+        }
+
+        public static SpecificEnergy operator *(double left, SpecificEnergy right)
+        {
+            return new SpecificEnergy(left*right._joulesPerKiloGram);
+        }
+
+        public static SpecificEnergy operator *(SpecificEnergy left, double right)
+        {
+            return new SpecificEnergy(left._joulesPerKiloGram*(double)right);
+        }
+
+        public static SpecificEnergy operator /(SpecificEnergy left, double right)
+        {
+            return new SpecificEnergy(left._joulesPerKiloGram/(double)right);
+        }
+
+        public static double operator /(SpecificEnergy left, SpecificEnergy right)
+        {
+            return Convert.ToDouble(left._joulesPerKiloGram/right._joulesPerKiloGram);
+        }
+
+        #endregion
+
+        #region Equality / IComparable
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null) throw new ArgumentNullException("obj");
+            if (!(obj is SpecificEnergy)) throw new ArgumentException("Expected type SpecificEnergy.", "obj");
+            return CompareTo((SpecificEnergy) obj);
+        }
+
+        public int CompareTo(SpecificEnergy other)
+        {
+            return _joulesPerKiloGram.CompareTo(other._joulesPerKiloGram);
+        }
+
+        public static bool operator <=(SpecificEnergy left, SpecificEnergy right)
+        {
+            return left._joulesPerKiloGram <= right._joulesPerKiloGram;
+        }
+
+        public static bool operator >=(SpecificEnergy left, SpecificEnergy right)
+        {
+            return left._joulesPerKiloGram >= right._joulesPerKiloGram;
+        }
+
+        public static bool operator <(SpecificEnergy left, SpecificEnergy right)
+        {
+            return left._joulesPerKiloGram < right._joulesPerKiloGram;
+        }
+
+        public static bool operator >(SpecificEnergy left, SpecificEnergy right)
+        {
+            return left._joulesPerKiloGram > right._joulesPerKiloGram;
+        }
+
+        public static bool operator ==(SpecificEnergy left, SpecificEnergy right)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return left._joulesPerKiloGram == right._joulesPerKiloGram;
+        }
+
+        public static bool operator !=(SpecificEnergy left, SpecificEnergy right)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return left._joulesPerKiloGram != right._joulesPerKiloGram;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+
+            return _joulesPerKiloGram.Equals(((SpecificEnergy) obj)._joulesPerKiloGram);
+        }
+
+        public override int GetHashCode()
+        {
+            return _joulesPerKiloGram.GetHashCode();
+        }
+
+        #endregion
+
+        #region Conversion
+
+        /// <summary>
+        ///     Convert to the unit representation <paramref name="unit" />.
+        /// </summary>
+        /// <returns>Value in new unit if successful, exception otherwise.</returns>
+        /// <exception cref="NotImplementedException">If conversion was not successful.</exception>
+        public double As(SpecificEnergyUnit unit)
+        {
+            switch (unit)
+            {
+                case SpecificEnergyUnit.JoulePerKiloGram:
+                    return JoulesPerKiloGram;
+                case SpecificEnergyUnit.KiloCaloriePerGram:
+                    return KiloCaloriesPerGram;
+                case SpecificEnergyUnit.KilojoulePerKiloGram:
+                    return KilojoulesPerKiloGram;
+                case SpecificEnergyUnit.KilowattHourPerKiloGram:
+                    return KilowattHoursPerKiloGram;
+                case SpecificEnergyUnit.MegajoulePerKiloGram:
+                    return MegajoulesPerKiloGram;
+                case SpecificEnergyUnit.MegawattHourPerKiloGram:
+                    return MegawattHoursPerKiloGram;
+                case SpecificEnergyUnit.WattHourPerKiloGram:
+                    return WattHoursPerKiloGram;
+
+                default:
+                    throw new NotImplementedException("unit: " + unit);
+            }
+        }
+
+        #endregion
+
+        #region Parsing
+
+        /// <summary>
+        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
+        /// </summary>
+        /// <example>
+        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="ArgumentException">
+        ///     Expected string to have one or two pairs of quantity and unit in the format
+        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in" 
+        /// </exception>
+        public static SpecificEnergy Parse(string str, IFormatProvider formatProvider = null)
+        {
+            if (str == null) throw new ArgumentNullException("str");
+
+            var numFormat = formatProvider != null ?
+                (NumberFormatInfo) formatProvider.GetFormat(typeof (NumberFormatInfo)) :
+                NumberFormatInfo.CurrentInfo;
+
+            var numRegex = string.Format(@"[\d., {0}{1}]*\d",  // allows digits, dots, commas, and spaces in the quantity (must end in digit)
+                            numFormat.NumberGroupSeparator,    // adds provided (or current) culture's group separator
+                            numFormat.NumberDecimalSeparator); // adds provided (or current) culture's decimal separator
+            var exponentialRegex = @"(?:[eE][-+]?\d+)?)";
+            var regexString = string.Format(@"(?:\s*(?<value>[-+]?{0}{1}{2}{3})?{4}{5}",
+                            numRegex,                // capture base (integral) Quantity value
+                            exponentialRegex,        // capture exponential (if any), end of Quantity capturing
+                            @"\s?",                  // ignore whitespace (allows both "1kg", "1 kg")
+                            @"(?<unit>[^\s\d,]+)",   // capture Unit (non-whitespace) input
+                            @"(and)?,?",             // allow "and" & "," separators between quantities
+                            @"(?<invalid>[a-z]*)?"); // capture invalid input
+
+            var quantities = ParseWithRegex(regexString, str, formatProvider);
+            if (quantities.Count == 0)
+            {
+                throw new ArgumentException(
+                    "Expected string to have at least one pair of quantity and unit in the format"
+                    + " \"&lt;quantity&gt; &lt;unit&gt;\". Eg. \"5.5 m\" or \"1ft 2in\"");
+            }
+            return quantities.Aggregate((x, y) => x + y);
+        }
+
+        /// <summary>
+        ///     Parse a string given a particular regular expression.
+        /// </summary>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        private static List<SpecificEnergy> ParseWithRegex(string regexString, string str, IFormatProvider formatProvider = null)
+        {
+            var regex = new Regex(regexString);
+            MatchCollection matches = regex.Matches(str.Trim());
+            var converted = new List<SpecificEnergy>();
+
+            foreach (Match match in matches)
+            {
+                GroupCollection groups = match.Groups;
+
+                var valueString = groups["value"].Value;
+                var unitString = groups["unit"].Value;
+                if (groups["invalid"].Value != "")
+                {
+                    var newEx = new UnitsNetException("Invalid string detected: " + groups["invalid"].Value);
+                    newEx.Data["input"] = str;
+                    newEx.Data["matched value"] = valueString;
+                    newEx.Data["matched unit"] = unitString;
+                    newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                    throw newEx;
+                }
+                if (valueString == "" && unitString == "") continue;
+
+                try
+                {
+                    SpecificEnergyUnit unit = ParseUnit(unitString, formatProvider);
+                    double value = double.Parse(valueString, formatProvider);
+
+                    converted.Add(From(value, unit));
+                }
+                catch (Exception ex)
+                {
+                    var newEx = new UnitsNetException("Error parsing string.", ex);
+                    newEx.Data["input"] = str;
+                    newEx.Data["matched value"] = valueString;
+                    newEx.Data["matched unit"] = unitString;
+                    newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                    throw newEx;
+                }
+            }
+            return converted;
+        }
+
+        /// <summary>
+        ///     Parse a unit string.
+        /// </summary>
+        /// <example>
+        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
+        /// </example>
+        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
+        /// <exception cref="UnitsNetException">Error parsing string.</exception>
+        public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatProvider = null)
+        {
+            if (str == null) throw new ArgumentNullException("str");
+            var unitSystem = UnitSystem.GetCached(formatProvider);
+
+            var unit = unitSystem.Parse<SpecificEnergyUnit>(str.Trim());
+
+            if (unit == SpecificEnergyUnit.Undefined)
+            {
+                var newEx = new UnitsNetException("Error parsing string. The unit is not a recognized SpecificEnergyUnit.");
+                newEx.Data["input"] = str;
+                newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
+                throw newEx;
+            }
+
+            return unit;
+        }
+
+        #endregion
+
+        /// <summary>
+        ///     Get default string representation of value and unit.
+        /// </summary>
+        /// <returns>String representation.</returns>
+        public override string ToString()
+        {
+            return ToString(SpecificEnergyUnit.JoulePerKiloGram);
+        }
+
+        /// <summary>
+        ///     Get string representation of value and unit.
+        /// </summary>
+        /// <param name="unit">Unit representation to use.</param>
+        /// <param name="culture">Culture to use for localization and number formatting.</param>
+        /// <param name="significantDigitsAfterRadix">The number of significant digits after the radix point.</param>
+        /// <returns>String representation.</returns>
+        [UsedImplicitly]
+        public string ToString(SpecificEnergyUnit unit, CultureInfo culture = null, int significantDigitsAfterRadix = 2)
+        {
+            return ToString(unit, culture, UnitFormatter.GetFormat(As(unit), significantDigitsAfterRadix));
+        }
+
+        /// <summary>
+        ///     Get string representation of value and unit.
+        /// </summary>
+        /// <param name="culture">Culture to use for localization and number formatting.</param>
+        /// <param name="unit">Unit representation to use.</param>
+        /// <param name="format">String format to use. Default:  "{0:0.##} {1} for value and unit abbreviation respectively."</param>
+        /// <param name="args">Arguments for string format. Value and unit are implictly included as arguments 0 and 1.</param>
+        /// <returns>String representation.</returns>
+        [UsedImplicitly]
+        public string ToString(SpecificEnergyUnit unit, CultureInfo culture, string format, params object[] args)
+        {
+            return string.Format(culture, format, UnitFormatter.GetFormatArgs(unit, As(unit), culture, args));
+        }
+    }
+}
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs
index 5ea3ebcd58..3d5e211df1 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs
@@ -102,6 +102,14 @@ public double Knots
             get { return _metersPerSecond/0.514444; }
         }
 
+        /// <summary>
+        ///     Get Speed in MetersPerHour.
+        /// </summary>
+        public double MetersPerHour
+        {
+            get { return _metersPerSecond*3600; }
+        }
+
         /// <summary>
         ///     Get Speed in MetersPerSecond.
         /// </summary>
@@ -199,6 +207,14 @@ public static Speed FromKnots(double knots)
             return new Speed(knots*0.514444);
         }
 
+        /// <summary>
+        ///     Get Speed from MetersPerHour.
+        /// </summary>
+        public static Speed FromMetersPerHour(double metersperhour)
+        {
+            return new Speed(metersperhour/3600);
+        }
+
         /// <summary>
         ///     Get Speed from MetersPerSecond.
         /// </summary>
@@ -262,6 +278,8 @@ public static Speed From(double value, SpeedUnit fromUnit)
                     return FromKilometersPerSecond(value);
                 case SpeedUnit.Knot:
                     return FromKnots(value);
+                case SpeedUnit.MeterPerHour:
+                    return FromMetersPerHour(value);
                 case SpeedUnit.MeterPerSecond:
                     return FromMetersPerSecond(value);
                 case SpeedUnit.MicrometerPerSecond:
@@ -417,6 +435,8 @@ public double As(SpeedUnit unit)
                     return KilometersPerSecond;
                 case SpeedUnit.Knot:
                     return Knots;
+                case SpeedUnit.MeterPerHour:
+                    return MetersPerHour;
                 case SpeedUnit.MeterPerSecond:
                     return MetersPerSecond;
                 case SpeedUnit.MicrometerPerSecond:
diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
index 4b614a858b..04ec567b57 100644
--- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
+++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
@@ -107,12 +107,22 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "g"),
                                 new AbbreviationsForCulture("ru-RU", "g"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.MinuteOfArc,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "'", "min"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Radian,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "rad"),
                                 new AbbreviationsForCulture("ru-RU", "рад"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.SecondOfArc,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "″", "sec"),
+                            }),
                     }),
                 new UnitLocalization(typeof (AreaUnit),
                     new[]
@@ -825,6 +835,12 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "nm"),
                                 new AbbreviationsForCulture("ru-RU", "нм"),
                             }),
+                        new CulturesForEnumValue((int) LengthUnit.NauticalMile,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "NM"),
+                                new AbbreviationsForCulture("ru-RU", "мил"),
+                            }),
                         new CulturesForEnumValue((int) LengthUnit.Yard,
                             new[]
                             {
@@ -949,6 +965,20 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("ru-RU", "т"),
                             }),
                     }),
+                new UnitLocalization(typeof (MassFlowUnit),
+                    new[]
+                    {
+                        new CulturesForEnumValue((int) MassFlowUnit.KiloGramPerSecond,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "kg/s"),
+                            }),
+                        new CulturesForEnumValue((int) MassFlowUnit.TonnePerDay,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "t/d"),
+                            }),
+                    }),
                 new UnitLocalization(typeof (PowerUnit),
                     new[]
                     {
@@ -1279,6 +1309,11 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (RotationalSpeedUnit),
                     new[]
                     {
+                        new CulturesForEnumValue((int) RotationalSpeedUnit.RadianPerSecond,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "rad/s"),
+                            }),
                         new CulturesForEnumValue((int) RotationalSpeedUnit.RevolutionPerMinute,
                             new[]
                             {
@@ -1292,6 +1327,45 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("ru-RU", "об/с"),
                             }),
                     }),
+                new UnitLocalization(typeof (SpecificEnergyUnit),
+                    new[]
+                    {
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.JoulePerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "J/kg"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KiloCaloriePerGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "kcal/g"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilojoulePerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "kJ/kg"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilowattHourPerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "kWh/kg"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegajoulePerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "MJ/kg"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegawattHourPerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "MWh/kg"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.WattHourPerKiloGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "Wh/kg"),
+                            }),
+                    }),
                 new UnitLocalization(typeof (SpecificWeightUnit),
                     new[]
                     {
@@ -1409,6 +1483,11 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                             {
                                 new AbbreviationsForCulture("en-US", "kt", "kn", "knot", "knots"),
                             }),
+                        new CulturesForEnumValue((int) SpeedUnit.MeterPerHour,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "m/h"),
+                            }),
                         new CulturesForEnumValue((int) SpeedUnit.MeterPerSecond,
                             new[]
                             {
diff --git a/UnitsNet/Scripts/UnitDefinitions/Angle.json b/UnitsNet/Scripts/UnitDefinitions/Angle.json
index 5236aba3e5..0900738be8 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Angle.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Angle.json
@@ -35,7 +35,31 @@
                 }
             ]
         },
-        {
+		{
+            "SingularName": "MinuteOfArc",
+            "PluralName": "MinutesOfArc",
+            "FromUnitToBaseFunc": "x/60",
+            "FromBaseToUnitFunc": "x*60",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["'", "min"]
+                }
+            ]
+        },
+		{
+            "SingularName": "SecondOfArc",
+            "PluralName": "SecondsOfArc",
+            "FromUnitToBaseFunc": "x/3600",
+            "FromBaseToUnitFunc": "x*3600",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["″", "sec"]
+                }
+            ]
+        },
+		{
             "SingularName": "Gradian",
             "PluralName": "Gradians",
             "FromUnitToBaseFunc": "x*0.9",
diff --git a/UnitsNet/Scripts/UnitDefinitions/Length.json b/UnitsNet/Scripts/UnitDefinitions/Length.json
index 9ad60c4a0b..648bab3fde 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Length.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Length.json
@@ -101,6 +101,22 @@
                 }
             ]
         },
+        {
+            "SingularName": "NauticalMile",
+            "PluralName": "NauticalMiles",
+            "FromUnitToBaseFunc": "x*1852",
+            "FromBaseToUnitFunc": "x/1852",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["NM"]
+                },
+                {
+                    "Culture": "ru-RU",
+                    "Abbreviations": ["мил"]
+                }
+            ]
+        },
         {
             "SingularName": "Microinch",
             "PluralName": "Microinches",
diff --git a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
new file mode 100644
index 0000000000..436802c78c
--- /dev/null
+++ b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
@@ -0,0 +1,31 @@
+{
+    "Name": "MassFlow",
+    "BaseUnit": "KiloGramPerSecond",
+    "XmlDoc": "",
+    "Units": [
+        {
+            "SingularName": "KiloGramPerSecond",
+            "PluralName": "KiloGramsPerSecond",
+            "FromUnitToBaseFunc": "x",
+            "FromBaseToUnitFunc": "x",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["kg/s"]
+                }
+            ]
+        },
+		{
+            "SingularName": "TonnePerDay",
+            "PluralName": "TonnesPerDay",
+            "FromUnitToBaseFunc": "x*86.4000",
+            "FromBaseToUnitFunc": "x/86.4000",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["t/d"]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json
index 6834f8fc81..060d65c34c 100644
--- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json
+++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json
@@ -19,7 +19,19 @@
                 }
             ]
         },
-        {
+		{
+            "SingularName": "RadianPerSecond",
+            "PluralName": "RadiansPerSecond",
+            "FromUnitToBaseFunc": "x/6.2831853072",
+            "FromBaseToUnitFunc": "x*6.2831853072",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["rad/s"]
+                }
+            ]
+        },
+		{
             "SingularName": "RevolutionPerMinute",
             "PluralName": "RevolutionsPerMinute",
             "FromUnitToBaseFunc": "x/60",
diff --git a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
new file mode 100644
index 0000000000..de3719cb6c
--- /dev/null
+++ b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
@@ -0,0 +1,47 @@
+{
+    "Name": "SpecificEnergy",
+    "BaseUnit": "JoulePerKiloGram",
+    "XmlDoc": "The SpecificEnergy",
+	"XmlDocRemarks": "https://en.wikipedia.org/wiki/Specific_energy",
+    "Units": [
+        {
+            "SingularName": "JoulePerKiloGram",
+            "PluralName": "JoulesPerKiloGram",
+            "FromUnitToBaseFunc": "x",
+            "FromBaseToUnitFunc": "x",
+            "Prefixes": ["Kilo","Mega"],
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["J/kg"]
+                }
+            ]
+        },
+		{
+            "SingularName": "KiloCaloriePerGram",
+            "PluralName": "KiloCaloriesPerGram",
+            "FromUnitToBaseFunc": "x*4.184e6",
+            "FromBaseToUnitFunc": "x/4.184e6",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["kcal/g"]
+                }
+            ]
+		},
+		{
+            "SingularName": "WattHourPerKiloGram",
+            "PluralName": "WattHoursPerKiloGram",
+            "FromUnitToBaseFunc": "x*3.6e3",
+            "FromBaseToUnitFunc": "x/3.6e3",
+            "Prefixes": ["Kilo","Mega"],
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["Wh/kg"]
+                }
+            ]
+		}
+
+   ]
+}
\ No newline at end of file
diff --git a/UnitsNet/Scripts/UnitDefinitions/Speed.json b/UnitsNet/Scripts/UnitDefinitions/Speed.json
index f9290d3067..9d9d4dd198 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Speed.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Speed.json
@@ -15,6 +15,18 @@
                     "Abbreviations": ["m/s"]
                 }
             ]
+        },
+		{
+            "SingularName": "MeterPerHour",
+            "PluralName": "MetersPerHour",
+            "FromUnitToBaseFunc": "x/3600",
+            "FromBaseToUnitFunc": "x*3600",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["m/h"]
+                }
+            ]
         },
         {
             "SingularName": "FootPerSecond",

From c686fda24d00c7fc0296e3555726e7f1d5eb6eff Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Mon, 14 Dec 2015 14:55:05 +0100
Subject: [PATCH 2/4] Added "radians per second" in frequncy.

---
 UnitsNet.Tests/CustomCode/FrequencyTests.cs   |   8 +
 UnitsNet.Tests/CustomCode/MassFlowTests.cs    |  46 +++++
 .../CustomCode/SpecificEnergyTests.cs         |  87 +++++++++
 .../GeneratedCode/FrequencyTestsBase.g.cs     |   6 +
 .../GeneratedCode/MassFlowTestsBase.g.cs      | 173 ++++++++++++++++++
 .../GeneratedCode/Enums/FrequencyUnit.g.cs    |   1 +
 .../GeneratedCode/UnitClasses/Frequency.g.cs  |  20 ++
 .../GeneratedCode/UnitSystem.Default.g.cs     |   5 +
 .../Scripts/UnitDefinitions/Frequency.json    |  14 +-
 9 files changed, 359 insertions(+), 1 deletion(-)
 create mode 100644 UnitsNet.Tests/CustomCode/MassFlowTests.cs
 create mode 100644 UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
 create mode 100644 UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs

diff --git a/UnitsNet.Tests/CustomCode/FrequencyTests.cs b/UnitsNet.Tests/CustomCode/FrequencyTests.cs
index 0cd6b24e23..6d87a41a6a 100644
--- a/UnitsNet.Tests/CustomCode/FrequencyTests.cs
+++ b/UnitsNet.Tests/CustomCode/FrequencyTests.cs
@@ -59,5 +59,13 @@ protected override double CyclesPerMinuteInOneHertz
         {
             get { return 0.016666667; }
         }
+
+        protected override double RadiansPerSecondInOneHertz
+        {
+            get
+            {
+                return 2 * Math.PI;
+            }
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
new file mode 100644
index 0000000000..087da8df69
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -0,0 +1,46 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+using System;
+
+namespace UnitsNet.Tests.CustomCode
+{
+    public class MassFlowTests : MassFlowTestsBase
+    {
+        // TODO Override properties in base class here
+        protected override double KiloGramsPerSecondInOneKiloGramPerSecond
+        {
+            get
+            {
+                return 1.0;
+            }
+        }
+
+        protected override double TonnesPerDayInOneKiloGramPerSecond
+        {
+            get
+            {
+                return 1.0 / (60.0 * 60 * 24 / 1000);
+            }
+        }
+    }
+}
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
new file mode 100644
index 0000000000..9f8001bf11
--- /dev/null
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -0,0 +1,87 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+using System;
+
+namespace UnitsNet.Tests.CustomCode
+{
+    public class SpecificEnergyTests : SpecificEnergyTestsBase
+    {
+
+        // TODO Override properties in base class here
+        protected override double JoulesPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 1.0;
+            }
+        }
+
+        protected override double KiloCaloriesPerGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 1.0 / (4.184E6);
+            }
+        }
+
+        protected override double KilojoulesPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 1.0E-3;
+            }
+        }
+
+        protected override double KilowattHoursPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 2.77777778e-7;
+            }
+        }
+
+        protected override double MegajoulesPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 1.0E-6;
+            }
+        }
+
+        protected override double MegawattHoursPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 2.77777778E-10;
+            }
+        }
+
+        protected override double WattHoursPerKiloGramInOneJoulePerKiloGram
+        {
+            get
+            {
+                return 1.0 / 3.6e3;
+            }
+        }
+    }
+}
diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
index 4434d6aea2..94ce535b49 100644
--- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
@@ -42,6 +42,7 @@ public abstract partial class FrequencyTestsBase
         protected abstract double HertzInOneHertz { get; }
         protected abstract double KilohertzInOneHertz { get; }
         protected abstract double MegahertzInOneHertz { get; }
+        protected abstract double RadiansPerSecondInOneHertz { get; }
         protected abstract double TerahertzInOneHertz { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
@@ -51,6 +52,7 @@ public abstract partial class FrequencyTestsBase
         protected virtual double HertzTolerance { get { return 1e-5; } }
         protected virtual double KilohertzTolerance { get { return 1e-5; } }
         protected virtual double MegahertzTolerance { get { return 1e-5; } }
+        protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } }
         protected virtual double TerahertzTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
@@ -64,6 +66,7 @@ public void HertzToFrequencyUnits()
             Assert.AreEqual(HertzInOneHertz, hertz.Hertz, HertzTolerance);
             Assert.AreEqual(KilohertzInOneHertz, hertz.Kilohertz, KilohertzTolerance);
             Assert.AreEqual(MegahertzInOneHertz, hertz.Megahertz, MegahertzTolerance);
+            Assert.AreEqual(RadiansPerSecondInOneHertz, hertz.RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.AreEqual(TerahertzInOneHertz, hertz.Terahertz, TerahertzTolerance);
         }
 
@@ -76,6 +79,7 @@ public void FromValueAndUnit()
             Assert.AreEqual(1, Frequency.From(1, FrequencyUnit.Hertz).Hertz, HertzTolerance);
             Assert.AreEqual(1, Frequency.From(1, FrequencyUnit.Kilohertz).Kilohertz, KilohertzTolerance);
             Assert.AreEqual(1, Frequency.From(1, FrequencyUnit.Megahertz).Megahertz, MegahertzTolerance);
+            Assert.AreEqual(1, Frequency.From(1, FrequencyUnit.RadianPerSecond).RadiansPerSecond, RadiansPerSecondTolerance);
             Assert.AreEqual(1, Frequency.From(1, FrequencyUnit.Terahertz).Terahertz, TerahertzTolerance);
         }
 
@@ -89,6 +93,7 @@ public void As()
             Assert.AreEqual(HertzInOneHertz, hertz.As(FrequencyUnit.Hertz), HertzTolerance);
             Assert.AreEqual(KilohertzInOneHertz, hertz.As(FrequencyUnit.Kilohertz), KilohertzTolerance);
             Assert.AreEqual(MegahertzInOneHertz, hertz.As(FrequencyUnit.Megahertz), MegahertzTolerance);
+            Assert.AreEqual(RadiansPerSecondInOneHertz, hertz.As(FrequencyUnit.RadianPerSecond), RadiansPerSecondTolerance);
             Assert.AreEqual(TerahertzInOneHertz, hertz.As(FrequencyUnit.Terahertz), TerahertzTolerance);
         }
 
@@ -102,6 +107,7 @@ public void ConversionRoundTrip()
             Assert.AreEqual(1, Frequency.FromHertz(hertz.Hertz).Hertz, HertzTolerance);
             Assert.AreEqual(1, Frequency.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance);
             Assert.AreEqual(1, Frequency.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance);
+            Assert.AreEqual(1, Frequency.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance);
             Assert.AreEqual(1, Frequency.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance);
         }
 
diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
new file mode 100644
index 0000000000..5ab9694b66
--- /dev/null
+++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
@@ -0,0 +1,173 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using NUnit.Framework;
+using UnitsNet.Units;
+
+// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
+#pragma warning disable 1718
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.Tests
+{
+    /// <summary>
+    /// Test of MassFlow.
+    /// </summary>
+    [TestFixture]
+// ReSharper disable once PartialTypeWithSinglePart
+    public abstract partial class MassFlowTestsBase
+    {
+        protected abstract double KiloGramsPerSecondInOneKiloGramPerSecond { get; }
+        protected abstract double TonnesPerDayInOneKiloGramPerSecond { get; }
+
+// ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double KiloGramsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double TonnesPerDayTolerance { get { return 1e-5; } }
+// ReSharper restore VirtualMemberNeverOverriden.Global
+
+        [Test]
+        public void KiloGramPerSecondToMassFlowUnits()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.TonnesPerDay, TonnesPerDayTolerance);
+        }
+
+        [Test]
+        public void FromValueAndUnit()
+        {
+            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.KiloGramPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.TonnePerDay).TonnesPerDay, TonnesPerDayTolerance);
+        }
+
+        [Test]
+        public void As()
+        {
+            var kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.KiloGramPerSecond), KiloGramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.TonnePerDay), TonnesPerDayTolerance);
+        }
+
+        [Test]
+        public void ConversionRoundTrip()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.AreEqual(1, MassFlow.FromKiloGramsPerSecond(kilogrampersecond.KiloGramsPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.FromTonnesPerDay(kilogrampersecond.TonnesPerDay).KiloGramsPerSecond, TonnesPerDayTolerance);
+        }
+
+        [Test]
+        public void ArithmeticOperators()
+        {
+            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.AreEqual(-1, -v.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(3)-v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(2, (v + v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(10, (v*10).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(10, (10*v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(10)/5).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(2, MassFlow.FromKiloGramsPerSecond(10)/MassFlow.FromKiloGramsPerSecond(5), KiloGramsPerSecondTolerance);
+        }
+
+        [Test]
+        public void ComparisonOperators()
+        {
+            MassFlow oneKiloGramPerSecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow twoKiloGramsPerSecond = MassFlow.FromKiloGramsPerSecond(2);
+
+            Assert.True(oneKiloGramPerSecond < twoKiloGramsPerSecond);
+            Assert.True(oneKiloGramPerSecond <= twoKiloGramsPerSecond);
+            Assert.True(twoKiloGramsPerSecond > oneKiloGramPerSecond);
+            Assert.True(twoKiloGramsPerSecond >= oneKiloGramPerSecond);
+
+            Assert.False(oneKiloGramPerSecond > twoKiloGramsPerSecond);
+            Assert.False(oneKiloGramPerSecond >= twoKiloGramsPerSecond);
+            Assert.False(twoKiloGramsPerSecond < oneKiloGramPerSecond);
+            Assert.False(twoKiloGramsPerSecond <= oneKiloGramPerSecond);
+        }
+
+        [Test]
+        public void CompareToIsImplemented()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.AreEqual(0, kilogrampersecond.CompareTo(kilogrampersecond));
+            Assert.Greater(kilogrampersecond.CompareTo(MassFlow.Zero), 0);
+            Assert.Less(MassFlow.Zero.CompareTo(kilogrampersecond), 0);
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentException))]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            kilogrampersecond.CompareTo(new object());
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void CompareToThrowsOnNull()
+        { 
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            kilogrampersecond.CompareTo(null);
+        }
+
+
+        [Test]
+        public void EqualityOperators()
+        {
+            MassFlow a = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow b = MassFlow.FromKiloGramsPerSecond(2);
+
+// ReSharper disable EqualExpressionComparison
+            Assert.True(a == a); 
+            Assert.True(a != b);
+
+            Assert.False(a == b);
+            Assert.False(a != a);
+// ReSharper restore EqualExpressionComparison
+        }
+
+        [Test]
+        public void EqualsIsImplemented()
+        {
+            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.IsTrue(v.Equals(MassFlow.FromKiloGramsPerSecond(1)));
+            Assert.IsFalse(v.Equals(MassFlow.Zero));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.IsFalse(kilogrampersecond.Equals(new object()));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnNull()
+        {
+            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            Assert.IsFalse(kilogrampersecond.Equals(null));
+        }
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Enums/FrequencyUnit.g.cs b/UnitsNet/GeneratedCode/Enums/FrequencyUnit.g.cs
index 7cf8436567..b2e4420ac7 100644
--- a/UnitsNet/GeneratedCode/Enums/FrequencyUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/FrequencyUnit.g.cs
@@ -31,6 +31,7 @@ public enum FrequencyUnit
         Hertz,
         Kilohertz,
         Megahertz,
+        RadianPerSecond,
         Terahertz,
     }
 }
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs
index 7912df891c..d089c4aa5e 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs
@@ -102,6 +102,14 @@ public double Megahertz
             get { return (_hertz) / 1e6d; }
         }
 
+        /// <summary>
+        ///     Get Frequency in RadiansPerSecond.
+        /// </summary>
+        public double RadiansPerSecond
+        {
+            get { return _hertz*6.2831853072; }
+        }
+
         /// <summary>
         ///     Get Frequency in Terahertz.
         /// </summary>
@@ -167,6 +175,14 @@ public static Frequency FromMegahertz(double megahertz)
             return new Frequency((megahertz) * 1e6d);
         }
 
+        /// <summary>
+        ///     Get Frequency from RadiansPerSecond.
+        /// </summary>
+        public static Frequency FromRadiansPerSecond(double radianspersecond)
+        {
+            return new Frequency(radianspersecond/6.2831853072);
+        }
+
         /// <summary>
         ///     Get Frequency from Terahertz.
         /// </summary>
@@ -198,6 +214,8 @@ public static Frequency From(double value, FrequencyUnit fromUnit)
                     return FromKilohertz(value);
                 case FrequencyUnit.Megahertz:
                     return FromMegahertz(value);
+                case FrequencyUnit.RadianPerSecond:
+                    return FromRadiansPerSecond(value);
                 case FrequencyUnit.Terahertz:
                     return FromTerahertz(value);
 
@@ -345,6 +363,8 @@ public double As(FrequencyUnit unit)
                     return Kilohertz;
                 case FrequencyUnit.Megahertz:
                     return Megahertz;
+                case FrequencyUnit.RadianPerSecond:
+                    return RadiansPerSecond;
                 case FrequencyUnit.Terahertz:
                     return Terahertz;
 
diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
index 04ec567b57..a34d158079 100644
--- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
+++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
@@ -568,6 +568,11 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                             {
                                 new AbbreviationsForCulture("en-US", "MHz"),
                             }),
+                        new CulturesForEnumValue((int) FrequencyUnit.RadianPerSecond,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "rad/s"),
+                            }),
                         new CulturesForEnumValue((int) FrequencyUnit.Terahertz,
                             new[]
                             {
diff --git a/UnitsNet/Scripts/UnitDefinitions/Frequency.json b/UnitsNet/Scripts/UnitDefinitions/Frequency.json
index 667f2d7332..d914f63641 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Frequency.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Frequency.json
@@ -16,7 +16,19 @@
                 }
             ]
         },
-        {
+		{
+            "SingularName": "RadianPerSecond",
+            "PluralName": "RadiansPerSecond",
+            "FromUnitToBaseFunc": "x/6.2831853072",
+            "FromBaseToUnitFunc": "x*6.2831853072",
+            "Localization": [
+                {
+                    "Culture": "en-US",
+                    "Abbreviations": ["rad/s"]
+                }
+            ]
+        },
+		{
             "SingularName": "CyclePerMinute",
             "PluralName": "CyclesPerMinute",
             "FromUnitToBaseFunc": "x*60",

From c0a26711fc57ee833cd5aaf104780503023f09bb Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@seaware.se>
Date: Fri, 15 Jan 2016 20:10:29 +0100
Subject: [PATCH 3/4] Changes according to comments by anjdreas

---
 UnitsNet.Tests/CustomCode/AngleTests.cs       |   4 +-
 UnitsNet.Tests/CustomCode/MassFlowTests.cs    |   4 +-
 .../CustomCode/SpecificEnergyTests.cs         |  25 ++-
 .../GeneratedCode/AngleTestsBase.g.cs         |  24 +--
 .../GeneratedCode/MassFlowTestsBase.g.cs      |  86 ++++----
 .../SpecificEnergyTestsBase.g.cs              | 156 ++++++++-------
 UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs   |   4 +-
 .../GeneratedCode/Enums/MassFlowUnit.g.cs     |   2 +-
 .../Enums/SpecificEnergyUnit.g.cs             |  15 +-
 UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs |  76 +++----
 .../GeneratedCode/UnitClasses/MassFlow.g.cs   |  60 +++---
 .../UnitClasses/SpecificEnergy.g.cs           | 188 ++++++++++--------
 .../GeneratedCode/UnitSystem.Default.g.cs     |  41 ++--
 UnitsNet/Scripts/UnitDefinitions/Angle.json   |  12 +-
 .../Scripts/UnitDefinitions/MassFlow.json     |   6 +-
 .../UnitDefinitions/SpecificEnergy.json       |  21 +-
 16 files changed, 382 insertions(+), 342 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index 59f9ff86a9..988496525e 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -35,7 +35,7 @@ protected override double GradiansInOneDegree
             get { return 400/360.0; }
         }
 
-        protected override double MinutesOfArcInOneDegree
+        protected override double ArcminutesInOneDegree
         {
             get
             {
@@ -48,7 +48,7 @@ protected override double RadiansInOneDegree
             get { return Math.PI/2/90; }
         }
 
-        protected override double SecondsOfArcInOneDegree
+        protected override double ArcsecondsInOneDegree
         {
             get
             {
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 087da8df69..1b934169b4 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -27,7 +27,7 @@ namespace UnitsNet.Tests.CustomCode
     public class MassFlowTests : MassFlowTestsBase
     {
         // TODO Override properties in base class here
-        protected override double KiloGramsPerSecondInOneKiloGramPerSecond
+        protected override double KilogramsPerSecondInOneKilogramPerSecond
         {
             get
             {
@@ -35,7 +35,7 @@ protected override double KiloGramsPerSecondInOneKiloGramPerSecond
             }
         }
 
-        protected override double TonnesPerDayInOneKiloGramPerSecond
+        protected override double TonnesPerDayInOneKilogramPerSecond
         {
             get
             {
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
index 9f8001bf11..aec916542e 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -26,9 +26,7 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class SpecificEnergyTests : SpecificEnergyTestsBase
     {
-
-        // TODO Override properties in base class here
-        protected override double JoulesPerKiloGramInOneJoulePerKiloGram
+        protected override double JoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -36,7 +34,15 @@ protected override double JoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KiloCaloriesPerGramInOneJoulePerKiloGram
+        protected override double CaloriesPerGramInOneJoulePerKilogram
+        {
+            get
+            {
+                return 1.0 / (4.184E3);
+            }
+        }
+
+        protected override double KilocaloriesPerGramInOneJoulePerKilogram
         {
             get
             {
@@ -44,7 +50,8 @@ protected override double KiloCaloriesPerGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KilojoulesPerKiloGramInOneJoulePerKiloGram
+
+        protected override double KilojoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -52,7 +59,7 @@ protected override double KilojoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KilowattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double KilowattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -60,7 +67,7 @@ protected override double KilowattHoursPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double MegajoulesPerKiloGramInOneJoulePerKiloGram
+        protected override double MegajoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -68,7 +75,7 @@ protected override double MegajoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double MegawattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double MegawattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -76,7 +83,7 @@ protected override double MegawattHoursPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double WattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double WattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
index 864ef2cb34..9582b7c16b 100644
--- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
@@ -36,61 +36,61 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class AngleTestsBase
     {
+        protected abstract double ArcminutesInOneDegree { get; }
+        protected abstract double ArcsecondsInOneDegree { get; }
         protected abstract double DegreesInOneDegree { get; }
         protected abstract double GradiansInOneDegree { get; }
-        protected abstract double MinutesOfArcInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
-        protected abstract double SecondsOfArcInOneDegree { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double ArcminutesTolerance { get { return 1e-5; } }
+        protected virtual double ArcsecondsTolerance { get { return 1e-5; } }
         protected virtual double DegreesTolerance { get { return 1e-5; } }
         protected virtual double GradiansTolerance { get { return 1e-5; } }
-        protected virtual double MinutesOfArcTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
-        protected virtual double SecondsOfArcTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
         public void DegreeToAngleUnits()
         {
             Angle degree = Angle.FromDegrees(1);
+            Assert.AreEqual(ArcminutesInOneDegree, degree.Arcminutes, ArcminutesTolerance);
+            Assert.AreEqual(ArcsecondsInOneDegree, degree.Arcseconds, ArcsecondsTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.Degrees, DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.Gradians, GradiansTolerance);
-            Assert.AreEqual(MinutesOfArcInOneDegree, degree.MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.Radians, RadiansTolerance);
-            Assert.AreEqual(SecondsOfArcInOneDegree, degree.SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
         public void FromValueAndUnit()
         {
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Arcminute).Arcminutes, ArcminutesTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Arcsecond).Arcseconds, ArcsecondsTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Degree).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Gradian).Gradians, GradiansTolerance);
-            Assert.AreEqual(1, Angle.From(1, AngleUnit.MinuteOfArc).MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
-            Assert.AreEqual(1, Angle.From(1, AngleUnit.SecondOfArc).SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
         public void As()
         {
             var degree = Angle.FromDegrees(1);
+            Assert.AreEqual(ArcminutesInOneDegree, degree.As(AngleUnit.Arcminute), ArcminutesTolerance);
+            Assert.AreEqual(ArcsecondsInOneDegree, degree.As(AngleUnit.Arcsecond), ArcsecondsTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.As(AngleUnit.Degree), DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.As(AngleUnit.Gradian), GradiansTolerance);
-            Assert.AreEqual(MinutesOfArcInOneDegree, degree.As(AngleUnit.MinuteOfArc), MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
-            Assert.AreEqual(SecondsOfArcInOneDegree, degree.As(AngleUnit.SecondOfArc), SecondsOfArcTolerance);
         }
 
         [Test]
         public void ConversionRoundTrip()
         {
             Angle degree = Angle.FromDegrees(1);
+            Assert.AreEqual(1, Angle.FromArcminutes(degree.Arcminutes).Degrees, ArcminutesTolerance);
+            Assert.AreEqual(1, Angle.FromArcseconds(degree.Arcseconds).Degrees, ArcsecondsTolerance);
             Assert.AreEqual(1, Angle.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
-            Assert.AreEqual(1, Angle.FromMinutesOfArc(degree.MinutesOfArc).Degrees, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
-            Assert.AreEqual(1, Angle.FromSecondsOfArc(degree.SecondsOfArc).Degrees, SecondsOfArcTolerance);
         }
 
         [Test]
diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
index 5ab9694b66..c7999d864e 100644
--- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
@@ -36,79 +36,79 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class MassFlowTestsBase
     {
-        protected abstract double KiloGramsPerSecondInOneKiloGramPerSecond { get; }
-        protected abstract double TonnesPerDayInOneKiloGramPerSecond { get; }
+        protected abstract double KilogramsPerSecondInOneKilogramPerSecond { get; }
+        protected abstract double TonnesPerDayInOneKilogramPerSecond { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
-        protected virtual double KiloGramsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsPerSecondTolerance { get { return 1e-5; } }
         protected virtual double TonnesPerDayTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
-        public void KiloGramPerSecondToMassFlowUnits()
+        public void KilogramPerSecondToMassFlowUnits()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.TonnesPerDay, TonnesPerDayTolerance);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(KilogramsPerSecondInOneKilogramPerSecond, kilogrampersecond.KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKilogramPerSecond, kilogrampersecond.TonnesPerDay, TonnesPerDayTolerance);
         }
 
         [Test]
         public void FromValueAndUnit()
         {
-            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.KiloGramPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.KilogramPerSecond).KilogramsPerSecond, KilogramsPerSecondTolerance);
             Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.TonnePerDay).TonnesPerDay, TonnesPerDayTolerance);
         }
 
         [Test]
         public void As()
         {
-            var kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.KiloGramPerSecond), KiloGramsPerSecondTolerance);
-            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.TonnePerDay), TonnesPerDayTolerance);
+            var kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(KilogramsPerSecondInOneKilogramPerSecond, kilogrampersecond.As(MassFlowUnit.KilogramPerSecond), KilogramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKilogramPerSecond, kilogrampersecond.As(MassFlowUnit.TonnePerDay), TonnesPerDayTolerance);
         }
 
         [Test]
         public void ConversionRoundTrip()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(1, MassFlow.FromKiloGramsPerSecond(kilogrampersecond.KiloGramsPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(1, MassFlow.FromTonnesPerDay(kilogrampersecond.TonnesPerDay).KiloGramsPerSecond, TonnesPerDayTolerance);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(1, MassFlow.FromKilogramsPerSecond(kilogrampersecond.KilogramsPerSecond).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.FromTonnesPerDay(kilogrampersecond.TonnesPerDay).KilogramsPerSecond, TonnesPerDayTolerance);
         }
 
         [Test]
         public void ArithmeticOperators()
         {
-            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(-1, -v.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(3)-v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (v + v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(10, (v*10).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(10, (10*v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(10)/5).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, MassFlow.FromKiloGramsPerSecond(10)/MassFlow.FromKiloGramsPerSecond(5), KiloGramsPerSecondTolerance);
+            MassFlow v = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(-1, -v.KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKilogramsPerSecond(3)-v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (v + v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(10, (v*10).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(10, (10*v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKilogramsPerSecond(10)/5).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, MassFlow.FromKilogramsPerSecond(10)/MassFlow.FromKilogramsPerSecond(5), KilogramsPerSecondTolerance);
         }
 
         [Test]
         public void ComparisonOperators()
         {
-            MassFlow oneKiloGramPerSecond = MassFlow.FromKiloGramsPerSecond(1);
-            MassFlow twoKiloGramsPerSecond = MassFlow.FromKiloGramsPerSecond(2);
-
-            Assert.True(oneKiloGramPerSecond < twoKiloGramsPerSecond);
-            Assert.True(oneKiloGramPerSecond <= twoKiloGramsPerSecond);
-            Assert.True(twoKiloGramsPerSecond > oneKiloGramPerSecond);
-            Assert.True(twoKiloGramsPerSecond >= oneKiloGramPerSecond);
-
-            Assert.False(oneKiloGramPerSecond > twoKiloGramsPerSecond);
-            Assert.False(oneKiloGramPerSecond >= twoKiloGramsPerSecond);
-            Assert.False(twoKiloGramsPerSecond < oneKiloGramPerSecond);
-            Assert.False(twoKiloGramsPerSecond <= oneKiloGramPerSecond);
+            MassFlow oneKilogramPerSecond = MassFlow.FromKilogramsPerSecond(1);
+            MassFlow twoKilogramsPerSecond = MassFlow.FromKilogramsPerSecond(2);
+
+            Assert.True(oneKilogramPerSecond < twoKilogramsPerSecond);
+            Assert.True(oneKilogramPerSecond <= twoKilogramsPerSecond);
+            Assert.True(twoKilogramsPerSecond > oneKilogramPerSecond);
+            Assert.True(twoKilogramsPerSecond >= oneKilogramPerSecond);
+
+            Assert.False(oneKilogramPerSecond > twoKilogramsPerSecond);
+            Assert.False(oneKilogramPerSecond >= twoKilogramsPerSecond);
+            Assert.False(twoKilogramsPerSecond < oneKilogramPerSecond);
+            Assert.False(twoKilogramsPerSecond <= oneKilogramPerSecond);
         }
 
         [Test]
         public void CompareToIsImplemented()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.AreEqual(0, kilogrampersecond.CompareTo(kilogrampersecond));
             Assert.Greater(kilogrampersecond.CompareTo(MassFlow.Zero), 0);
             Assert.Less(MassFlow.Zero.CompareTo(kilogrampersecond), 0);
@@ -118,7 +118,7 @@ public void CompareToIsImplemented()
         [ExpectedException(typeof(ArgumentException))]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             kilogrampersecond.CompareTo(new object());
         }
@@ -127,7 +127,7 @@ public void CompareToThrowsOnTypeMismatch()
         [ExpectedException(typeof(ArgumentNullException))]
         public void CompareToThrowsOnNull()
         { 
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             kilogrampersecond.CompareTo(null);
         }
@@ -136,8 +136,8 @@ public void CompareToThrowsOnNull()
         [Test]
         public void EqualityOperators()
         {
-            MassFlow a = MassFlow.FromKiloGramsPerSecond(1);
-            MassFlow b = MassFlow.FromKiloGramsPerSecond(2);
+            MassFlow a = MassFlow.FromKilogramsPerSecond(1);
+            MassFlow b = MassFlow.FromKilogramsPerSecond(2);
 
 // ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
@@ -151,22 +151,22 @@ public void EqualityOperators()
         [Test]
         public void EqualsIsImplemented()
         {
-            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.IsTrue(v.Equals(MassFlow.FromKiloGramsPerSecond(1)));
+            MassFlow v = MassFlow.FromKilogramsPerSecond(1);
+            Assert.IsTrue(v.Equals(MassFlow.FromKilogramsPerSecond(1)));
             Assert.IsFalse(v.Equals(MassFlow.Zero));
         }
 
         [Test]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.IsFalse(kilogrampersecond.Equals(new object()));
         }
 
         [Test]
         public void EqualsReturnsFalseOnNull()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.IsFalse(kilogrampersecond.Equals(null));
         }
     }
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
index 3abbda3723..b1a8db42f3 100644
--- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
@@ -36,109 +36,115 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class SpecificEnergyTestsBase
     {
-        protected abstract double JoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double KiloCaloriesPerGramInOneJoulePerKiloGram { get; }
-        protected abstract double KilojoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double KilowattHoursPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double MegajoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double MegawattHoursPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double WattHoursPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double CaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double JoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilocaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double KilojoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilowattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegajoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegawattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double WattHoursPerKilogramInOneJoulePerKilogram { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
-        protected virtual double JoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double KiloCaloriesPerGramTolerance { get { return 1e-5; } }
-        protected virtual double KilojoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double KilowattHoursPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double MegajoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double MegawattHoursPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double WattHoursPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double CaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double JoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilocaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilowattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegawattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double WattHoursPerKilogramTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
-        public void JoulePerKiloGramToSpecificEnergyUnits()
+        public void JoulePerKilogramToSpecificEnergyUnits()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.CaloriesPerGram, CaloriesPerGramTolerance);
+            Assert.AreEqual(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.WattHoursPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void FromValueAndUnit()
         {
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KiloCaloriePerGram).KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKiloGram).KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKiloGram).KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKiloGram).MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKiloGram).MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKiloGram).WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram).CaloriesPerGram, CaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram).KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram).KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram).KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram).MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram).MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram).WattHoursPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void As()
         {
-            var jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKiloGram), JoulesPerKiloGramTolerance);
-            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KiloCaloriePerGram), KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKiloGram), KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKiloGram), KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKiloGram), MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKiloGram), MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKiloGram), WattHoursPerKiloGramTolerance);
+            var jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.CaloriePerGram), CaloriesPerGramTolerance);
+            Assert.AreEqual(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKilogram), JoulesPerKilogramTolerance);
+            Assert.AreEqual(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilocaloriePerGram), KilocaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKilogram), KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKilogram), KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKilogram), MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKilogram), MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKilogram), WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void ConversionRoundTrip()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(1, SpecificEnergy.FromJoulesPerKiloGram(jouleperkilogram.JoulesPerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKiloCaloriesPerGram(jouleperkilogram.KiloCaloriesPerGram).JoulesPerKiloGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKilojoulesPerKiloGram(jouleperkilogram.KilojoulesPerKiloGram).JoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKilowattHoursPerKiloGram(jouleperkilogram.KilowattHoursPerKiloGram).JoulesPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromMegajoulesPerKiloGram(jouleperkilogram.MegajoulesPerKiloGram).JoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromMegawattHoursPerKiloGram(jouleperkilogram.MegawattHoursPerKiloGram).JoulesPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromWattHoursPerKiloGram(jouleperkilogram.WattHoursPerKiloGram).JoulesPerKiloGram, WattHoursPerKiloGramTolerance);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(1, SpecificEnergy.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void ArithmeticOperators()
         {
-            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(-1, -v.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(3)-v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (v + v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(10, (v*10).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(10, (10*v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(10)/5).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, SpecificEnergy.FromJoulesPerKiloGram(10)/SpecificEnergy.FromJoulesPerKiloGram(5), JoulesPerKiloGramTolerance);
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(-1, -v.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (v + v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(10, (v*10).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(10, (10*v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, SpecificEnergy.FromJoulesPerKilogram(10)/SpecificEnergy.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
         }
 
         [Test]
         public void ComparisonOperators()
         {
-            SpecificEnergy oneJoulePerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            SpecificEnergy twoJoulesPerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(2);
-
-            Assert.True(oneJoulePerKiloGram < twoJoulesPerKiloGram);
-            Assert.True(oneJoulePerKiloGram <= twoJoulesPerKiloGram);
-            Assert.True(twoJoulesPerKiloGram > oneJoulePerKiloGram);
-            Assert.True(twoJoulesPerKiloGram >= oneJoulePerKiloGram);
-
-            Assert.False(oneJoulePerKiloGram > twoJoulesPerKiloGram);
-            Assert.False(oneJoulePerKiloGram >= twoJoulesPerKiloGram);
-            Assert.False(twoJoulesPerKiloGram < oneJoulePerKiloGram);
-            Assert.False(twoJoulesPerKiloGram <= oneJoulePerKiloGram);
+            SpecificEnergy oneJoulePerKilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy twoJoulesPerKilogram = SpecificEnergy.FromJoulesPerKilogram(2);
+
+            Assert.True(oneJoulePerKilogram < twoJoulesPerKilogram);
+            Assert.True(oneJoulePerKilogram <= twoJoulesPerKilogram);
+            Assert.True(twoJoulesPerKilogram > oneJoulePerKilogram);
+            Assert.True(twoJoulesPerKilogram >= oneJoulePerKilogram);
+
+            Assert.False(oneJoulePerKilogram > twoJoulesPerKilogram);
+            Assert.False(oneJoulePerKilogram >= twoJoulesPerKilogram);
+            Assert.False(twoJoulesPerKilogram < oneJoulePerKilogram);
+            Assert.False(twoJoulesPerKilogram <= oneJoulePerKilogram);
         }
 
         [Test]
         public void CompareToIsImplemented()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.AreEqual(0, jouleperkilogram.CompareTo(jouleperkilogram));
             Assert.Greater(jouleperkilogram.CompareTo(SpecificEnergy.Zero), 0);
             Assert.Less(SpecificEnergy.Zero.CompareTo(jouleperkilogram), 0);
@@ -148,7 +154,7 @@ public void CompareToIsImplemented()
         [ExpectedException(typeof(ArgumentException))]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             jouleperkilogram.CompareTo(new object());
         }
@@ -157,7 +163,7 @@ public void CompareToThrowsOnTypeMismatch()
         [ExpectedException(typeof(ArgumentNullException))]
         public void CompareToThrowsOnNull()
         { 
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             jouleperkilogram.CompareTo(null);
         }
@@ -166,8 +172,8 @@ public void CompareToThrowsOnNull()
         [Test]
         public void EqualityOperators()
         {
-            SpecificEnergy a = SpecificEnergy.FromJoulesPerKiloGram(1);
-            SpecificEnergy b = SpecificEnergy.FromJoulesPerKiloGram(2);
+            SpecificEnergy a = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy b = SpecificEnergy.FromJoulesPerKilogram(2);
 
 // ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
@@ -181,22 +187,22 @@ public void EqualityOperators()
         [Test]
         public void EqualsIsImplemented()
         {
-            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.IsTrue(v.Equals(SpecificEnergy.FromJoulesPerKiloGram(1)));
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.IsTrue(v.Equals(SpecificEnergy.FromJoulesPerKilogram(1)));
             Assert.IsFalse(v.Equals(SpecificEnergy.Zero));
         }
 
         [Test]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.IsFalse(jouleperkilogram.Equals(new object()));
         }
 
         [Test]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.IsFalse(jouleperkilogram.Equals(null));
         }
     }
diff --git a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
index ac96746f64..dd3c5a6ed7 100644
--- a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
@@ -25,10 +25,10 @@ namespace UnitsNet.Units
     public enum AngleUnit
     {
         Undefined = 0,
+        Arcminute,
+        Arcsecond,
         Degree,
         Gradian,
-        MinuteOfArc,
         Radian,
-        SecondOfArc,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
index 1f7887259e..a5e9c951ce 100644
--- a/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
@@ -25,7 +25,7 @@ namespace UnitsNet.Units
     public enum MassFlowUnit
     {
         Undefined = 0,
-        KiloGramPerSecond,
+        KilogramPerSecond,
         TonnePerDay,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
index 09eeb9b8da..f20d5d3a71 100644
--- a/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
@@ -25,12 +25,13 @@ namespace UnitsNet.Units
     public enum SpecificEnergyUnit
     {
         Undefined = 0,
-        JoulePerKiloGram,
-        KiloCaloriePerGram,
-        KilojoulePerKiloGram,
-        KilowattHourPerKiloGram,
-        MegajoulePerKiloGram,
-        MegawattHourPerKiloGram,
-        WattHourPerKiloGram,
+        CaloriePerGram,
+        JoulePerKilogram,
+        KilocaloriePerGram,
+        KilojoulePerKilogram,
+        KilowattHourPerKilogram,
+        MegajoulePerKilogram,
+        MegawattHourPerKilogram,
+        WattHourPerKilogram,
     }
 }
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
index 9f16981d83..e1249c9a44 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
@@ -55,43 +55,43 @@ public static AngleUnit BaseUnit
         }
 
         /// <summary>
-        ///     Get Angle in Degrees.
+        ///     Get Angle in Arcminutes.
         /// </summary>
-        public double Degrees
+        public double Arcminutes
         {
-            get { return _degrees; }
+            get { return _degrees*60; }
         }
 
         /// <summary>
-        ///     Get Angle in Gradians.
+        ///     Get Angle in Arcseconds.
         /// </summary>
-        public double Gradians
+        public double Arcseconds
         {
-            get { return _degrees/0.9; }
+            get { return _degrees*3600; }
         }
 
         /// <summary>
-        ///     Get Angle in MinutesOfArc.
+        ///     Get Angle in Degrees.
         /// </summary>
-        public double MinutesOfArc
+        public double Degrees
         {
-            get { return _degrees*60; }
+            get { return _degrees; }
         }
 
         /// <summary>
-        ///     Get Angle in Radians.
+        ///     Get Angle in Gradians.
         /// </summary>
-        public double Radians
+        public double Gradians
         {
-            get { return _degrees/180*Math.PI; }
+            get { return _degrees/0.9; }
         }
 
         /// <summary>
-        ///     Get Angle in SecondsOfArc.
+        ///     Get Angle in Radians.
         /// </summary>
-        public double SecondsOfArc
+        public double Radians
         {
-            get { return _degrees*3600; }
+            get { return _degrees/180*Math.PI; }
         }
 
         #endregion
@@ -104,43 +104,43 @@ public static Angle Zero
         }
 
         /// <summary>
-        ///     Get Angle from Degrees.
+        ///     Get Angle from Arcminutes.
         /// </summary>
-        public static Angle FromDegrees(double degrees)
+        public static Angle FromArcminutes(double arcminutes)
         {
-            return new Angle(degrees);
+            return new Angle(arcminutes/60);
         }
 
         /// <summary>
-        ///     Get Angle from Gradians.
+        ///     Get Angle from Arcseconds.
         /// </summary>
-        public static Angle FromGradians(double gradians)
+        public static Angle FromArcseconds(double arcseconds)
         {
-            return new Angle(gradians*0.9);
+            return new Angle(arcseconds/3600);
         }
 
         /// <summary>
-        ///     Get Angle from MinutesOfArc.
+        ///     Get Angle from Degrees.
         /// </summary>
-        public static Angle FromMinutesOfArc(double minutesofarc)
+        public static Angle FromDegrees(double degrees)
         {
-            return new Angle(minutesofarc/60);
+            return new Angle(degrees);
         }
 
         /// <summary>
-        ///     Get Angle from Radians.
+        ///     Get Angle from Gradians.
         /// </summary>
-        public static Angle FromRadians(double radians)
+        public static Angle FromGradians(double gradians)
         {
-            return new Angle(radians*180/Math.PI);
+            return new Angle(gradians*0.9);
         }
 
         /// <summary>
-        ///     Get Angle from SecondsOfArc.
+        ///     Get Angle from Radians.
         /// </summary>
-        public static Angle FromSecondsOfArc(double secondsofarc)
+        public static Angle FromRadians(double radians)
         {
-            return new Angle(secondsofarc/3600);
+            return new Angle(radians*180/Math.PI);
         }
 
 
@@ -154,16 +154,16 @@ public static Angle From(double value, AngleUnit fromUnit)
         {
             switch (fromUnit)
             {
+                case AngleUnit.Arcminute:
+                    return FromArcminutes(value);
+                case AngleUnit.Arcsecond:
+                    return FromArcseconds(value);
                 case AngleUnit.Degree:
                     return FromDegrees(value);
                 case AngleUnit.Gradian:
                     return FromGradians(value);
-                case AngleUnit.MinuteOfArc:
-                    return FromMinutesOfArc(value);
                 case AngleUnit.Radian:
                     return FromRadians(value);
-                case AngleUnit.SecondOfArc:
-                    return FromSecondsOfArc(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -297,16 +297,16 @@ public double As(AngleUnit unit)
         {
             switch (unit)
             {
+                case AngleUnit.Arcminute:
+                    return Arcminutes;
+                case AngleUnit.Arcsecond:
+                    return Arcseconds;
                 case AngleUnit.Degree:
                     return Degrees;
                 case AngleUnit.Gradian:
                     return Gradians;
-                case AngleUnit.MinuteOfArc:
-                    return MinutesOfArc;
                 case AngleUnit.Radian:
                     return Radians;
-                case AngleUnit.SecondOfArc:
-                    return SecondsOfArc;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
index d3b0e38bb4..57429539c2 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
@@ -40,26 +40,26 @@ public partial struct MassFlow : IComparable, IComparable<MassFlow>
         /// <summary>
         ///     Base unit of MassFlow.
         /// </summary>
-        private readonly double _kiloGramsPerSecond;
+        private readonly double _kilogramsPerSecond;
 
         public MassFlow(double kilogramspersecond) : this()
         {
-            _kiloGramsPerSecond = kilogramspersecond;
+            _kilogramsPerSecond = kilogramspersecond;
         }
 
         #region Properties
 
         public static MassFlowUnit BaseUnit
         {
-            get { return MassFlowUnit.KiloGramPerSecond; }
+            get { return MassFlowUnit.KilogramPerSecond; }
         }
 
         /// <summary>
-        ///     Get MassFlow in KiloGramsPerSecond.
+        ///     Get MassFlow in KilogramsPerSecond.
         /// </summary>
-        public double KiloGramsPerSecond
+        public double KilogramsPerSecond
         {
-            get { return _kiloGramsPerSecond; }
+            get { return _kilogramsPerSecond; }
         }
 
         /// <summary>
@@ -67,7 +67,7 @@ public double KiloGramsPerSecond
         /// </summary>
         public double TonnesPerDay
         {
-            get { return _kiloGramsPerSecond/86.4000; }
+            get { return _kilogramsPerSecond/86.4000; }
         }
 
         #endregion
@@ -80,9 +80,9 @@ public static MassFlow Zero
         }
 
         /// <summary>
-        ///     Get MassFlow from KiloGramsPerSecond.
+        ///     Get MassFlow from KilogramsPerSecond.
         /// </summary>
-        public static MassFlow FromKiloGramsPerSecond(double kilogramspersecond)
+        public static MassFlow FromKilogramsPerSecond(double kilogramspersecond)
         {
             return new MassFlow(kilogramspersecond);
         }
@@ -106,8 +106,8 @@ public static MassFlow From(double value, MassFlowUnit fromUnit)
         {
             switch (fromUnit)
             {
-                case MassFlowUnit.KiloGramPerSecond:
-                    return FromKiloGramsPerSecond(value);
+                case MassFlowUnit.KilogramPerSecond:
+                    return FromKilogramsPerSecond(value);
                 case MassFlowUnit.TonnePerDay:
                     return FromTonnesPerDay(value);
 
@@ -134,37 +134,37 @@ public static string GetAbbreviation(MassFlowUnit unit, CultureInfo culture = nu
 
         public static MassFlow operator -(MassFlow right)
         {
-            return new MassFlow(-right._kiloGramsPerSecond);
+            return new MassFlow(-right._kilogramsPerSecond);
         }
 
         public static MassFlow operator +(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left._kiloGramsPerSecond + right._kiloGramsPerSecond);
+            return new MassFlow(left._kilogramsPerSecond + right._kilogramsPerSecond);
         }
 
         public static MassFlow operator -(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left._kiloGramsPerSecond - right._kiloGramsPerSecond);
+            return new MassFlow(left._kilogramsPerSecond - right._kilogramsPerSecond);
         }
 
         public static MassFlow operator *(double left, MassFlow right)
         {
-            return new MassFlow(left*right._kiloGramsPerSecond);
+            return new MassFlow(left*right._kilogramsPerSecond);
         }
 
         public static MassFlow operator *(MassFlow left, double right)
         {
-            return new MassFlow(left._kiloGramsPerSecond*(double)right);
+            return new MassFlow(left._kilogramsPerSecond*(double)right);
         }
 
         public static MassFlow operator /(MassFlow left, double right)
         {
-            return new MassFlow(left._kiloGramsPerSecond/(double)right);
+            return new MassFlow(left._kilogramsPerSecond/(double)right);
         }
 
         public static double operator /(MassFlow left, MassFlow right)
         {
-            return Convert.ToDouble(left._kiloGramsPerSecond/right._kiloGramsPerSecond);
+            return Convert.ToDouble(left._kilogramsPerSecond/right._kilogramsPerSecond);
         }
 
         #endregion
@@ -180,39 +180,39 @@ public int CompareTo(object obj)
 
         public int CompareTo(MassFlow other)
         {
-            return _kiloGramsPerSecond.CompareTo(other._kiloGramsPerSecond);
+            return _kilogramsPerSecond.CompareTo(other._kilogramsPerSecond);
         }
 
         public static bool operator <=(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond <= right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond <= right._kilogramsPerSecond;
         }
 
         public static bool operator >=(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond >= right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond >= right._kilogramsPerSecond;
         }
 
         public static bool operator <(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond < right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond < right._kilogramsPerSecond;
         }
 
         public static bool operator >(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond > right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond > right._kilogramsPerSecond;
         }
 
         public static bool operator ==(MassFlow left, MassFlow right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._kiloGramsPerSecond == right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond == right._kilogramsPerSecond;
         }
 
         public static bool operator !=(MassFlow left, MassFlow right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._kiloGramsPerSecond != right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond != right._kilogramsPerSecond;
         }
 
         public override bool Equals(object obj)
@@ -222,12 +222,12 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return _kiloGramsPerSecond.Equals(((MassFlow) obj)._kiloGramsPerSecond);
+            return _kilogramsPerSecond.Equals(((MassFlow) obj)._kilogramsPerSecond);
         }
 
         public override int GetHashCode()
         {
-            return _kiloGramsPerSecond.GetHashCode();
+            return _kilogramsPerSecond.GetHashCode();
         }
 
         #endregion
@@ -243,8 +243,8 @@ public double As(MassFlowUnit unit)
         {
             switch (unit)
             {
-                case MassFlowUnit.KiloGramPerSecond:
-                    return KiloGramsPerSecond;
+                case MassFlowUnit.KilogramPerSecond:
+                    return KilogramsPerSecond;
                 case MassFlowUnit.TonnePerDay:
                     return TonnesPerDay;
 
@@ -379,7 +379,7 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider
         /// <returns>String representation.</returns>
         public override string ToString()
         {
-            return ToString(MassFlowUnit.KiloGramPerSecond);
+            return ToString(MassFlowUnit.KilogramPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
index 447ce6b37e..6482241d60 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
@@ -40,74 +40,82 @@ public partial struct SpecificEnergy : IComparable, IComparable<SpecificEnergy>
         /// <summary>
         ///     Base unit of SpecificEnergy.
         /// </summary>
-        private readonly double _joulesPerKiloGram;
+        private readonly double _joulesPerKilogram;
 
         public SpecificEnergy(double joulesperkilogram) : this()
         {
-            _joulesPerKiloGram = joulesperkilogram;
+            _joulesPerKilogram = joulesperkilogram;
         }
 
         #region Properties
 
         public static SpecificEnergyUnit BaseUnit
         {
-            get { return SpecificEnergyUnit.JoulePerKiloGram; }
+            get { return SpecificEnergyUnit.JoulePerKilogram; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in JoulesPerKiloGram.
+        ///     Get SpecificEnergy in CaloriesPerGram.
         /// </summary>
-        public double JoulesPerKiloGram
+        public double CaloriesPerGram
         {
-            get { return _joulesPerKiloGram; }
+            get { return _joulesPerKilogram/4.184e3; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KiloCaloriesPerGram.
+        ///     Get SpecificEnergy in JoulesPerKilogram.
         /// </summary>
-        public double KiloCaloriesPerGram
+        public double JoulesPerKilogram
         {
-            get { return _joulesPerKiloGram/4.184e6; }
+            get { return _joulesPerKilogram; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KilojoulesPerKiloGram.
+        ///     Get SpecificEnergy in KilocaloriesPerGram.
         /// </summary>
-        public double KilojoulesPerKiloGram
+        public double KilocaloriesPerGram
         {
-            get { return (_joulesPerKiloGram) / 1e3d; }
+            get { return (_joulesPerKilogram/4.184e3) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattHoursPerKiloGram.
+        ///     Get SpecificEnergy in KilojoulesPerKilogram.
         /// </summary>
-        public double KilowattHoursPerKiloGram
+        public double KilojoulesPerKilogram
         {
-            get { return (_joulesPerKiloGram/3.6e3) / 1e3d; }
+            get { return (_joulesPerKilogram) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in MegajoulesPerKiloGram.
+        ///     Get SpecificEnergy in KilowattHoursPerKilogram.
         /// </summary>
-        public double MegajoulesPerKiloGram
+        public double KilowattHoursPerKilogram
         {
-            get { return (_joulesPerKiloGram) / 1e6d; }
+            get { return (_joulesPerKilogram/3.6e3) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattHoursPerKiloGram.
+        ///     Get SpecificEnergy in MegajoulesPerKilogram.
         /// </summary>
-        public double MegawattHoursPerKiloGram
+        public double MegajoulesPerKilogram
         {
-            get { return (_joulesPerKiloGram/3.6e3) / 1e6d; }
+            get { return (_joulesPerKilogram) / 1e6d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in WattHoursPerKiloGram.
+        ///     Get SpecificEnergy in MegawattHoursPerKilogram.
         /// </summary>
-        public double WattHoursPerKiloGram
+        public double MegawattHoursPerKilogram
         {
-            get { return _joulesPerKiloGram/3.6e3; }
+            get { return (_joulesPerKilogram/3.6e3) / 1e6d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in WattHoursPerKilogram.
+        /// </summary>
+        public double WattHoursPerKilogram
+        {
+            get { return _joulesPerKilogram/3.6e3; }
         }
 
         #endregion
@@ -120,57 +128,65 @@ public static SpecificEnergy Zero
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from JoulesPerKiloGram.
+        ///     Get SpecificEnergy from CaloriesPerGram.
+        /// </summary>
+        public static SpecificEnergy FromCaloriesPerGram(double caloriespergram)
+        {
+            return new SpecificEnergy(caloriespergram*4.184e3);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from JoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromJoulesPerKiloGram(double joulesperkilogram)
+        public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram)
         {
             return new SpecificEnergy(joulesperkilogram);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KiloCaloriesPerGram.
+        ///     Get SpecificEnergy from KilocaloriesPerGram.
         /// </summary>
-        public static SpecificEnergy FromKiloCaloriesPerGram(double kilocaloriespergram)
+        public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram)
         {
-            return new SpecificEnergy(kilocaloriespergram*4.184e6);
+            return new SpecificEnergy((kilocaloriespergram*4.184e3) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KilojoulesPerKiloGram.
+        ///     Get SpecificEnergy from KilojoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromKilojoulesPerKiloGram(double kilojoulesperkilogram)
+        public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilogram)
         {
             return new SpecificEnergy((kilojoulesperkilogram) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KilowattHoursPerKiloGram.
+        ///     Get SpecificEnergy from KilowattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerKiloGram(double kilowatthoursperkilogram)
+        public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthoursperkilogram)
         {
             return new SpecificEnergy((kilowatthoursperkilogram*3.6e3) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from MegajoulesPerKiloGram.
+        ///     Get SpecificEnergy from MegajoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromMegajoulesPerKiloGram(double megajoulesperkilogram)
+        public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilogram)
         {
             return new SpecificEnergy((megajoulesperkilogram) * 1e6d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from MegawattHoursPerKiloGram.
+        ///     Get SpecificEnergy from MegawattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerKiloGram(double megawatthoursperkilogram)
+        public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthoursperkilogram)
         {
             return new SpecificEnergy((megawatthoursperkilogram*3.6e3) * 1e6d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from WattHoursPerKiloGram.
+        ///     Get SpecificEnergy from WattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromWattHoursPerKiloGram(double watthoursperkilogram)
+        public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogram)
         {
             return new SpecificEnergy(watthoursperkilogram*3.6e3);
         }
@@ -186,20 +202,22 @@ public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
         {
             switch (fromUnit)
             {
-                case SpecificEnergyUnit.JoulePerKiloGram:
-                    return FromJoulesPerKiloGram(value);
-                case SpecificEnergyUnit.KiloCaloriePerGram:
-                    return FromKiloCaloriesPerGram(value);
-                case SpecificEnergyUnit.KilojoulePerKiloGram:
-                    return FromKilojoulesPerKiloGram(value);
-                case SpecificEnergyUnit.KilowattHourPerKiloGram:
-                    return FromKilowattHoursPerKiloGram(value);
-                case SpecificEnergyUnit.MegajoulePerKiloGram:
-                    return FromMegajoulesPerKiloGram(value);
-                case SpecificEnergyUnit.MegawattHourPerKiloGram:
-                    return FromMegawattHoursPerKiloGram(value);
-                case SpecificEnergyUnit.WattHourPerKiloGram:
-                    return FromWattHoursPerKiloGram(value);
+                case SpecificEnergyUnit.CaloriePerGram:
+                    return FromCaloriesPerGram(value);
+                case SpecificEnergyUnit.JoulePerKilogram:
+                    return FromJoulesPerKilogram(value);
+                case SpecificEnergyUnit.KilocaloriePerGram:
+                    return FromKilocaloriesPerGram(value);
+                case SpecificEnergyUnit.KilojoulePerKilogram:
+                    return FromKilojoulesPerKilogram(value);
+                case SpecificEnergyUnit.KilowattHourPerKilogram:
+                    return FromKilowattHoursPerKilogram(value);
+                case SpecificEnergyUnit.MegajoulePerKilogram:
+                    return FromMegajoulesPerKilogram(value);
+                case SpecificEnergyUnit.MegawattHourPerKilogram:
+                    return FromMegawattHoursPerKilogram(value);
+                case SpecificEnergyUnit.WattHourPerKilogram:
+                    return FromWattHoursPerKilogram(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -224,37 +242,37 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, CultureInfo cultur
 
         public static SpecificEnergy operator -(SpecificEnergy right)
         {
-            return new SpecificEnergy(-right._joulesPerKiloGram);
+            return new SpecificEnergy(-right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram + right._joulesPerKiloGram);
+            return new SpecificEnergy(left._joulesPerKilogram + right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram - right._joulesPerKiloGram);
+            return new SpecificEnergy(left._joulesPerKilogram - right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator *(double left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left*right._joulesPerKiloGram);
+            return new SpecificEnergy(left*right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator *(SpecificEnergy left, double right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram*(double)right);
+            return new SpecificEnergy(left._joulesPerKilogram*(double)right);
         }
 
         public static SpecificEnergy operator /(SpecificEnergy left, double right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram/(double)right);
+            return new SpecificEnergy(left._joulesPerKilogram/(double)right);
         }
 
         public static double operator /(SpecificEnergy left, SpecificEnergy right)
         {
-            return Convert.ToDouble(left._joulesPerKiloGram/right._joulesPerKiloGram);
+            return Convert.ToDouble(left._joulesPerKilogram/right._joulesPerKilogram);
         }
 
         #endregion
@@ -270,39 +288,39 @@ public int CompareTo(object obj)
 
         public int CompareTo(SpecificEnergy other)
         {
-            return _joulesPerKiloGram.CompareTo(other._joulesPerKiloGram);
+            return _joulesPerKilogram.CompareTo(other._joulesPerKilogram);
         }
 
         public static bool operator <=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram <= right._joulesPerKiloGram;
+            return left._joulesPerKilogram <= right._joulesPerKilogram;
         }
 
         public static bool operator >=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram >= right._joulesPerKiloGram;
+            return left._joulesPerKilogram >= right._joulesPerKilogram;
         }
 
         public static bool operator <(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram < right._joulesPerKiloGram;
+            return left._joulesPerKilogram < right._joulesPerKilogram;
         }
 
         public static bool operator >(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram > right._joulesPerKiloGram;
+            return left._joulesPerKilogram > right._joulesPerKilogram;
         }
 
         public static bool operator ==(SpecificEnergy left, SpecificEnergy right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._joulesPerKiloGram == right._joulesPerKiloGram;
+            return left._joulesPerKilogram == right._joulesPerKilogram;
         }
 
         public static bool operator !=(SpecificEnergy left, SpecificEnergy right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._joulesPerKiloGram != right._joulesPerKiloGram;
+            return left._joulesPerKilogram != right._joulesPerKilogram;
         }
 
         public override bool Equals(object obj)
@@ -312,12 +330,12 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return _joulesPerKiloGram.Equals(((SpecificEnergy) obj)._joulesPerKiloGram);
+            return _joulesPerKilogram.Equals(((SpecificEnergy) obj)._joulesPerKilogram);
         }
 
         public override int GetHashCode()
         {
-            return _joulesPerKiloGram.GetHashCode();
+            return _joulesPerKilogram.GetHashCode();
         }
 
         #endregion
@@ -333,20 +351,22 @@ public double As(SpecificEnergyUnit unit)
         {
             switch (unit)
             {
-                case SpecificEnergyUnit.JoulePerKiloGram:
-                    return JoulesPerKiloGram;
-                case SpecificEnergyUnit.KiloCaloriePerGram:
-                    return KiloCaloriesPerGram;
-                case SpecificEnergyUnit.KilojoulePerKiloGram:
-                    return KilojoulesPerKiloGram;
-                case SpecificEnergyUnit.KilowattHourPerKiloGram:
-                    return KilowattHoursPerKiloGram;
-                case SpecificEnergyUnit.MegajoulePerKiloGram:
-                    return MegajoulesPerKiloGram;
-                case SpecificEnergyUnit.MegawattHourPerKiloGram:
-                    return MegawattHoursPerKiloGram;
-                case SpecificEnergyUnit.WattHourPerKiloGram:
-                    return WattHoursPerKiloGram;
+                case SpecificEnergyUnit.CaloriePerGram:
+                    return CaloriesPerGram;
+                case SpecificEnergyUnit.JoulePerKilogram:
+                    return JoulesPerKilogram;
+                case SpecificEnergyUnit.KilocaloriePerGram:
+                    return KilocaloriesPerGram;
+                case SpecificEnergyUnit.KilojoulePerKilogram:
+                    return KilojoulesPerKilogram;
+                case SpecificEnergyUnit.KilowattHourPerKilogram:
+                    return KilowattHoursPerKilogram;
+                case SpecificEnergyUnit.MegajoulePerKilogram:
+                    return MegajoulesPerKilogram;
+                case SpecificEnergyUnit.MegawattHourPerKilogram:
+                    return MegawattHoursPerKilogram;
+                case SpecificEnergyUnit.WattHourPerKilogram:
+                    return WattHoursPerKilogram;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
@@ -479,7 +499,7 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro
         /// <returns>String representation.</returns>
         public override string ToString()
         {
-            return ToString(SpecificEnergyUnit.JoulePerKiloGram);
+            return ToString(SpecificEnergyUnit.JoulePerKilogram);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
index a34d158079..b3bed178e0 100644
--- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
+++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
@@ -95,6 +95,16 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (AngleUnit),
                     new[]
                     {
+                        new CulturesForEnumValue((int) AngleUnit.Arcminute,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "'", "arcmin", "amin", "min"),
+                            }),
+                        new CulturesForEnumValue((int) AngleUnit.Arcsecond,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "″", "arcsec", "asec", "sec"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Degree,
                             new[]
                             {
@@ -107,22 +117,12 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "g"),
                                 new AbbreviationsForCulture("ru-RU", "g"),
                             }),
-                        new CulturesForEnumValue((int) AngleUnit.MinuteOfArc,
-                            new[]
-                            {
-                                new AbbreviationsForCulture("en-US", "'", "min"),
-                            }),
                         new CulturesForEnumValue((int) AngleUnit.Radian,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "rad"),
                                 new AbbreviationsForCulture("ru-RU", "рад"),
                             }),
-                        new CulturesForEnumValue((int) AngleUnit.SecondOfArc,
-                            new[]
-                            {
-                                new AbbreviationsForCulture("en-US", "″", "sec"),
-                            }),
                     }),
                 new UnitLocalization(typeof (AreaUnit),
                     new[]
@@ -973,7 +973,7 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (MassFlowUnit),
                     new[]
                     {
-                        new CulturesForEnumValue((int) MassFlowUnit.KiloGramPerSecond,
+                        new CulturesForEnumValue((int) MassFlowUnit.KilogramPerSecond,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kg/s"),
@@ -1335,37 +1335,42 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (SpecificEnergyUnit),
                     new[]
                     {
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.JoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.CaloriePerGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "cal/g"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.JoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "J/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KiloCaloriePerGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilocaloriePerGram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kcal/g"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilojoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilojoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kJ/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilowattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilowattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kWh/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegajoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegajoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "MJ/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegawattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegawattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "MWh/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.WattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.WattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "Wh/kg"),
diff --git a/UnitsNet/Scripts/UnitDefinitions/Angle.json b/UnitsNet/Scripts/UnitDefinitions/Angle.json
index 0900738be8..551b4339d5 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Angle.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Angle.json
@@ -36,26 +36,26 @@
             ]
         },
 		{
-            "SingularName": "MinuteOfArc",
-            "PluralName": "MinutesOfArc",
+            "SingularName": "Arcminute",
+            "PluralName": "Arcminutes",
             "FromUnitToBaseFunc": "x/60",
             "FromBaseToUnitFunc": "x*60",
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["'", "min"]
+                    "Abbreviations": ["'", "arcmin", "amin", "min"]
                 }
             ]
         },
 		{
-            "SingularName": "SecondOfArc",
-            "PluralName": "SecondsOfArc",
+            "SingularName": "Arcsecond",
+            "PluralName": "Arcseconds",
             "FromUnitToBaseFunc": "x/3600",
             "FromBaseToUnitFunc": "x*3600",
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["″", "sec"]
+                    "Abbreviations": ["″", "arcsec", "asec", "sec"]
                 }
             ]
         },
diff --git a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
index 436802c78c..b9cbee5ca9 100644
--- a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
+++ b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
@@ -1,11 +1,11 @@
 {
     "Name": "MassFlow",
-    "BaseUnit": "KiloGramPerSecond",
+    "BaseUnit": "KilogramPerSecond",
     "XmlDoc": "",
     "Units": [
         {
-            "SingularName": "KiloGramPerSecond",
-            "PluralName": "KiloGramsPerSecond",
+            "SingularName": "KilogramPerSecond",
+            "PluralName": "KilogramsPerSecond",
             "FromUnitToBaseFunc": "x",
             "FromBaseToUnitFunc": "x",
             "Localization": [
diff --git a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
index de3719cb6c..8431ee10cc 100644
--- a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
+++ b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
@@ -1,12 +1,12 @@
 {
     "Name": "SpecificEnergy",
-    "BaseUnit": "JoulePerKiloGram",
+    "BaseUnit": "JoulePerKilogram",
     "XmlDoc": "The SpecificEnergy",
 	"XmlDocRemarks": "https://en.wikipedia.org/wiki/Specific_energy",
     "Units": [
         {
-            "SingularName": "JoulePerKiloGram",
-            "PluralName": "JoulesPerKiloGram",
+            "SingularName": "JoulePerKilogram",
+            "PluralName": "JoulesPerKilogram",
             "FromUnitToBaseFunc": "x",
             "FromBaseToUnitFunc": "x",
             "Prefixes": ["Kilo","Mega"],
@@ -18,20 +18,21 @@
             ]
         },
 		{
-            "SingularName": "KiloCaloriePerGram",
-            "PluralName": "KiloCaloriesPerGram",
-            "FromUnitToBaseFunc": "x*4.184e6",
-            "FromBaseToUnitFunc": "x/4.184e6",
+            "SingularName": "CaloriePerGram",
+            "PluralName": "CaloriesPerGram",
+            "FromUnitToBaseFunc": "x*4.184e3",
+            "FromBaseToUnitFunc": "x/4.184e3",
+            "Prefixes": ["Kilo"],
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["kcal/g"]
+                    "Abbreviations": ["cal/g"]
                 }
             ]
 		},
 		{
-            "SingularName": "WattHourPerKiloGram",
-            "PluralName": "WattHoursPerKiloGram",
+            "SingularName": "WattHourPerKilogram",
+            "PluralName": "WattHoursPerKilogram",
             "FromUnitToBaseFunc": "x*3.6e3",
             "FromBaseToUnitFunc": "x/3.6e3",
             "Prefixes": ["Kilo","Mega"],

From 59d86660e1299bf6423d281e63093b8a8d4194e6 Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@stormgeo.com>
Date: Sun, 17 Jan 2016 13:20:06 +0100
Subject: [PATCH 4/4] Cross checked all new tests and fixed MassFlow

---
 .../UnitsNet.Serialization.JsonNet.Tests.csproj               | 3 ---
 UnitsNet.Tests/CustomCode/LengthTests.cs                      | 2 +-
 UnitsNet.Tests/CustomCode/MassFlowTests.cs                    | 2 +-
 UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs              | 4 ++--
 UnitsNet/Scripts/UnitDefinitions/MassFlow.json                | 4 ++--
 5 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
index 7d6fe10699..d24fc02fc6 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
@@ -67,9 +67,6 @@
       <Name>UnitsNet.Net35</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index 0d4d3d3a2d..896da4f6e4 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -93,7 +93,7 @@ protected override double YardsInOneMeter
         protected override double NauticalMilesInOneMeter
         {
             get
-            { return 5.3996E-04; }
+            { return 1.0/1852.0; }
         }
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 1b934169b4..21f452ded4 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -39,7 +39,7 @@ protected override double TonnesPerDayInOneKilogramPerSecond
         {
             get
             {
-                return 1.0 / (60.0 * 60 * 24 / 1000);
+                return (60.0 * 60 * 24 / 1000);
             }
         }
     }
diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
index 57429539c2..c873a47a41 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
@@ -67,7 +67,7 @@ public double KilogramsPerSecond
         /// </summary>
         public double TonnesPerDay
         {
-            get { return _kilogramsPerSecond/86.4000; }
+            get { return _kilogramsPerSecond*86.4000; }
         }
 
         #endregion
@@ -92,7 +92,7 @@ public static MassFlow FromKilogramsPerSecond(double kilogramspersecond)
         /// </summary>
         public static MassFlow FromTonnesPerDay(double tonnesperday)
         {
-            return new MassFlow(tonnesperday*86.4000);
+            return new MassFlow(tonnesperday/86.4000);
         }
 
 
diff --git a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
index b9cbee5ca9..3645b8a26a 100644
--- a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
+++ b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
@@ -18,8 +18,8 @@
 		{
             "SingularName": "TonnePerDay",
             "PluralName": "TonnesPerDay",
-            "FromUnitToBaseFunc": "x*86.4000",
-            "FromBaseToUnitFunc": "x/86.4000",
+            "FromUnitToBaseFunc": "x/86.4000",
+            "FromBaseToUnitFunc": "x*86.4000",
             "Localization": [
                 {
                     "Culture": "en-US",