Feature/operator overloading

UnitsNet.Tests/CustomCode/AngleTests.cs

@@ -20,11 +20,25 @@
 // THE SOFTWARE.
 
 using System;
+using NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class AngleTests : AngleTestsBase
     {
+        [Test]
+        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
         {
@@ -33,7 +47,7 @@ protected override double DegreesInOneDegree
 
         protected override double GradiansInOneDegree
         {
-            get { return 400/360.0; }
+            get { return 400 / 360.0; }
         }
 
         protected override double ArcminutesInOneDegree
@@ -46,7 +60,7 @@ protected override double ArcminutesInOneDegree
 
         protected override double RadiansInOneDegree
         {
-            get { return Math.PI/2/90; }
+            get { return Math.PI / 2 / 90; }
         }
 
         protected override double NanoradiansInOneDegree

UnitsNet.Tests/CustomCode/AreaTests.cs

@@ -19,10 +19,19 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class AreaTests : AreaTestsBase
     {
+        [Test]
+        public void AreaDividedByLengthEqualsLength()
+        {
+            var length = Area.FromSquareMeters(50) / Length.FromMeters(5);
+            Assert.AreEqual(length, Length.FromMeters(10));
+        }
+
         protected override double SquareCentimetersInOneSquareMeter
         {
             get { return 1E4; }

UnitsNet.Tests/CustomCode/DensityTests.cs

@@ -19,10 +19,26 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class DensityTests : DensityTestsBase
     {
+        [Test]
+        public static void DensityTimesVolumeEqualsMass()
+        {
+            var mass = Density.FromKilogramsPerCubicMeter(2) * Volume.FromCubicMeters(3);
+            Assert.AreEqual(mass, Mass.FromKilograms(6));
+        }
+
+        [Test]
+        public static void VolumeTimesDensityEqualsMass()
+        {
+            var mass = Volume.FromCubicMeters(3) * Density.FromKilogramsPerCubicMeter(2);
+            Assert.AreEqual(mass, Mass.FromKilograms(6));
+        }
+
         protected override double KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter
         {
             get { return 1e-6; }

UnitsNet.Tests/CustomCode/ForceTests.cs

@@ -18,11 +18,36 @@
 // 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 NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class ForceTests : ForceTestsBase
     {
+        [Test]
+        public void ForceTimesSpeedEqualsPower()
+        {
+            var power = Force.FromNewtons(27.0) * Speed.FromMetersPerSecond(10.0);
+            Assert.AreEqual(power, Power.FromWatts(270));
+        }
+        [Test]
+        public void SpeedTimesForceEqualsPower()
+        {
+            var power = Speed.FromMetersPerSecond(10.0)* Force.FromNewtons(27.0);
+            Assert.AreEqual(power, Power.FromWatts(270));
+        }
+        [Test]
+        public void ForceDividedByMassEqualsAcceleration()
+        {
+            var acceleration= Force.FromNewtons(27)/Mass.FromKilograms(9);
+            Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(3));
+        }
+        [Test]
+        public void ForceDividedByAreaEqualsPressure()
+        {
+            var pressure=Force.FromNewtons(81)/Area.FromSquareMeters(9);
+            Assert.AreEqual(pressure, Pressure.FromNewtonsPerSquareMeter(9));
+        }
         protected override double DyneInOneNewton
         {
             get { return 1E5; }

UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs

@@ -20,12 +20,48 @@
 // THE SOFTWARE.
 
 
+using NUnit.Framework;
 using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class KinematicViscosityTests : KinematicViscosityTestsBase
     {
+        [Test]
+        public static void KinematicViscosityDividedByLengthEqualsSpeed()
+        {
+            var speed = KinematicViscosity.FromSquareMetersPerSecond(4) / Length.FromMeters(2);
+            Assert.AreEqual(speed, Speed.FromMetersPerSecond(2));
+        }
+
+        [Test]
+        public static void KinematicViscosityTimesTimeSpanEqualsArea()
+        {
+            var area = KinematicViscosity.FromSquareMetersPerSecond(4) * TimeSpan.FromSeconds(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void TimeSpanTimesKinematicViscosityEqualsArea()
+        {
+            var area = TimeSpan.FromSeconds(2) * KinematicViscosity.FromSquareMetersPerSecond(4);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void KinematicViscosityTimesDurationEqualsArea()
+        {
+            var area = KinematicViscosity.FromSquareMetersPerSecond(4) * Duration.FromSeconds(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void DurationTimesKinematicViscosityEqualsArea()
+        {
+            var area = Duration.FromSeconds(2) * KinematicViscosity.FromSquareMetersPerSecond(4);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
         #region Overrides of KinematicViscosityTestsBase
 
         protected override double CentistokesInOneSquareMeterPerSecond

UnitsNet.Tests/CustomCode/LengthTests.cs

@@ -20,11 +20,46 @@
 // THE SOFTWARE.
 
 using System;
+using NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class LengthTests : LengthTestsBase
     {
+        [Test]
+        public void LengthTimesLengthEqualsArea()
+        {
+            var area = Length.FromMeters(10) * Length.FromMeters(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(20));
+        }
+
+        [Test]
+        public void AreaTimesLengthEqualsVolume()
+        {
+            var volume = Area.FromSquareMeters(10) * Length.FromMeters(3);
+            Assert.AreEqual(volume, Volume.FromCubicMeters(30));
+        }
+        [Test]
+        public void LengthTimesAreaEqualsVolume()
+        {
+            var volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
+            Assert.AreEqual(volume, Volume.FromCubicMeters(27));
+        }
+
+        [Test]
+        public void ForceTimesLengthEqualsTorque()
+        {
+            var torque = Force.FromNewtons(1) * Length.FromMeters(3);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(3));
+        }
+
+        [Test]
+        public void LengthTimesForceEqualsTorque()
+        {
+            var torque = Length.FromMeters(3) * Force.FromNewtons(1);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(3));
+        }
+
         protected override double CentimetersInOneMeter
         {
             get { return 100; }
@@ -90,10 +125,12 @@ protected override double YardsInOneMeter
             get { return 1.09361; }
         }
 
+
         protected override double NauticalMilesInOneMeter
         {
             get
             { return 1.0/1852.0; }
         }
+
     }
 }

UnitsNet.Tests/CustomCode/MassFlowTests.cs

@@ -19,22 +19,49 @@
 // 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;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class MassFlowTests : MassFlowTestsBase
     {
+        [Test]
+        public void MassFlowTimesTimeSpanEqualsMass()
+        {
+            var mass = MassFlow.FromKilogramsPerSecond(20.0) * TimeSpan.FromSeconds(4.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+        [Test]
+        public void TimeSpanTimesMassFlowEqualsMass()
+        {
+            var mass = TimeSpan.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+
+        [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 GramsPerSecondInOneGramPerSecond
         {
             get { return 1; }
         }
 
         protected override double DecagramsPerSecondInOneGramPerSecond
-        {
+            {
             get { return 1E-1; }
-        }
+            }
 
         protected override double HectogramsPerSecondInOneGramPerSecond
         {

UnitsNet.Tests/CustomCode/MassTests.cs

@@ -18,11 +18,48 @@
 // 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 NUnit.Framework;
+using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class MassTests : MassTestsBase
     {
+        [Test]
+        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()
+        {
+            var density = Mass.FromKilograms(18) / Volume.FromCubicMeters(3);
+            Assert.AreEqual(density, Density.FromKilogramsPerCubicMeter(6));
+        }
+
+        [Test]
+        public void MassTimesAccelerationEqualsForce()
+        {
+            var force = Mass.FromKilograms(18) * Acceleration.FromMeterPerSecondSquared(3);
+            Assert.AreEqual(force, Force.FromNewtons(54));
+        }
+
+        [Test]
+        public void AccelerationTimesMassEqualsForce()
+        {
+            var force = Acceleration.FromMeterPerSecondSquared(3) * Mass.FromKilograms(18);
+            Assert.AreEqual(force, Force.FromNewtons(54));
+        }
+
         protected override double CentigramsInOneKilogram
         {
             get { return 1E5; }

UnitsNet.Tests/CustomCode/PowerTests.cs

@@ -18,11 +18,57 @@
 // 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 NUnit.Framework;
+using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class PowerTests : PowerTestsBase
     {
+        [Test]
+        public void PowerDividedBySpeedEqualsForce()
+        {
+            var force= Power.FromWatts(15.0) / Speed.FromMetersPerSecond(3);
+            Assert.AreEqual(force, Force.FromNewtons(5));
+        }
+        [Test]
+        public void PowerDividedByRotationalSpeedEqualsForce()
+        {
+            var torque = Power.FromWatts(15.0) / RotationalSpeed.FromRadiansPerSecond(3);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(5));
+        }
+        [Test]
+        public void PowerDividedByTorqueEqualsRotationalSpeed()
+        {
+            var rotationalSpeed= Power.FromWatts(15.0) / Torque.FromNewtonMeters(3);
+            Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
+        }
+        [Test]
+        public void PowerTimesTimeSpanEqualsEnergy()
+        {
+            var energy = Power.FromWatts(5.0)*TimeSpan.FromSeconds(8.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+        [Test]
+        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; }