Merge branch 'refs/heads/main' into release

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.