Modified VolumeTests.cs to match other unit tests.

Author: angularsen

Tests/VolumeTests.cs

@@ -7,122 +7,129 @@ namespace UnitsNet.Tests.net35
     public class VolumeTests
     {
         private const double Delta = 1E-5;
-        private Volume cubicMeter;
-        private Volume liter;
-        private Volume otherLiter;
-
-        [SetUp]
-        public void Setup()
-        {
-            cubicMeter = Volume.FromCubicMeters(1);
-            liter = Volume.FromLiters(1);
-            otherLiter = Volume.FromLiters(1);
-        }
+        private readonly Volume _cubicMeter = Volume.FromCubicMeters(1);
 
         [Test]
         public void CubicMetersToVolumeUnits()
         {
-            Assert.AreEqual(1E-9, cubicMeter.CubicKilometers, Delta);
-            Assert.AreEqual(1, cubicMeter.CubicMeters, Delta);
-            Assert.AreEqual(1E3, cubicMeter.CubicDecimeters, Delta);
-            Assert.AreEqual(1E6, cubicMeter.CubicCentimeters, Delta);
-            Assert.AreEqual(1E9, cubicMeter.CubicMillimeters, Delta);
-
-            Assert.AreEqual(1E1, cubicMeter.Hectoliters, Delta);
-            Assert.AreEqual(1E3, cubicMeter.Liters, Delta);
-            Assert.AreEqual(1E4, cubicMeter.Deciliters, Delta);
-            Assert.AreEqual(1E5, cubicMeter.Centiliters, Delta);
-            Assert.AreEqual(1E6, cubicMeter.Milliliters, Delta);
+            Assert.AreEqual(1E-9, _cubicMeter.CubicKilometers, Delta);
+            Assert.AreEqual(1, _cubicMeter.CubicMeters, Delta);
+            Assert.AreEqual(1E3, _cubicMeter.CubicDecimeters, Delta);
+            Assert.AreEqual(1E6, _cubicMeter.CubicCentimeters, Delta);
+            Assert.AreEqual(1E9, _cubicMeter.CubicMillimeters, Delta);
+
+            Assert.AreEqual(1E1, _cubicMeter.Hectoliters, Delta);
+            Assert.AreEqual(1E3, _cubicMeter.Liters, Delta);
+            Assert.AreEqual(1E4, _cubicMeter.Deciliters, Delta);
+            Assert.AreEqual(1E5, _cubicMeter.Centiliters, Delta);
+            Assert.AreEqual(1E6, _cubicMeter.Milliliters, Delta);
         }
 
         [Test]
         public void VolumeUnitsRoundTrip()
         {
-            Assert.AreEqual(1, Volume.FromCubicKilometers(cubicMeter.CubicKilometers).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromCubicMeters(cubicMeter.CubicMeters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromCubicDecimeters(cubicMeter.CubicDecimeters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromCubicCentimeters(cubicMeter.CubicCentimeters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromCubicMillimeters(cubicMeter.CubicMillimeters).CubicMeters, Delta);
-
-            Assert.AreEqual(1, Volume.FromHectoliters(cubicMeter.Hectoliters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromLiters(cubicMeter.Liters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromDeciliters(cubicMeter.Deciliters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromCentiliters(cubicMeter.Centiliters).CubicMeters, Delta);
-            Assert.AreEqual(1, Volume.FromMilliliters(cubicMeter.Milliliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicKilometers(_cubicMeter.CubicKilometers).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicMeters(_cubicMeter.CubicMeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicDecimeters(_cubicMeter.CubicDecimeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicCentimeters(_cubicMeter.CubicCentimeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicMillimeters(_cubicMeter.CubicMillimeters).CubicMeters, Delta);
+
+            Assert.AreEqual(1, Volume.FromHectoliters(_cubicMeter.Hectoliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromLiters(_cubicMeter.Liters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromDeciliters(_cubicMeter.Deciliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCentiliters(_cubicMeter.Centiliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromMilliliters(_cubicMeter.Milliliters).CubicMeters, Delta);
         }
 
         [Test]
         public void ArithmeticOperatorsRoundtrip()
         {
-            Assert.AreEqual(Volume.FromLiters(-1000).CubicMeters, (-cubicMeter).CubicMeters, Delta);
-            Assert.AreEqual(Volume.FromLiters(1000 - 1).CubicMeters, (cubicMeter - liter).CubicMeters, Delta);
-            Assert.AreEqual(Volume.FromLiters(1000 + 1).CubicMeters, (cubicMeter + liter).CubicMeters, Delta);
+            Volume v = Volume.FromLiters(1);
+            Assert.AreEqual(-1, -v.Liters, Delta);
+            Assert.AreEqual(2, (Volume.FromLiters(3)-v).Liters, Delta);
+            Assert.AreEqual(2, (v + v).Liters, Delta);
+            Assert.AreEqual(10, (v*10).Liters, Delta);
+            Assert.AreEqual(10, (10*v).Liters, Delta);
+            Assert.AreEqual(2, (Volume.FromLiters(10)/5).Liters, Delta);
+            Assert.AreEqual(2, Volume.FromLiters(10)/Volume.FromLiters(5), Delta);
         }
 
         [Test]
-        public void ComparableOperatorsRoundtrip()
+        public void ComparisonOperators()
         {
-            Assert.IsTrue(liter < cubicMeter);
-            Assert.IsFalse(cubicMeter < liter);
-
-            Assert.IsTrue(liter <= cubicMeter);
-            Assert.IsFalse(cubicMeter <= liter);
-            Assert.IsTrue(liter <= Volume.FromLiters(1));
-
-            Assert.IsTrue(cubicMeter > liter);
-            Assert.IsFalse(liter > cubicMeter);
-
-            Assert.IsTrue(cubicMeter >= liter);
-            Assert.IsFalse(liter >= cubicMeter);
-            Assert.IsTrue(liter >= Volume.FromLiters(1));
-
-            Assert.IsTrue(liter == otherLiter);
-            Assert.IsFalse(liter == cubicMeter);
-
-            Assert.IsTrue(liter != cubicMeter);
-            Assert.IsFalse(liter != otherLiter);
+            Volume oneCubicMeter = Volume.FromCubicMeters(1);
+            Volume twoCubicMeters = Volume.FromCubicMeters(2);
+
+            Assert.True(oneCubicMeter < twoCubicMeters);
+            Assert.True(oneCubicMeter <= twoCubicMeters);
+            Assert.True(twoCubicMeters > oneCubicMeter);
+            Assert.True(twoCubicMeters >= oneCubicMeter);
+
+            Assert.False(oneCubicMeter > twoCubicMeters);
+            Assert.False(oneCubicMeter >= twoCubicMeters);
+            Assert.False(twoCubicMeters < oneCubicMeter);
+            Assert.False(twoCubicMeters <= oneCubicMeter);
         }
 
         [Test]
         public void CompareToIsImplemented()
         {
-            Assert.AreEqual(0, cubicMeter.CompareTo(cubicMeter));
-            Assert.IsTrue(cubicMeter.CompareTo(Volume.Zero) > 0);
-            Assert.IsTrue(Volume.Zero.CompareTo(cubicMeter) < 0);
+            Volume meter = Volume.FromCubicMeters(1);
+            Assert.AreEqual(0, meter.CompareTo(meter));
+            Assert.Greater(meter.CompareTo(Volume.Zero), 0);
+            Assert.Less(Volume.Zero.CompareTo(meter), 0);
         }
 
         [Test]
         [ExpectedException(typeof(ArgumentException))]
-        public void CompareToCanHandleTypeMismatch()
+        public void CompareToThrowsOnTypeMismatch()
         {
-            cubicMeter.CompareTo(new object());
+            Volume meter = Volume.FromCubicMeters(1);
+            meter.CompareTo(new object());
         }
 
         [Test]
         [ExpectedException(typeof(ArgumentNullException))]
-        public void CompareToCanHandleNullInstance()
+        public void CompareToThrowsOnNull()
+        { 
+            Volume meter = Volume.FromCubicMeters(1);
+            meter.CompareTo(null);
+        }
+
+
+        [Test]
+        public void EqualityOperators()
         {
-            cubicMeter.CompareTo((object)null);
+            Volume a = Volume.FromCubicMeters(1);
+            Volume b = Volume.FromCubicMeters(2);
+
+            Assert.True(a == a); 
+            Assert.True(a != b);
+
+            Assert.False(a == b);
+            Assert.False(a != a);
         }
 
         [Test]
         public void EqualsIsImplemented()
         {
-            Assert.IsTrue(cubicMeter.Equals(Volume.FromCubicMeters(1)));
-            Assert.IsTrue(cubicMeter.Equals(cubicMeter));
-            Assert.IsFalse(cubicMeter.Equals(liter));
+            Volume v = Volume.FromCubicMeters(1);
+            Assert.IsTrue(v.Equals(Volume.FromCubicMeters(1)));
+            Assert.IsFalse(v.Equals(Volume.Zero));
         }
 
         [Test]
-        public void EqualsCanHandleTypeMismatch()
+        public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Assert.IsFalse(cubicMeter.Equals(new object()));
+            Volume meter = Volume.FromCubicMeters(1);
+            Assert.IsFalse(meter.Equals(new object()));
         }
 
         [Test]
-        public void EqualsCanHandleNullInstance()
+        public void EqualsReturnsFalseOnNull()
         {
-            Assert.IsFalse(cubicMeter.Equals(null));
+            Volume meter = Volume.FromCubicMeters(1);
+            Assert.IsFalse(meter.Equals(null));
         }
     }
 }