Added support for Duration

Author: Erik Ovegard

UnitsNet.Tests/CustomCode/AngleTests.cs

@@ -27,12 +27,19 @@ namespace UnitsNet.Tests.CustomCode
     public class AngleTests : AngleTestsBase
     {
         [Test]
-        public void AngleDividedByTimeEqualsRotationalSpeed()
+        public void AngleDividedByTimeSpanEqualsRotationalSpeed()
         {
             var rotationalSpeed = Angle.FromRadians(10)/TimeSpan.FromSeconds(5);
             Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
         }
 
+        [Test]
+        public void AngleDividedByDurationEqualsRotationalSpeed()
+        {
+            var rotationalSpeed = Angle.FromRadians(10) / Duration.FromSeconds(5);
+            Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
+        }
+
         protected override double DegreesInOneDegree
         {
             get { return 1; }

UnitsNet.Tests/CustomCode/MassFlowTests.cs

@@ -27,7 +27,6 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class MassFlowTests : MassFlowTestsBase
     {
-        // strange bug
         [Test]
         public void MassFlowTimesTimeSpanEqualsMass()
         {
@@ -41,7 +40,19 @@ public void TimeSpanTimesMassFlowEqualsMass()
             Assert.AreEqual(mass, Mass.FromKilograms(80.0));
         }
 
-        // TODO Override properties in base class here
+        [Test]
+        public void MassFlowTimesDurationEqualsMass()
+        {
+            var mass = MassFlow.FromKilogramsPerSecond(20.0) * Duration.FromSeconds(4.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+        [Test]
+        public void DurationTimesMassFlowEqualsMass()
+        {
+            var mass = Duration.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+
         protected override double KilogramsPerSecondInOneKilogramPerSecond
         {
             get

UnitsNet.Tests/CustomCode/MassTests.cs

@@ -26,12 +26,19 @@ namespace UnitsNet.Tests.CustomCode
     public class MassTests : MassTestsBase
     {
         [Test]
-        public void MassDividedByTimeEqualsMassFlow()
+        public void MassDividedByTimeSpanEqualsMassFlow()
         {
             var massFlow= Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);
             Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
         }
 
+        [Test]
+        public void MassDividedByDurationEqualsMassFlow()
+        {
+            var massFlow = Mass.FromKilograms(18.0) / Duration.FromSeconds(6);
+            Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
+        }
+
         [Test]
         public void MassDividedByVolumeEqualsDensity()
         {

UnitsNet.Tests/CustomCode/PowerTests.cs

@@ -44,7 +44,7 @@ public void PowerDevidedByTorqueEqualsRotationalSpeed()
             Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
         }
         [Test]
-        public void PowerTimesTimespanEqualsEnergy()
+        public void PowerTimesTimeSpanEqualsEnergy()
         {
             var energy = Power.FromWatts(5.0)*TimeSpan.FromSeconds(8.0);
             Assert.AreEqual(energy, Energy.FromJoules(40.0));
@@ -55,6 +55,20 @@ public void TimeSpanTimesPowerEqualsEnergy()
             var energy = TimeSpan.FromSeconds(8.0)* Power.FromWatts(5.0);
             Assert.AreEqual(energy, Energy.FromJoules(40.0));
         }
+
+        [Test]
+        public void PowerTimesDurationEqualsEnergy()
+        {
+            var energy = Power.FromWatts(5.0) * Duration.FromSeconds(8.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+        [Test]
+        public void DurationTimesPowerEqualsEnergy()
+        {
+            var energy = Duration.FromSeconds(8.0) * Power.FromWatts(5.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+
         protected override double FemtowattsInOneWatt
         {
             get { return 1e15; }

UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs

@@ -41,6 +41,20 @@ public void TimeSpanTimesRotationalSpeedEqualsAngle()
             Assert.AreEqual(angle, Angle.FromRadians(90.0));
         }
 
+        [Test]
+        public void RotationalSpeedTimesDurationEqualsAngle()
+        {
+            var angle = RotationalSpeed.FromRadiansPerSecond(10.0) * Duration.FromSeconds(9.0);
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
+        [Test]
+        public void DurationTimesRotationalSpeedEqualsAngle()
+        {
+            var angle = Duration.FromSeconds(9.0) * RotationalSpeed.FromRadiansPerSecond(10.0);
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
         [Test]
         public void RotationalSpeedTimesForceEqualsPower()
         {

UnitsNet.Tests/CustomCode/SpeedTests.cs

@@ -27,7 +27,7 @@ namespace UnitsNet.Tests.CustomCode
     public class SpeedTests : SpeedTestsBase
     {
         [Test]
-        public void SpeedDevidedByTimespanEqualsAcceleration()
+        public void SpeedDevidedByTimeSpanEqualsAcceleration()
         {
             var acceleration = Speed.FromMetersPerSecond(20) / TimeSpan.FromSeconds(2);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
@@ -40,6 +40,20 @@ public void SpeedTimesTimeSpanEqualsLength()
             Assert.AreEqual(length, Length.FromMeters(40));
         }
 
+        [Test]
+        public void SpeedDevidedByDurationEqualsAcceleration()
+        {
+            var acceleration = Speed.FromMetersPerSecond(20) / Duration.FromSeconds(2);
+            Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
+        }
+
+        [Test]
+        public void SpeedTimesDurationEqualsLength()
+        {
+            var length = Speed.FromMetersPerSecond(20) * Duration.FromSeconds(2);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
         [Test]
         public void TimeSpanSpeedTimesEqualsLength()
         {
@@ -54,6 +68,20 @@ public void LengthDividedByTimeSpanEqualsSpeed()
             Assert.AreEqual(speed, Speed.FromMetersPerSecond(10));
         }
 
+        [Test]
+        public void DurationSpeedTimesEqualsLength()
+        {
+            var length = Duration.FromSeconds(2) * Speed.FromMetersPerSecond(20);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
+        [Test]
+        public void LengthDividedByDurationEqualsSpeed()
+        {
+            var speed = Length.FromMeters(20) / Duration.FromSeconds(2);
+            Assert.AreEqual(speed, Speed.FromMetersPerSecond(10));
+        }
+
         protected override double FeetPerSecondInOneMeterPerSecond
         {
             get { return 3.28084; }

UnitsNet/CustomCode/UnitClasses/Angle.extra.cs

@@ -29,5 +29,10 @@ public partial struct Angle
         {
             return RotationalSpeed.FromRadiansPerSecond(angle.Radians / timeSpan.TotalSeconds);
         }
+
+        public static RotationalSpeed operator /(Angle angle, Duration duration)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(angle.Radians / duration.Seconds);
+        }
     }
 }

UnitsNet/CustomCode/UnitClasses/Length.extra.cs

@@ -40,6 +40,12 @@ public static Length FromFeetInches(double feet, double inches)
         {
             return Speed.FromMetersPerSecond(length.Meters / timeSpan.TotalSeconds);
         }
+
+        public static Speed operator /(Length length, Duration duration)
+        {
+            return Speed.FromMetersPerSecond(length.Meters / duration.Seconds);
+        }
+
         public static Area operator*(Length length1, Length length2)
         {
             return Area.FromSquareMeters(length1.Meters * length2.Meters);

UnitsNet/CustomCode/UnitClasses/Mass.extra.cs

@@ -67,6 +67,11 @@ public static Mass FromStonePounds(double stone, double pounds)
             return MassFlow.FromKilogramsPerSecond(mass.Kilograms / timeSpan.TotalSeconds);
         }
 
+        public static MassFlow operator /(Mass mass, Duration duration)
+        {
+            return MassFlow.FromKilogramsPerSecond(mass.Kilograms / duration.Seconds);
+        }
+
         public static Density operator /(Mass mass, Volume volume)
         {
             return Density.FromKilogramsPerCubicMeter(mass.Kilograms / volume.CubicMeters);

UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs

@@ -34,5 +34,14 @@ public partial struct MassFlow
         {
             return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
         }
+
+        public static Mass operator *(MassFlow massFlow, Duration duration)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+        }
+        public static Mass operator *(Duration duration, MassFlow massFlow)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+        }
     }
 }