Merge branch 'v4' into Dimensionless

Author: tmilnthorp

UnitsNet.Tests/BaseDimensionsTests.cs

@@ -28,14 +28,13 @@ public void ConstructorImplementedCorrectly()
         [InlineData(0, 0, 0, 0, 1, 0, 0)]
         [InlineData(0, 0, 0, 0, 0, 1, 0)]
         [InlineData(0, 0, 0, 0, 0, 0, 1)]
-        public void IsBaseImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
+        public void IsBaseQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
         {
             var baseDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity);
             var derivedDimensions = new BaseDimensions(length * 2, mass * 2, time * 2, current * 2, temperature * 2, amount * 2, luminousIntensity * 2);
 
-            Assert.True(baseDimensions.IsBase());
-            Assert.False(derivedDimensions.IsBase());
-            Assert.False(BaseDimensions.Dimensionless.IsBase());
+            Assert.True(baseDimensions.IsBaseQuantity());
+            Assert.False(derivedDimensions.IsBaseQuantity());
         }
 
         [Theory]
@@ -46,14 +45,13 @@ public void IsBaseImplementedProperly(int length, int mass, int time, int curren
         [InlineData(0, 0, 0, 0, 2, 0, 0)]
         [InlineData(0, 0, 0, 0, 0, 2, 0)]
         [InlineData(0, 0, 0, 0, 0, 0, 2)]
-        public void IsDerivedImplementedSuccessfully(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
+        public void IsDerivedQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
         {
             var baseDimensions = new BaseDimensions(length / 2, mass / 2, time / 2, current / 2, temperature / 2, amount / 2, luminousIntensity / 2);
             var derivedDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity);
 
-            Assert.False(baseDimensions.IsDerived());
-            Assert.True(derivedDimensions.IsDerived());
-            Assert.False(BaseDimensions.Dimensionless.IsDerived());
+            Assert.False(baseDimensions.IsDerivedQuantity());
+            Assert.True(derivedDimensions.IsDerivedQuantity());
         }
 
         [Fact]
@@ -82,6 +80,11 @@ public void EqualityOperatorsWorkAsExpected()
 
             Assert.False(baseDimensions2 == null);
             Assert.False(null == baseDimensions2);
+
+            BaseDimensions nullBaseDimensions1 = null;
+            BaseDimensions nullBaseDimensions2 = null;
+
+            Assert.True(nullBaseDimensions1 == nullBaseDimensions2);
         }
 
         [Fact]
@@ -98,6 +101,11 @@ public void InequalityOperatorsWorkAsExpected()
 
             Assert.True(baseDimensions2 != null);
             Assert.True(null != baseDimensions2);
+
+            BaseDimensions nullBaseDimensions1 = null;
+            BaseDimensions nullBaseDimensions2 = null;
+
+            Assert.False(nullBaseDimensions1 != nullBaseDimensions2);
         }
 
         [Fact]

UnitsNet.Tests/BaseUnitsTests.cs

@@ -0,0 +1,121 @@
+// Copyright (c) 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).
+// https://github.com/angularsen/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 UnitsNet.Units;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class BaseUnitsTests
+    {
+        private static BaseUnits siBaseUnits = new BaseUnits(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second,
+                ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela);
+
+        private static BaseUnits siBaseUnitsCopy = new BaseUnits(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second,
+                ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela);
+
+        private static BaseUnits nonSiBaseUnits = new BaseUnits(LengthUnit.Foot, MassUnit.Pound, DurationUnit.Second,
+            ElectricCurrentUnit.Ampere, TemperatureUnit.DegreeFahrenheit, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela);
+
+        [Fact]
+        public void ConstructorSetsUnitsProperly()
+        {
+            var baseUnits = new BaseUnits(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second,
+                ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela);
+
+            Assert.Equal(LengthUnit.Meter, baseUnits.Length);
+            Assert.Equal(MassUnit.Kilogram, baseUnits.Mass);
+            Assert.Equal(DurationUnit.Second, baseUnits.Time);
+            Assert.Equal(ElectricCurrentUnit.Ampere, baseUnits.Current);
+            Assert.Equal(TemperatureUnit.Kelvin, baseUnits.Temperature);
+            Assert.Equal(AmountOfSubstanceUnit.Mole, baseUnits.Amount);
+            Assert.Equal(LuminousIntensityUnit.Candela, baseUnits.LuminousIntensity);
+        }
+
+        [Fact]
+        public void EqualsObjectIsImplementedCorrectly()
+        {
+            Assert.True(siBaseUnits.Equals((object)siBaseUnitsCopy));
+            Assert.False(siBaseUnits.Equals((object)nonSiBaseUnits));
+
+            Assert.False(siBaseUnits.Equals("Some object."));
+            Assert.False(siBaseUnits.Equals((IFormatProvider)null));
+        }
+
+        [Fact]
+        public void EqualsBaseUnitsIsImplementedCorrectly()
+        {
+            Assert.True(siBaseUnits.Equals(siBaseUnitsCopy));
+            Assert.True(siBaseUnitsCopy.Equals(siBaseUnits));
+
+            Assert.False(siBaseUnits.Equals(nonSiBaseUnits));
+            Assert.False(nonSiBaseUnits.Equals(siBaseUnits));
+
+            Assert.False(siBaseUnits.Equals(null));
+        }
+
+        [Fact]
+        public void EqualityOperatorIsImplementedCorrectly()
+        {
+            Assert.True(siBaseUnits == siBaseUnitsCopy);
+            Assert.True(siBaseUnitsCopy == siBaseUnits);
+
+            Assert.False(siBaseUnits == nonSiBaseUnits);
+            Assert.False(nonSiBaseUnits == siBaseUnits);
+
+            Assert.False(siBaseUnits == null);
+            Assert.False(null == siBaseUnits);
+
+            BaseUnits nullBaseUnits1 = null;
+            BaseUnits nullBaseUnits2 = null;
+
+            Assert.True(nullBaseUnits1 == nullBaseUnits2);
+        }
+
+        [Fact]
+        public void InequalityOperatorIsImplementedCorrectly()
+        {
+            Assert.False(siBaseUnits != siBaseUnitsCopy);
+            Assert.False(siBaseUnitsCopy != siBaseUnits);
+
+            Assert.True(siBaseUnits != nonSiBaseUnits);
+            Assert.True(nonSiBaseUnits != siBaseUnits);
+
+            Assert.True(siBaseUnits != null);
+            Assert.True(null != siBaseUnits);
+
+            BaseUnits nullBaseUnits1 = null;
+            BaseUnits nullBaseUnits2 = null;
+
+            Assert.False(nullBaseUnits1 != nullBaseUnits2);
+        }
+
+        [Fact]
+        public void ToStringGivesExpectedResult()
+        {
+            var siBaseUnits = new BaseUnits(LengthUnit.Meter, MassUnit.Kilogram, DurationUnit.Second,
+                ElectricCurrentUnit.Ampere, TemperatureUnit.Kelvin, AmountOfSubstanceUnit.Mole, LuminousIntensityUnit.Candela);
+
+            Assert.Equal("[Length]: m, [Mass]: kg, [Time]: s, [Current]: A, [Temperature]: K, [Amount]: mol, [LuminousIntensity]: cd", siBaseUnits.ToString());
+        }
+    }
+}

UnitsNet.Tests/GeneratedCode/.gitignore

@@ -0,0 +1,4 @@
+*.g.cs
+!InformationTestsBase.g.cs
+!LengthTestsBase.g.cs
+!LevelTestsBase.g.cs