Add [Nullable]EnumAssertions to handle enums

Src/FluentAssertions/AssertionExtensions.cs

@@ -130,13 +130,6 @@ public static ExecutionTime ExecutionTime(this Func<Task> action)
             return new ExecutionTime(action);
         }
 
-        /// <summary>
-        /// Returns an <see cref="EnumAssertions"/> object that can be used to assert the
-        /// current <see cref="Enum"/>.
-        /// </summary>
-        public static EnumAssertions Should(this Enum @enum)
-            => new EnumAssertions(@enum);
-
         /// <summary>
         /// Returns an <see cref="ExecutionTimeAssertions"/> object that can be used to assert the
         /// current <see cref="FluentAssertions.Specialized.ExecutionTime"/>.

Src/FluentAssertions/Common/ObjectExtensions.cs

@@ -31,8 +31,8 @@ public static bool IsSameOrEqualTo(this object actual, object expected)
             Type actualType = actual.GetType();
 
             return actualType != expectedType
-                && (actual.IsNumericType() || actualType.IsEnum)
-                && (expected.IsNumericType() || expectedType.IsEnum)
+                && actual.IsNumericType()
+                && expected.IsNumericType()
                 && CanConvert(actual, expected, actualType, expectedType)
                 && CanConvert(expected, actual, expectedType, actualType);
         }
@@ -55,9 +55,7 @@ private static bool CanConvert(object source, object target, Type sourceType, Ty
 
         private static object ConvertTo(this object source, Type targetType)
         {
-            return targetType.IsEnum
-                ? Enum.ToObject(targetType, source)
-                : Convert.ChangeType(source, targetType, CultureInfo.InvariantCulture);
+            return Convert.ChangeType(source, targetType, CultureInfo.InvariantCulture);
         }
 
         private static bool IsNumericType(this object obj)

Src/FluentAssertions/EnumAssertionsExtensions.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Diagnostics;
+using System.Diagnostics.Contracts;
+using FluentAssertions.Primitives;
+
+namespace FluentAssertions
+{
+    /// <summary>
+    /// Contains an extension method for custom assertions in unit tests related to Enum objects.
+    /// </summary>
+    [DebuggerNonUserCode]
+    public static class EnumAssertionsExtensions
+    {
+        /// <summary>
+        /// Returns an <see cref="EnumAssertions{TEnum, TAssertions}"/> object that can be used to assert the
+        /// current <typeparamref name="TEnum"/>.
+        /// </summary>
+        [Pure]
+        public static EnumAssertions<TEnum> Should<TEnum>(this TEnum @enum)
+            where TEnum : struct, Enum
+        {
+            return new EnumAssertions<TEnum>(@enum);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="EnumAssertions{TEnum, TAssertions}"/> object that can be used to assert the
+        /// current <typeparamref name="TEnum"/>.
+        /// </summary>
+        [Pure]
+        public static NullableEnumAssertions<TEnum> Should<TEnum>(this TEnum? @enum)
+            where TEnum : struct, Enum
+        {
+            return new NullableEnumAssertions<TEnum>(@enum);
+        }
+    }
+}

Src/FluentAssertions/Equivalency/EnumEqualityStep.cs

@@ -15,10 +15,9 @@ public class EnumEqualityStep : IEquivalencyStep
         /// </summary>
         public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
         {
-            Type subjectType = config.GetExpectationType(context.RuntimeType, context.CompileTimeType);
+            Type expectationType = config.GetExpectationType(context.RuntimeType, context.CompileTimeType);
 
-            return (subjectType?.IsEnum == true) ||
-                   (context.Expectation?.GetType().IsEnum == true);
+            return expectationType.IsEnum;
         }
 
         /// <summary>

Src/FluentAssertions/Equivalency/EnumerableEquivalencyStep.cs

@@ -13,9 +13,9 @@ public class EnumerableEquivalencyStep : IEquivalencyStep
         /// </summary>
         public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
         {
-            Type subjectType = config.GetExpectationType(context.RuntimeType, context.CompileTimeType);
+            Type expectationType = config.GetExpectationType(context.RuntimeType, context.CompileTimeType);
 
-            return IsCollection(subjectType);
+            return IsCollection(expectationType);
         }
 
         /// <summary>

Src/FluentAssertions/Formatting/EnumValueFormatter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Globalization;
+
+namespace FluentAssertions.Formatting
+{
+    public class EnumValueFormatter : IValueFormatter
+    {
+        /// <summary>
+        /// Indicates whether the current <see cref="IValueFormatter"/> can handle the specified <paramref name="value"/>.
+        /// </summary>
+        /// <param name="value">The value for which to create a <see cref="string"/>.</param>
+        /// <returns>
+        /// <c>true</c> if the current <see cref="IValueFormatter"/> can handle the specified value; otherwise, <c>false</c>.
+        /// </returns>
+        public virtual bool CanHandle(object value)
+        {
+            return value is Enum;
+        }
+
+        /// <inheritdoc />
+        public string Format(object value, FormattingContext context, FormatChild formatChild)
+        {
+            Type type = value.GetType();
+            string typePart = type.Name;
+            string namePart = Enum.GetName(type, value);
+            string valuePart = Convert.ToDecimal(value, CultureInfo.InvariantCulture)
+                .ToString(CultureInfo.InvariantCulture);
+
+            return $"{typePart}.{namePart}({valuePart})";
+        }
+    }
+}

Src/FluentAssertions/Formatting/Formatter.cs

@@ -46,6 +46,7 @@ public static class Formatter
             new ExceptionValueFormatter(),
             new MultidimensionalArrayFormatter(),
             new EnumerableValueFormatter(),
+            new EnumValueFormatter(),
             new DefaultValueFormatter()
         };