add tests

Author: angularsen

CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs

@@ -75,7 +75,7 @@ namespace UnitsNet
         IComparable<{_quantity.Name}>,
         IConvertible,
         IEquatable<{_quantity.Name}>,
-        IEquatableQuantity<{_quantity.Name}>,
+        IEquatableQuantity<{_quantity.Name}, {_quantity.ValueType}>,
         IFormattable");
 
             Writer.WL($@"
@@ -824,46 +824,13 @@ public int CompareTo({_quantity.Name} other)
             return _value.CompareTo(other.ToUnit(this.Unit).Value);
         }}
 
-        /// <summary>
-        ///     <para>
-        ///     Compare equality to another {_quantity.Name} within the given absolute or relative tolerance.
-        ///     </para>
-        ///     <para>
-        ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
-        ///     <paramref name=""other""/> as a percentage of this quantity's value. <paramref name=""other""/> will be converted into
-        ///     this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of
-        ///     this quantity's value to be considered equal.
-        ///     <example>
-        ///     In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm).
-        ///     <code>
-        ///     var a = Length.FromMeters(2.0);
-        ///     var b = Length.FromInches(50.0);
-        ///     a.Equals(b, 0.01, ComparisonType.Relative);
-        ///     </code>
-        ///     </example>
-        ///     </para>
-        ///     <para>
-        ///     Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and
-        ///     <paramref name=""other""/> as a fixed number in this quantity's unit. <paramref name=""other""/> will be converted into
-        ///     this quantity's unit for comparison.
-        ///     <example>
-        ///     In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm).
-        ///     <code>
-        ///     var a = Length.FromMeters(2.0);
-        ///     var b = Length.FromInches(50.0);
-        ///     a.Equals(b, 0.01, ComparisonType.Absolute);
-        ///     </code>
-        ///     </example>
-        ///     </para>
-        ///     <para>
-        ///     Note that it is advised against specifying zero difference, due to the nature
-        ///     of floating-point operations and using {_valueType} internally.
-        ///     </para>
-        /// </summary>
-        /// <param name=""other"">The other quantity to compare to.</param>
-        /// <param name=""tolerance"">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
-        /// <param name=""comparisonType"">The comparison type: either relative or absolute.</param>
-        /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
+        /// <inheritdoc />
+        public bool Equals(IQuantity? other, double tolerance, ComparisonType comparisonType)
+        {{
+            return other is {_quantity.Name} otherTyped && Equals(otherTyped, tolerance, comparisonType);
+        }}
+
+        /// <inheritdoc />
         public bool Equals({_quantity.Name} other, {_quantity.ValueType} tolerance, ComparisonType comparisonType)
         {{
             if (tolerance < 0)

UnitsNet.Tests/CustomQuantities/HowMuch.cs

@@ -42,6 +42,11 @@ public HowMuch(double value, HowMuchUnit unit)
 
         public double As(UnitSystem unitSystem) => throw new NotImplementedException();
 
+        public bool Equals(IQuantity? other, double tolerance, ComparisonType comparisonType)
+        {
+            return other is HowMuch otherTyped && otherTyped.Unit == Unit && otherTyped.Value.Equals(Value);
+        }
+
         public IQuantity ToUnit(Enum unit)
         {
             if (unit is HowMuchUnit howMuchUnit) return new HowMuch(As(unit), howMuchUnit);

UnitsNet.Tests/DummyIQuantity.cs

@@ -17,6 +17,8 @@ internal class DummyIQuantity : IQuantity
 
         public double As(UnitSystem unitSystem ) => throw new NotImplementedException();
 
+        public bool Equals(IQuantity? other, double tolerance, ComparisonType comparisonType) => throw new NotImplementedException();
+
         public string ToString(IFormatProvider? provider) => throw new NotImplementedException();
 
         public string ToString(string? format, IFormatProvider? formatProvider) => throw new NotImplementedException();

UnitsNet.Tests/QuantityTests.cs

@@ -1,6 +1,7 @@
 // Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System.Globalization;
 using UnitsNet.Units;
 using Xunit;
 
@@ -16,5 +17,41 @@ public void GetHashCodeForDifferentQuantitiesWithSameValuesAreNotEqual()
 
             Assert.NotEqual(length.GetHashCode(), area.GetHashCode());
         }
+
+        [Theory]
+        [InlineData("10 m", "9.89 m" , ComparisonType.Absolute, 0.1, false)] // +/- 0.1m absolute tolerance and some additional margin tolerate rounding errors in test case.
+        [InlineData("10 m", "9.91 m" , ComparisonType.Absolute, 0.1, true)]
+        [InlineData("10 m", "10.09 m", ComparisonType.Absolute, 0.1, true)]
+        [InlineData("10 m", "10.11 m", ComparisonType.Absolute, 0.1, false)]
+        [InlineData("10 m", "8.9 m"  , ComparisonType.Absolute, 0.1, false)] // +/- 1m relative tolerance (10%) and some additional margin tolerate rounding errors in test case.
+        [InlineData("10 m", "9.1 m"  , ComparisonType.Relative, 0.1, true)]
+        [InlineData("10 m", "10.9 m" , ComparisonType.Relative, 0.1, true)]
+        [InlineData("10 m", "11.1 m" , ComparisonType.Relative, 0.1, false)]
+        public void Equals_IEquatableQuantity(string q1String, string q2String, ComparisonType comparisonType, double tolerance, bool expectedEqual)
+        {
+            IEquatableQuantity<Length, double> q1 = Length.Parse(q1String, CultureInfo.InvariantCulture);
+            var q2 = Length.Parse(q2String, CultureInfo.InvariantCulture);
+
+            Assert.NotStrictEqual(q1, q2); // Strict equality should not be equal.
+            Assert.Equal(expectedEqual, q1.Equals(q2, tolerance, comparisonType));
+        }
+
+        [Theory]
+        [InlineData("10 m", "9.89 m" , ComparisonType.Absolute, 0.1, false)] // +/- 0.1m absolute tolerance and some additional margin tolerate rounding errors in test case.
+        [InlineData("10 m", "9.91 m" , ComparisonType.Absolute, 0.1, true)]
+        [InlineData("10 m", "10.09 m", ComparisonType.Absolute, 0.1, true)]
+        [InlineData("10 m", "10.11 m", ComparisonType.Absolute, 0.1, false)]
+        [InlineData("10 m", "8.9 m"  , ComparisonType.Absolute, 0.1, false)] // +/- 1m relative tolerance (10%) and some additional margin tolerate rounding errors in test case.
+        [InlineData("10 m", "9.1 m"  , ComparisonType.Relative, 0.1, true)]
+        [InlineData("10 m", "10.9 m" , ComparisonType.Relative, 0.1, true)]
+        [InlineData("10 m", "11.1 m" , ComparisonType.Relative, 0.1, false)]
+        public void Equals_IQuantity(string q1String, string q2String, ComparisonType comparisonType, double tolerance, bool expectedEqual)
+        {
+            IQuantity q1 = Quantity.Parse(CultureInfo.InvariantCulture, typeof(Length), q1String);
+            IQuantity q2 = Quantity.Parse(CultureInfo.InvariantCulture, typeof(Length), q2String);
+
+            Assert.NotEqual(q1, q2); // Strict equality should not be equal.
+            Assert.Equal(expectedEqual, q1.Equals(q2, tolerance, comparisonType));
+        }
     }
 }