Add more test coverage (#800)

Author: tmilnthorp

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -339,24 +339,41 @@ public void EqualityOperators()
         }}
 
         [Fact]
-        public void EqualsIsImplemented()
+        public void Equals_SameType_IsImplemented()
         {{
             var a = {_quantity.Name}.From{_baseUnit.PluralName}(1);
             var b = {_quantity.Name}.From{_baseUnit.PluralName}(2);
 
             Assert.True(a.Equals(a));
             Assert.False(a.Equals(b));
-            Assert.False(a.Equals(null));
         }}
 
         [Fact]
-        public void EqualsRelativeToleranceIsImplemented()
+        public void Equals_QuantityAsObject_IsImplemented()
+        {{
+            object a = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            object b = {_quantity.Name}.From{_baseUnit.PluralName}(2);
+
+            Assert.True(a.Equals(a));
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals((object)null));
+        }}
+
+        [Fact]
+        public void Equals_RelativeTolerance_IsImplemented()
         {{
             var v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
             Assert.True(v.Equals({_quantity.Name}.From{_baseUnit.PluralName}(1), {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
             Assert.False(v.Equals({_quantity.Name}.Zero, {_baseUnit.PluralName}Tolerance, ComparisonType.Relative));
         }}
 
+        [Fact]
+        public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
+        {{
+            var v = {_quantity.Name}.From{_baseUnit.PluralName}(1);
+            Assert.Throws<ArgumentOutOfRangeException>(() => v.Equals({_quantity.Name}.From{_baseUnit.PluralName}(1), -1, ComparisonType.Relative));
+        }}
+
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {{
@@ -514,113 +531,137 @@ public void Convert_ToDateTime_ThrowsInvalidCastException()
         public void Convert_ToDecimal_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
+            Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
         }}
 
         [Fact]
         public void Convert_ToDouble_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity));
+            Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity));
         }}
 
         [Fact]
         public void Convert_ToInt16_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity));
+            Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity));
         }}
 
         [Fact]
         public void Convert_ToInt32_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
+            Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
         }}
 
         [Fact]
         public void Convert_ToInt64_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity));
+            Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity));
         }}
 
         [Fact]
         public void Convert_ToSByte_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity));
+            Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity));
         }}
 
         [Fact]
         public void Convert_ToSingle_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
+            Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
         }}
 
         [Fact]
         public void Convert_ToString_EqualsToString()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
+            Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
         }}
 
         [Fact]
         public void Convert_ToUInt16_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity));
+            Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity));
         }}
 
         [Fact]
         public void Convert_ToUInt32_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity));
+            Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity));
         }}
 
         [Fact]
         public void Convert_ToUInt64_EqualsValueAsSameType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
+            Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
         }}
 
         [Fact]
         public void Convert_ChangeType_SelfType_EqualsSelf()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal(quantity, Convert.ChangeType(quantity, typeof({_quantity.Name})));
+            Assert.Equal(quantity, Convert.ChangeType(quantity, typeof({_quantity.Name})));
         }}
 
         [Fact]
         public void Convert_ChangeType_UnitType_EqualsUnit()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof({_unitEnumName})));
+            Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof({_unitEnumName})));
         }}
 
         [Fact]
         public void Convert_ChangeType_QuantityType_EqualsQuantityType()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal(QuantityType.{_quantity.Name}, Convert.ChangeType(quantity, typeof(QuantityType)));
+            Assert.Equal(QuantityType.{_quantity.Name}, Convert.ChangeType(quantity, typeof(QuantityType)));
         }}
 
         [Fact]
         public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Equal({_quantity.Name}.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
+            Assert.Equal({_quantity.Name}.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
         }}
 
         [Fact]
         public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
         {{
             var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
-           Assert.Throws<InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
+            Assert.Throws<InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
         }}
+
+        [Fact]
+        public void GetHashCode_Equals()
+        {{
+            var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(1.0);
+            Assert.Equal(new {{{_quantity.Name}.QuantityType, quantity.Value, quantity.Unit}}.GetHashCode(), quantity.GetHashCode());
+        }}
+");
+
+        if( _quantity.GenerateArithmetic )
+        {
+                Writer.WL( $@"
+        [Theory]
+        [InlineData(1.0)]
+        [InlineData(-1.0)]
+        public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
+        {{
+            var quantity = {_quantity.Name}.From{_baseUnit.PluralName}(value);
+            Assert.Equal({_quantity.Name}.From{_baseUnit.PluralName}(-value), -quantity);
+        }}
+");
+        }
+
+Writer.WL( $@"
     }}
 }}" );
             return Writer.ToString();