bugfix/empty-structs (#59)

Fixed equality bug due to null reference exceptions in empty/default structs.

Author: MrMatthewLayton

OnixLabs.Core.UnitTests/Text/Base16Tests.cs

@@ -52,6 +52,21 @@ public void Base16ShouldNotChangeWhenModifyingObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Base16 default values should be identical")]
+    public void Base16DefaultValuesShouldBeIdentical()
+    {
+        // Given
+        Base16 a = new();
+        Base16 b = default;
+
+        // Then
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        Assert.True(a.Equals(b));
+        Assert.True(a == b);
+        Assert.False(a != b);
+    }
+
     [Fact(DisplayName = "Base16 values should be identical")]
     public void Base16ValuesShouldBeIdentical()
     {

OnixLabs.Core.UnitTests/Text/Base32Tests.cs

@@ -52,6 +52,21 @@ public void Base32ShouldNotChangeWhenModifyingObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Base32 default values should be identical")]
+    public void Base32DefaultValuesShouldBeIdentical()
+    {
+        // Given
+        Base32 a = new();
+        Base32 b = default;
+
+        // Then
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        Assert.True(a.Equals(b));
+        Assert.True(a == b);
+        Assert.False(a != b);
+    }
+
     [Fact(DisplayName = "Base32 values should be identical")]
     public void Base32ValuesShouldBeIdentical()
     {

OnixLabs.Core.UnitTests/Text/Base58Tests.cs

@@ -52,6 +52,21 @@ public void Base58ShouldNotChangeWhenModifyingObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Base58 default values should be identical")]
+    public void Base58DefaultValuesShouldBeIdentical()
+    {
+        // Given
+        Base58 a = new();
+        Base58 b = default;
+
+        // Then
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        Assert.True(a.Equals(b));
+        Assert.True(a == b);
+        Assert.False(a != b);
+    }
+
     [Fact(DisplayName = "Base58 values should be identical")]
     public void Base58ValuesShouldBeIdentical()
     {

OnixLabs.Core.UnitTests/Text/Base64Tests.cs

@@ -52,6 +52,21 @@ public void Base64ShouldNotChangeWhenModifyingObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Base64 default values should be identical")]
+    public void Base64DefaultValuesShouldBeIdentical()
+    {
+        // Given
+        Base64 a = new();
+        Base64 b = default;
+
+        // Then
+        Assert.Equal(a, b);
+        Assert.Equal(a.GetHashCode(), b.GetHashCode());
+        Assert.True(a.Equals(b));
+        Assert.True(a == b);
+        Assert.False(a != b);
+    }
+
     [Fact(DisplayName = "Base64 values should be identical")]
     public void Base64ValuesShouldBeIdentical()
     {

OnixLabs.Core/Linq/Extensions.IEnumerable.cs

@@ -90,8 +90,10 @@ public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
     /// <param name="enumerable">The current <see cref="IEnumerable{T}"/> from which to compute a content hash code.</param>
     /// <typeparam name="T">The underlying type of the <see cref="IEnumerable{T}"/>.</typeparam>
     /// <returns>Returns the computed content hash code of the current <see cref="IEnumerable{T}"/>.</returns>
-    public static int GetContentHashCode<T>(this IEnumerable<T> enumerable)
+    public static int GetContentHashCode<T>(this IEnumerable<T>? enumerable)
     {
+        if (enumerable is null) return default;
+
         HashCode result = new();
         enumerable.ForEach(element => result.Add(element));
         return result.ToHashCode();
@@ -173,6 +175,19 @@ public static Optional<T> LastOrNone<T>(this IEnumerable<T> enumerable, Func<T,
     /// <returns>Returns <see langword="true"/> if none of the elements of the current <see cref="IEnumerable{T}"/> satisfy the specified predicate condition; otherwise, <see langword="false"/>.</returns>
     public static bool None<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate) => !enumerable.Any(predicate);
 
+    /// <summary>Determines whether two sequences are <see langword="null"/>, or equal by comparing their elements by using a specified <see cref="T:IEqualityComparer{T}" />.</summary>
+    /// <param name="first">An <see cref="T:IEnumerable{T}" /> to compare to <paramref name="second" />.</param>
+    /// <param name="second">An <see cref="T:IEnumerable{T}" /> to compare to the first sequence.</param>
+    /// <param name="comparer">An <see cref="T:IEqualityComparer{T}" /> to use to compare elements.</param>
+    /// <typeparam name="T">The underlying type of the <see cref="IEnumerable{T}"/>.</typeparam>
+    /// <returns> Returns <see langword="true" /> if the two source sequences are <see langword="null"/>, or of equal length and their corresponding elements compare equal according to <paramref name="comparer" />; otherwise, <see langword="false" />.</returns>
+    public static bool SequenceEqualOrNull<T>(this IEnumerable<T>? first, IEnumerable<T>? second, EqualityComparer<T>? comparer = null)
+    {
+        if (first is null && second is null) return true;
+        if (first is null || second is null) return false;
+        return first.SequenceEqual(second, comparer ?? EqualityComparer<T>.Default);
+    }
+
     /// <summary>
     /// Obtains a single element of the current <see cref="IEnumerable{T}"/> that satisfies the specified predicate;
     /// otherwise <see cref="Optional{T}.None"/> if no such element is found,

OnixLabs.Core/OnixLabs.Core.csproj

@@ -11,7 +11,7 @@
         <NeutralLanguage>en</NeutralLanguage>
         <Copyright>Copyright © ONIXLabs 2020</Copyright>
         <RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
-        <PackageVersion>8.4.0</PackageVersion>
+        <PackageVersion>8.5.0</PackageVersion>
         <PackageLicenseUrl></PackageLicenseUrl>
     </PropertyGroup>
     <PropertyGroup>

OnixLabs.Core/Text/Base16.Equatable.cs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System.Linq;
 using OnixLabs.Core.Linq;
 
 namespace OnixLabs.Core.Text;
@@ -24,7 +23,7 @@ public readonly partial struct Base16
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Base16 other) => other.value.SequenceEqual(value);
+    public bool Equals(Base16 other) => other.value.SequenceEqualOrNull(value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Core/Text/Base32.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct Base32
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Base32 other) => other.value.SequenceEqual(value);
+    public bool Equals(Base32 other) => other.value.SequenceEqualOrNull(value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Core/Text/Base58.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct Base58
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Base58 other) => other.value.SequenceEqual(value);
+    public bool Equals(Base58 other) => other.value.SequenceEqualOrNull(value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Core/Text/Base64.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct Base64
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Base64 other) => other.value.SequenceEqual(value);
+    public bool Equals(Base64 other) => other.value.SequenceEqualOrNull(value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Numerics/OnixLabs.Numerics.csproj

@@ -10,7 +10,7 @@
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <Copyright>Copyright © ONIXLabs 2020</Copyright>
         <RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
-        <PackageVersion>8.4.0</PackageVersion>
+        <PackageVersion>8.5.0</PackageVersion>
         <LangVersion>12</LangVersion>
         <PackageLicenseUrl></PackageLicenseUrl>
     </PropertyGroup>

OnixLabs.Security.Cryptography.UnitTests/DigitalSignatureTests.cs

@@ -65,6 +65,21 @@ public void DigitalSignatureValueShouldNotBeModifiedWhenAlteringTheObtainedByteA
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Identical default signature values should be considered equal")]
+    public void IdenticalDefaultDigitalSignatureValuesShouldBeConsideredEqual()
+    {
+        // Given
+        DigitalSignature left = new();
+        DigitalSignature right = default;
+
+        // Then
+        Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
+        Assert.True(left.Equals(right));
+        Assert.True(left == right);
+        Assert.False(left != right);
+    }
+
     [Fact(DisplayName = "Identical signature values should be considered equal")]
     public void IdenticalDigitalSignatureValuesShouldBeConsideredEqual()
     {
@@ -74,8 +89,10 @@ public void IdenticalDigitalSignatureValuesShouldBeConsideredEqual()
 
         // Then
         Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
         Assert.True(left.Equals(right));
         Assert.True(left == right);
+        Assert.False(left != right);
     }
 
     [Fact(DisplayName = "Different signature values should not be considered equal")]
@@ -87,7 +104,9 @@ public void DifferentDigitalSignatureValuesShouldNotBeConsideredEqual()
 
         // Then
         Assert.NotEqual(left, right);
+        Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
         Assert.False(left.Equals(right));
+        Assert.False(left == right);
         Assert.True(left != right);
     }
 

OnixLabs.Security.Cryptography.UnitTests/HashTests.cs

@@ -85,6 +85,21 @@ public void HashValueShouldNotBeModifiedWhenAlteringTheObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Identical default hash values should be considered equal")]
+    public void IdenticalDefaultHashValuesShouldBeConsideredEqual()
+    {
+        // Given
+        Hash left = new();
+        Hash right = default;
+
+        // Then
+        Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
+        Assert.True(left.Equals(right));
+        Assert.True(left == right);
+        Assert.False(left != right);
+    }
+
     [Fact(DisplayName = "Identical hash values should be considered equal")]
     public void IdenticalHashValuesShouldBeConsideredEqual()
     {
@@ -94,8 +109,10 @@ public void IdenticalHashValuesShouldBeConsideredEqual()
 
         // Then
         Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
         Assert.True(left.Equals(right));
         Assert.True(left == right);
+        Assert.False(left != right);
     }
 
     [Fact(DisplayName = "Different hash values should not be considered equal")]
@@ -107,7 +124,9 @@ public void DifferentHashValuesShouldNotBeConsideredEqual()
 
         // Then
         Assert.NotEqual(left, right);
+        Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
         Assert.False(left.Equals(right));
+        Assert.False(left == right);
         Assert.True(left != right);
     }
 

OnixLabs.Security.Cryptography.UnitTests/SaltTests.cs

@@ -66,6 +66,21 @@ public void SaltValueShouldNotBeModifiedWhenAlteringTheObtainedByteArray()
         Assert.Equal(expected, actual);
     }
 
+    [Fact(DisplayName = "Identical default salt values should be considered equal")]
+    public void IdenticalDefaultSaltValuesShouldBeConsideredEqual()
+    {
+        // Given
+        Salt left = new();
+        Salt right = default;
+
+        // Then
+        Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
+        Assert.True(left.Equals(right));
+        Assert.True(left == right);
+        Assert.False(left != right);
+    }
+
     [Fact(DisplayName = "Identical salt values should be considered equal")]
     public void IdenticalSaltValuesShouldBeConsideredEqual()
     {
@@ -75,8 +90,10 @@ public void IdenticalSaltValuesShouldBeConsideredEqual()
 
         // Then
         Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
         Assert.True(left.Equals(right));
         Assert.True(left == right);
+        Assert.False(left != right);
     }
 
     [Fact(DisplayName = "Different salt values should not be considered equal")]
@@ -88,7 +105,9 @@ public void DifferentSaltValuesShouldNotBeConsideredEqual()
 
         // Then
         Assert.NotEqual(left, right);
+        Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
         Assert.False(left.Equals(right));
+        Assert.False(left == right);
         Assert.True(left != right);
     }
 

OnixLabs.Security.Cryptography/DigitalSignature.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct DigitalSignature
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(DigitalSignature other) => value.SequenceEqual(other.value);
+    public bool Equals(DigitalSignature other) => value.SequenceEqualOrNull(other.value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Security.Cryptography/Hash.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct Hash
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Hash other) => value.SequenceEqual(other.value);
+    public bool Equals(Hash other) => value.SequenceEqualOrNull(other.value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.

OnixLabs.Security.Cryptography/OnixLabs.Security.Cryptography.csproj

@@ -10,7 +10,7 @@
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <Copyright>Copyright © ONIXLabs 2020</Copyright>
         <RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
-        <PackageVersion>8.4.0</PackageVersion>
+        <PackageVersion>8.5.0</PackageVersion>
         <LangVersion>12</LangVersion>
         <PackageLicenseUrl></PackageLicenseUrl>
     </PropertyGroup>

OnixLabs.Security.Cryptography/Salt.Equatable.cs

@@ -24,7 +24,7 @@ public readonly partial struct Salt
     /// </summary>
     /// <param name="other">An object to compare with the current object.</param>
     /// <returns>Returns <see langword="true"/> if the current object is equal to the other parameter; otherwise, <see langword="false"/>.</returns>
-    public bool Equals(Salt other) => value.SequenceEqual(other.value);
+    public bool Equals(Salt other) => value.SequenceEqualOrNull(other.value);
 
     /// <summary>
     /// Checks for equality between the current instance and another object.