Mass flow, specific energy and some new units

UnitsNet.Tests/CustomCode/AngleTests.cs

@@ -35,9 +35,25 @@ protected override double GradiansInOneDegree
             get { return 400/360.0; }
         }
 
+        protected override double ArcminutesInOneDegree
+        {
+            get
+            {
+                return 60.0;
+            }
+        }
+
         protected override double RadiansInOneDegree
         {
             get { return Math.PI/2/90; }
         }
+
+        protected override double ArcsecondsInOneDegree
+        {
+            get
+            {
+                return 3600.0;
+            }
+        }
     }
 }

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;
+            }
+        }
     }
 }

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 1.0/1852.0; }
+        }
     }
 }

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 (60.0 * 60 * 24 / 1000);
+            }
+        }
+    }
+}

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; }

UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs

@@ -0,0 +1,94 @@
+// 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
+    {
+        protected override double JoulesPerKilogramInOneJoulePerKilogram
+        {
+            get
+            {
+                return 1.0;
+            }
+        }
+
+        protected override double CaloriesPerGramInOneJoulePerKilogram
+        {
+            get
+            {
+                return 1.0 / (4.184E3);
+            }
+        }
+
+        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;
+            }
+        }
+    }
+}

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;
+            }
+        }
     }
 }

UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs

@@ -36,11 +36,15 @@ 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 RadiansInOneDegree { 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 RadiansTolerance { get { return 1e-5; } }
@@ -50,6 +54,8 @@ public abstract partial class AngleTestsBase
         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(RadiansInOneDegree, degree.Radians, RadiansTolerance);
@@ -58,6 +64,8 @@ public void DegreeToAngleUnits()
         [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.Radian).Radians, RadiansTolerance);
@@ -67,6 +75,8 @@ public void FromValueAndUnit()
         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(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
@@ -76,6 +86,8 @@ public void As()
         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.FromRadians(degree.Radians).Degrees, RadiansTolerance);

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);
         }
 

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);
         }