Adding back ShouldBe expecting a nullable struct to be a non-nullable…

… struct

EasyAssertions/Assertions/ObjectAssertions.cs

@@ -25,6 +25,24 @@ public static Actual<TActual> ShouldBe<TActual, TExpected>(this TActual actual,
                 }
             });
     }
+
+    /// <summary>
+    /// Asserts that a nullable value is equal to another value, using the default equality comparer.
+    /// </summary>
+    public static Actual<TActual> ShouldBe<TActual>(this TActual? actual, TActual expected, string? message = null) 
+        where TActual : struct
+    {
+        actual.RegisterAssertion(c =>
+            {
+                if (!actual.HasValue)
+                    throw c.StandardError.NotEqual(expected, actual, message);
+
+                if (!c.Test.ObjectsAreEqual(actual.Value, expected))
+                    throw c.StandardError.NotEqual(expected, actual, message);
+            });
+
+        return new Actual<TActual>(actual!.Value);
+    }
 
     /// <summary>
     /// Asserts that two values are equal, using the default equality comparer.

EasyAssertions/EasyAssertions.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
-    <Version>3.0.2</Version>
+    <Version>3.0.3</Version>
     <Authors>Simon Oxtoby</Authors>
     <Company />
     <Product />

ReleaseNotes.md

@@ -1,3 +1,7 @@
+# v3.0.3
+## Bug Fixes
+ - Adding back `ShouldBe` expecting a nullable struct to be a non-nullable struct.
+
 # v3.0.2
 ## Bug Fixes
  - Removed the `ShouldBe` on nullable structs that was marked as `Obsolete` to push people to `ShouldBeValue` - the small improvement in intellisense isn't worth breaking existing code.    
@@ -14,7 +18,7 @@
  - Moved `ShouldBeValue` from `EnumAssertions` to `ObjectAssertions`.
 
 # v3.0.0
-**NOTE:** This release caused too many problems with the `class` constraint on `ShouldBe` - use v3.0.2 instead.
+**NOTE:** This release caused too many problems with the `class` constraint on `ShouldBe` - use v3.0.3 instead.
 
 ## New Features
  - Added nullable annotations everywhere.

UnitTests/Assertions/ObjectAssertionTests.cs

@@ -53,6 +53,49 @@ public void ShouldBe_CorrectlyRegistersAssertion()
         Assert.AreEqual(nameof(actualExpression), TestExpression.GetActual());
         Assert.AreEqual(nameof(expectedExpression), TestExpression.GetExpected());
     }
+
+    [Test]
+    public void ShouldBe_NullableStruct_ValueEqualsExpected_ReturnsActualValue()
+    {
+        int? actual = 1;
+
+        Actual<int> result = actual.ShouldBe(1);
+
+        Assert.AreEqual(1, result.And);
+    }
+
+    [Test]
+    public void ShouldBe_NullableStruct_NoValue_FailsWithObjectsNotEqualMessage()
+    {
+        int? actual = null;
+        const int expected = 1;
+        Error.NotEqual(expected, actual, "foo").Returns(ExpectedException);
+
+        AssertThrowsExpectedError(() => actual.ShouldBe(expected, "foo"));
+    }
+
+    [Test]
+    public void ShouldBe_NullableStruct_ValueIsDifferent_FailsWithObjectsNotEqualMessage()
+    {
+        int? actual = 1;
+        const int expected = 2;
+        Error.NotEqual(expected, actual, "foo").Returns(ExpectedException);
+
+        AssertThrowsExpectedError(() => actual.ShouldBe(expected, "foo"));
+    }
+
+    [Test]
+    public void ShouldBe_NullableStruct_CorrectlyRegistersAssertion()
+    {
+        int? actualExpression = 1;
+        const int expectedExpression = 2;
+        Error.NotEqual(Arg.Any<object>(), Arg.Any<object>()).Returns(ExpectedException);
+
+        Assert.Throws<Exception>(() => actualExpression.ShouldBe(expectedExpression));
+
+        Assert.AreEqual(nameof(actualExpression), TestExpression.GetActual());
+        Assert.AreEqual(nameof(expectedExpression), TestExpression.GetExpected());
+    }
 
     [Test]
     public void ShouldBeValue_SameValueReturnsActualValue()