diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 7d4e175544..890a5ff95e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -2,10 +2,10 @@ name: build
 
 on:
   pull_request:
-    paths-ignore: 
+    paths-ignore:
       - docs/**
   push:
-    paths-ignore: 
+    paths-ignore:
       - docs/**
 
 jobs:
@@ -17,37 +17,32 @@ jobs:
     - uses: actions/checkout@v2
       with:
         fetch-depth: 0
-    
+
     - name: Setup .NET 5
       uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 5.0.x
-    
+
     - name: Setup .NET 3.1
       uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 3.1.x
-        
+
     - name: Setup .NET 2.1
       uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 2.1.x
-    
-    - name: Install NUKE
-      run: |
-        dotnet tool install --global Nuke.GlobalTool
-        
+
     - name: Run NUKE
-      run: nuke
+      run: ./build.ps1
+      env:
+        BranchSpec: ${{ github.ref }}
+        BuildNumber: ${{ github.run_number}}
+        ApiKey: ${{ secrets.NUGETAPIKEY }}
 
     - name: Upload artifacts
       uses: actions/upload-artifact@v2
       with:
         path: ./Artifacts/*
-        
-    - name: Push to Nuget
-      run: dotnet nuget push .\artifacts\*.nupkg --api-key "$env:ApiKey" --skip-duplicate --no-symbols true --source https://api.nuget.org/v3/index.json
-      if: contains(github.ref, 'refs/tags/')
-      env:
-        ApiKey: ${{ secrets.NUGETAPIKEY }}
-      
+
+
diff --git a/.nuke/build.schema.json b/.nuke/build.schema.json
index a2c28c228d..e85daa3006 100644
--- a/.nuke/build.schema.json
+++ b/.nuke/build.schema.json
@@ -6,6 +6,18 @@
     "build": {
       "type": "object",
       "properties": {
+        "ApiKey": {
+          "type": "string",
+          "description": "The key to push to Nuget"
+        },
+        "BranchSpec": {
+          "type": "string",
+          "description": "A branch specification such as develop or refs/pull/1775/merge"
+        },
+        "BuildNumber": {
+          "type": "string",
+          "description": "An incrementing build number as provided by the build engine"
+        },
         "Continue": {
           "type": "boolean",
           "description": "Indicates to continue a previously failed build attempt"
@@ -64,9 +76,11 @@
             "type": "string",
             "enum": [
               "ApiChecks",
+              "CalculateNugetVersion",
               "Clean",
               "Compile",
               "Pack",
+              "Push",
               "Restore",
               "TestFrameworks",
               "UnitTests"
@@ -84,9 +98,11 @@
             "type": "string",
             "enum": [
               "ApiChecks",
+              "CalculateNugetVersion",
               "Clean",
               "Compile",
               "Pack",
+              "Push",
               "Restore",
               "TestFrameworks",
               "UnitTests"
diff --git a/AcceptApiChanges.sh b/AcceptApiChanges.sh
old mode 100644
new mode 100755
diff --git a/Build/.editorconfig b/Build/.editorconfig
index 21da7492e9..5641e0f6df 100644
--- a/Build/.editorconfig
+++ b/Build/.editorconfig
@@ -9,5 +9,8 @@ csharp_style_expression_bodied_properties = true:warning
 csharp_style_expression_bodied_indexers = true:warning
 csharp_style_expression_bodied_accessors = true:warning
 
-dotnet_diagnostic.IDE0044.severity = none
-dotnet_diagnostic.IDE0051.severity = none
+dotnet_diagnostic.ide0044.severity = none
+dotnet_diagnostic.ide0051.severity = none
+
+# ReSharper properties
+resharper_place_field_attribute_on_same_line = false
diff --git a/Build/Build.cs b/Build/Build.cs
index 29b8e4ee15..a09090bf5a 100644
--- a/Build/Build.cs
+++ b/Build/Build.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using Nuke.Common;
 using Nuke.Common.Execution;
@@ -24,20 +26,54 @@ class Build : NukeBuild
        - Microsoft VSCode           https://nuke.build/vscode
     */
 
-    public static int Main() => Execute<Build>(x => x.Pack);
+    public static int Main() => Execute<Build>(x => x.Push);
 
-    [Solution(GenerateProjects = true)] readonly Solution Solution;
-    [GitVersion(Framework = "net5.0")] readonly GitVersion GitVersion;
-    [PackageExecutable("nspec", "NSpecRunner.exe", Version = "3.1.0")] Tool NSpec3;
+    [Parameter("A branch specification such as develop or refs/pull/1775/merge")]
+    readonly string BranchSpec;
+
+    [Parameter("An incrementing build number as provided by the build engine")]
+    readonly string BuildNumber;
+
+    [Parameter("The key to push to Nuget")]
+    readonly string ApiKey;
+
+    [Solution(GenerateProjects = true)]
+    readonly Solution Solution;
+
+    [GitVersion(Framework = "net5.0")]
+    readonly GitVersion GitVersion;
+
+    [PackageExecutable("nspec", "NSpecRunner.exe", Version = "3.1.0")]
+    Tool NSpec3;
 
     AbsolutePath ArtifactsDirectory => RootDirectory / "Artifacts";
 
+    string SemVer;
+
     Target Clean => _ => _
         .Executes(() =>
         {
             EnsureCleanDirectory(ArtifactsDirectory);
         });
 
+    Target CalculateNugetVersion => _ => _
+        .Executes(() =>
+        {
+            SemVer = GitVersion.SemVer;
+            if (IsPullRequest)
+            {
+                Serilog.Log.Information(
+                    "Branch spec {branchspec} is a pull request. Adding build number {buildnumber}",
+                    BranchSpec, BuildNumber);
+
+                SemVer = string.Join('.', GitVersion.SemVer.Split('.').Take(3).Union(new [] { BuildNumber }));
+            }
+
+            Serilog.Log.Information("SemVer = {semver}", SemVer);
+        });
+
+    bool IsPullRequest => BranchSpec != null && BranchSpec.Contains("pull", StringComparison.InvariantCultureIgnoreCase);
+
     Target Restore => _ => _
         .DependsOn(Clean)
         .Executes(() =>
@@ -78,11 +114,18 @@ class Build : NukeBuild
         {
             if (EnvironmentInfo.IsWin)
             {
-                Xunit2(s => s
-                    .SetFramework("net47")
-                    .AddTargetAssemblies(GlobFiles(
+                Xunit2(s =>
+                {
+                    IReadOnlyCollection<string> testAssemblies = GlobFiles(
                         Solution.Specs.FluentAssertions_Specs.Directory,
-                        "bin/Debug/net47/*.Specs.dll").NotEmpty()));
+                        "bin/Debug/net47/*.Specs.dll");
+
+                    Assert.NotEmpty(testAssemblies.ToList());
+
+                    return s
+                        .SetFramework("net47")
+                        .AddTargetAssemblies(testAssemblies);
+                });
             }
 
             DotNetTest(s => s
@@ -128,6 +171,7 @@ from framework in supportedFrameworks
         .DependsOn(ApiChecks)
         .DependsOn(TestFrameworks)
         .DependsOn(UnitTests)
+        .DependsOn(CalculateNugetVersion)
         .Executes(() =>
         {
             DotNetPack(s => s
@@ -135,6 +179,27 @@ from framework in supportedFrameworks
                 .SetOutputDirectory(ArtifactsDirectory)
                 .SetConfiguration("Release")
                 .EnableContinuousIntegrationBuild() // Necessary for deterministic builds
-                .SetVersion(GitVersion.NuGetVersionV2));
+                .SetVersion(SemVer));
         });
+
+    Target Push => _ => _
+        .DependsOn(Pack)
+        .OnlyWhenDynamic(() => IsTag)
+        .Executes(() =>
+        {
+            var packages = GlobFiles(ArtifactsDirectory, "*.nupkg");
+
+            Assert.NotEmpty(packages.ToList());
+
+            DotNetNuGetPush(s => s
+                .SetApiKey(ApiKey)
+                .EnableSkipDuplicate()
+                .SetSource("https://api.nuget.org/v3/index.json")
+                .EnableNoSymbols()
+                .CombineWith(packages,
+                    (v, path) => v.SetTargetPath(path)));
+        });
+
+    bool IsTag => BranchSpec != null && BranchSpec.Contains("refs/tags", StringComparison.InvariantCultureIgnoreCase);
+
 }
diff --git a/Build/_build.csproj b/Build/_build.csproj
index b2677c5693..7ad25ada24 100644
--- a/Build/_build.csproj
+++ b/Build/_build.csproj
@@ -8,9 +8,9 @@
     <NukeScriptDirectory>..\</NukeScriptDirectory>
   </PropertyGroup>
   <ItemGroup>
-    <PackageDownload Include="GitVersion.Tool" Version="[5.7.0]" />
+    <PackageDownload Include="GitVersion.Tool" Version="[5.8.1]" />
     <PackageDownload Include="NSpec" Version="[3.1.0]" />
     <PackageDownload Include="xunit.runner.console" Version="[2.4.1]" />
-    <PackageReference Include="Nuke.Common" Version="5.3.0" />
+    <PackageReference Include="Nuke.Common" Version="6.0.1" />
   </ItemGroup>
 </Project>
diff --git a/FluentAssertions.sln b/FluentAssertions.sln
index 3973759a76..c69957349c 100644
--- a/FluentAssertions.sln
+++ b/FluentAssertions.sln
@@ -42,6 +42,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Approval.Tests", "Tests\App
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FluentAssertions.Specs", "Tests\FluentAssertions.Specs\FluentAssertions.Specs.csproj", "{6D31FFF8-E7FD-41D2-996C-CA8DDFDAE4FD}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UWP.Specs", "Tests\UWP.Specs\UWP.Specs.csproj", "{08087654-2C32-4818-95E4-45362373441D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		CI|Any CPU = CI|Any CPU
@@ -117,6 +119,9 @@ Global
 		{6D31FFF8-E7FD-41D2-996C-CA8DDFDAE4FD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6D31FFF8-E7FD-41D2-996C-CA8DDFDAE4FD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6D31FFF8-E7FD-41D2-996C-CA8DDFDAE4FD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{08087654-2C32-4818-95E4-45362373441D}.CI|Any CPU.ActiveCfg = Debug|x64
+		{08087654-2C32-4818-95E4-45362373441D}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{08087654-2C32-4818-95E4-45362373441D}.Release|Any CPU.ActiveCfg = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -133,6 +138,7 @@ Global
 		{FCAFB0F1-79EA-4D49-813B-188D4BC4BE71} = {963262D0-9FD5-4741-8C0E-E2F34F110EF3}
 		{F5115158-A038-4D14-A04E-46E7863E40B9} = {963262D0-9FD5-4741-8C0E-E2F34F110EF3}
 		{6D31FFF8-E7FD-41D2-996C-CA8DDFDAE4FD} = {963262D0-9FD5-4741-8C0E-E2F34F110EF3}
+		{08087654-2C32-4818-95E4-45362373441D} = {963262D0-9FD5-4741-8C0E-E2F34F110EF3}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {75DDA3D8-9D6F-4865-93F4-DDE11DEE8290}
diff --git a/GitVersion.yml b/GitVersion.yml
index aec62da423..99fad930de 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -3,5 +3,11 @@ branches:
   release:
     regex: releases?[/-]
     tag: rc
+  pull-request:
+    mode: ContinuousDeployment
+    regex: ((pull|pull\-requests|pr)[/-]|[/-](merge))
+    tag: pr
+    tag-number-pattern: '[/-]?(?<number>\d+)'
+    prevent-increment-of-merged-branch-version: false
 ignore:
   sha: []
diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
index 6c9fc5255c..b4449db0ce 100644
--- a/ISSUE_TEMPLATE.md
+++ b/ISSUE_TEMPLATE.md
@@ -3,7 +3,7 @@
 * Tried upgrading to newest version of Fluent Assertions, to see if your issue has already been resolved and released?
 * Checked existing open *and* closed [issues](https://github.com/fluentassertions/fluentassertions/issues?utf8=%E2%9C%93&q=is%3Aissue), to see if the issue has already been reported?
 * Tried reproducing your problem in a new isolated project?
-* Read the [documentation](https://fluentassertions.com/introduction/)?
+* Read the [documentation](https://fluentassertions.com/introduction)?
 * Considered if this is a general question and not a bug?. For general questions please use [StackOverflow](https://stackoverflow.com/questions/tagged/fluent-assertions?mixed=1).
 
 ### Description
@@ -43,4 +43,4 @@ result.Should().Be('M');
 
 ### Additional Information
 
-Any additional information, configuration or data that might be necessary to reproduce the issue.
\ No newline at end of file
+Any additional information, configuration or data that might be necessary to reproduce the issue.
diff --git a/README.md b/README.md
index 03c59e98de..a8c1e9ca5f 100644
--- a/README.md
+++ b/README.md
@@ -13,8 +13,8 @@ See https://www.fluentassertions.com for [background information](https://fluent
 Originally authored by Dennis Doomen with Jonas Nyrup as the productive side-kick. Notable contributions were provided by Artur Krajewski, Lukas Grützmacher and David Omid.
 
 # How do I build this?
-Install Visual Studio 2019 16.9+ or JetBrains Rider 2017.1 and Build Tools 2017 and run.
-You will also need to have .NET Framework 4.7 SDK and .NET 5.0 SDK installed - check [global.json](global.json) for the current minimum required version.
+Install Visual Studio 2019 16.9+ or JetBrains Rider 2021.1.0 as well as the Build Tools 2019 (including the Universal Windows Platform build tools).
+You will also need to have .NET Framework 4.7 SDK and .NET 5.0 SDK installed. Check [global.json](global.json) for the current minimum required version.
 
 # What are these Approval.Tests?
 This is a special set of tests that use the [Verify](https://github.com/VerifyTests/Verify) project to verify whether you've introduced any breaking changes in the public API of the library.
diff --git a/Src/FluentAssertions/AssertionExtensions.cs b/Src/FluentAssertions/AssertionExtensions.cs
index 9eb3e85dfc..4940cffe48 100644
--- a/Src/FluentAssertions/AssertionExtensions.cs
+++ b/Src/FluentAssertions/AssertionExtensions.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq.Expressions;
+using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 using System.Xml.Linq;
@@ -302,6 +303,16 @@ public static NullableBooleanAssertions Should(this bool? actualValue)
             return new NullableBooleanAssertions(actualValue);
         }
 
+        /// <summary>
+        /// Returns an <see cref="HttpResponseMessageAssertions"/> object that can be used to assert the
+        /// current <see cref="HttpResponseMessage"/>.
+        /// </summary>
+        [Pure]
+        public static HttpResponseMessageAssertions Should(this HttpResponseMessage actualValue)
+        {
+            return new HttpResponseMessageAssertions(actualValue);
+        }
+
         /// <summary>
         /// Returns an <see cref="GuidAssertions"/> object that can be used to assert the
         /// current <see cref="Guid"/>.
diff --git a/Src/FluentAssertions/CallerIdentifier.cs b/Src/FluentAssertions/CallerIdentifier.cs
index cbf3f2fa88..3985f68194 100644
--- a/Src/FluentAssertions/CallerIdentifier.cs
+++ b/Src/FluentAssertions/CallerIdentifier.cs
@@ -27,7 +27,7 @@ public static string DetermineCallerIdentity()
                 var stack = new StackTrace(fNeedFileInfo: true);
 
                 var allStackFrames = stack.GetFrames()
-                    .Where(frame => !IsCompilerServices(frame))
+                    .Where(frame => frame is not null && !IsCompilerServices(frame))
                     .ToArray();
 
                 int searchStart = allStackFrames.Length - 1;
@@ -40,13 +40,11 @@ public static string DetermineCallerIdentity()
                         frame => !IsCurrentAssembly(frame));
                 }
 
-                int firstFluentAssertionsCodeIndex = Array.FindLastIndex(
+                int lastUserStackFrameBeforeFluentAssertionsCodeIndex = Array.FindIndex(
                     allStackFrames,
-                    searchStart,
-                    frame => IsCurrentAssembly(frame));
-
-                int lastUserStackFrameBeforeFluentAssertionsCodeIndex =
-                    firstFluentAssertionsCodeIndex + 1;
+                    startIndex: 0,
+                    count: searchStart + 1,
+                    frame => !IsCurrentAssembly(frame) && !IsDotNet(frame));
 
                 for (int i = lastUserStackFrameBeforeFluentAssertionsCodeIndex; i < allStackFrames.Length; i++)
                 {
@@ -84,7 +82,7 @@ public StackFrameReference()
                 var stack = new StackTrace();
 
                 var allStackFrames = stack.GetFrames()
-                    .Where(frame => !IsCompilerServices(frame))
+                    .Where(frame => frame is not null && !IsCompilerServices(frame))
                     .ToArray();
 
                 int firstUserCodeFrameIndex = 0;
@@ -117,7 +115,7 @@ internal static IDisposable OverrideStackSearchUsingCurrentScope()
         internal static bool OnlyOneFluentAssertionScopeOnCallStack()
         {
             var allStackFrames = new StackTrace().GetFrames()
-                .Where(frame => !IsCompilerServices(frame))
+                .Where(frame => frame is not null && !IsCompilerServices(frame))
                 .ToArray();
 
             int firstNonFluentAssertionsStackFrameIndex = Array.FindIndex(
@@ -132,29 +130,29 @@ internal static bool OnlyOneFluentAssertionScopeOnCallStack()
             int startOfSecondFluentAssertionsScopeStackFrameIndex = Array.FindIndex(
                 allStackFrames,
                 startIndex: firstNonFluentAssertionsStackFrameIndex + 1,
-                IsCurrentAssembly);
+                frame => IsCurrentAssembly(frame));
 
             return startOfSecondFluentAssertionsScopeStackFrameIndex < 0;
         }
 
         private static bool IsCustomAssertion(StackFrame frame)
         {
-            return frame.GetMethod().IsDecoratedWithOrInherit<CustomAssertionAttribute>();
+            return frame.GetMethod()?.IsDecoratedWithOrInherit<CustomAssertionAttribute>() == true;
         }
 
         private static bool IsDynamic(StackFrame frame)
         {
-            return frame.GetMethod().DeclaringType is null;
+            return frame.GetMethod() is { DeclaringType: null };
         }
 
         private static bool IsCurrentAssembly(StackFrame frame)
         {
-            return frame.GetMethod().DeclaringType?.Assembly == typeof(CallerIdentifier).Assembly;
+            return frame.GetMethod()?.DeclaringType?.Assembly == typeof(CallerIdentifier).Assembly;
         }
 
         private static bool IsDotNet(StackFrame frame)
         {
-            var frameNamespace = frame.GetMethod().DeclaringType.Namespace;
+            var frameNamespace = frame.GetMethod()?.DeclaringType?.Namespace;
             var comparisonType = StringComparison.OrdinalIgnoreCase;
 
             return frameNamespace?.StartsWith("system.", comparisonType) == true ||
@@ -163,7 +161,7 @@ private static bool IsDotNet(StackFrame frame)
 
         private static bool IsCompilerServices(StackFrame frame)
         {
-            return frame.GetMethod().DeclaringType?.Namespace == "System.Runtime.CompilerServices";
+            return frame.GetMethod()?.DeclaringType?.Namespace == "System.Runtime.CompilerServices";
         }
 
         private static string ExtractVariableNameFrom(StackFrame frame)
diff --git a/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs b/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
index ff75c7090d..54a10c802c 100644
--- a/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
+++ b/Src/FluentAssertions/Collections/GenericCollectionAssertions.cs
@@ -946,7 +946,7 @@ public AndConstraint<TAssertions> ContainInOrder(IEnumerable<T> expected, string
         }
 
         /// <summary>
-        /// Asserts that the current collection only contains items that are assignable to the type <typeparamref name="TExpectation" />.
+        /// Asserts that the current collection contains at least one element that is assignable to the type <typeparamref name="TExpectation" />.
         /// </summary>
         /// <param name="because">
         /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
@@ -957,29 +957,18 @@ public AndConstraint<TAssertions> ContainInOrder(IEnumerable<T> expected, string
         /// </param>
         public AndConstraint<TAssertions> ContainItemsAssignableTo<TExpectation>(string because = "", params object[] becauseArgs)
         {
-            bool success = Execute.Assertion
+            Execute.Assertion
                 .BecauseOf(because, becauseArgs)
+                .WithExpectation("Expected {context:collection} to contain at least one element assignable to type {0}{reason}, ",
+                    typeof(TExpectation).FullName)
                 .ForCondition(Subject is not null)
-                .FailWith("Expected {context:collection} to contain element assignable to type {0}{reason}, but found <null>.",
-                    typeof(TExpectation));
-
-            if (success)
-            {
-                int index = 0;
-                foreach (T item in Subject)
-                {
-                    if (item is not TExpectation)
-                    {
-                        Execute.Assertion
-                            .BecauseOf(because, becauseArgs)
-                            .FailWith(
-                                "Expected {context:collection} to contain only items of type {0}{reason}" +
-                                ", but item {1} at index {2} is of type {3}.", typeof(TExpectation), item, index, item.GetType());
-                    }
-
-                    ++index;
-                }
-            }
+                .FailWith("but found <null>.")
+                .Then
+                .Given(() => Subject.ConvertOrCastToCollection())
+                .ForCondition(subject => subject.Any(x => typeof(TExpectation).IsAssignableFrom(GetType(x))))
+                .FailWith("but found {0}.", subject => subject.Select(x => GetType(x)))
+                .Then
+                .ClearExpectation();
 
             return new AndConstraint<TAssertions>((TAssertions)this);
         }
diff --git a/Src/FluentAssertions/Common/Configuration.cs b/Src/FluentAssertions/Common/Configuration.cs
index a59e40be46..d46724dd7e 100644
--- a/Src/FluentAssertions/Common/Configuration.cs
+++ b/Src/FluentAssertions/Common/Configuration.cs
@@ -76,7 +76,7 @@ private ValueFormatterDetectionMode DetermineFormatterDetectionMode()
 
         /// <summary>
         /// Gets or sets the assembly name to scan for custom value formatters in case <see cref="ValueFormatterDetectionMode"/>
-        /// is set to <see cref="ValueFormatterDetectionMode.Specific"/>.
+        /// is set to <see cref="Common.ValueFormatterDetectionMode.Specific"/>.
         /// </summary>
         public string ValueFormatterAssembly
         {
diff --git a/Src/FluentAssertions/Common/DictionaryHelpers.cs b/Src/FluentAssertions/Common/DictionaryHelpers.cs
index 99b3e92d6d..a152c63b00 100644
--- a/Src/FluentAssertions/Common/DictionaryHelpers.cs
+++ b/Src/FluentAssertions/Common/DictionaryHelpers.cs
@@ -58,9 +58,17 @@ public static bool TryGetValue<TCollection, TKey, TValue>(this TCollection colle
             static bool TryGetValue(TCollection collection, TKey key, out TValue value)
             {
                 Func<TKey, TKey, bool> areSameOrEqual = ObjectExtensions.GetComparer<TKey>();
-                KeyValuePair<TKey, TValue> matchingPair = collection.FirstOrDefault(kvp => areSameOrEqual(kvp.Key, key));
-                value = matchingPair.Value;
-                return matchingPair.Equals(default(KeyValuePair<TKey, TValue>));
+                foreach (var kvp in collection)
+                {
+                    if (areSameOrEqual(kvp.Key, key))
+                    {
+                        value = kvp.Value;
+                        return true;
+                    }
+                }
+
+                value = default;
+                return false;
             }
         }
 
diff --git a/Src/FluentAssertions/Data/DataEquivalencyAssertionOptions.cs b/Src/FluentAssertions/Data/DataEquivalencyAssertionOptions.cs
index e73cebbba3..e69b9c6597 100644
--- a/Src/FluentAssertions/Data/DataEquivalencyAssertionOptions.cs
+++ b/Src/FluentAssertions/Data/DataEquivalencyAssertionOptions.cs
@@ -177,7 +177,7 @@ private static MemberInfo GetMemberAccessTargetMember(Expression expression)
              && (unaryExpression.NodeType == ExpressionType.Convert))
             {
                 // If the expression is a value type, then accessing it will involve an
-                // implicit boxing convertion to type object that we need to ignore.
+                // implicit boxing conversion to type object that we need to ignore.
                 expression = unaryExpression.Operand;
             }
 
diff --git a/Src/FluentAssertions/Equivalency/Selection/SelectMemberByPathSelectionRule.cs b/Src/FluentAssertions/Equivalency/Selection/SelectMemberByPathSelectionRule.cs
index 62da346822..8a32b13ea3 100644
--- a/Src/FluentAssertions/Equivalency/Selection/SelectMemberByPathSelectionRule.cs
+++ b/Src/FluentAssertions/Equivalency/Selection/SelectMemberByPathSelectionRule.cs
@@ -22,7 +22,7 @@ public IEnumerable<IMember> SelectMembers(INode currentNode, IEnumerable<IMember
             string currentPath = currentNode.PathAndName;
 
             // If we're part of a collection comparison, the selected path will not include an index,
-            // so we need to to remove it from the current node as well.
+            // so we need to remove it from the current node as well.
             if (!ContainsIndexingQualifiers(selectedPath))
             {
                 currentPath = RemoveIndexQualifiers(currentPath);
diff --git a/Src/FluentAssertions/Events/EventMonitor.cs b/Src/FluentAssertions/Events/EventMonitor.cs
index 132154b758..41cc874c2c 100644
--- a/Src/FluentAssertions/Events/EventMonitor.cs
+++ b/Src/FluentAssertions/Events/EventMonitor.cs
@@ -30,6 +30,8 @@ public EventMonitor(object eventSource, Func<DateTime> utcNow)
 
         public T Subject => (T)subject.Target;
 
+        private readonly ThreadSafeSequenceGenerator threadSafeSequenceGenerator = new();
+
         public EventMetadata[] MonitoredEvents
         {
             get
@@ -49,7 +51,7 @@ public OccurredEvent[] OccurredEvents
                     from eventName in recorderMap.Keys
                     let recording = GetRecordingFor(eventName)
                     from @event in recording
-                    orderby @event.TimestampUtc
+                    orderby @event.Sequence
                     select @event;
 
                 return query.ToArray();
@@ -125,7 +127,7 @@ private void AttachEventHandler(EventInfo eventInfo, Func<DateTime> utcNow)
         {
             if (!recorderMap.TryGetValue(eventInfo.Name, out _))
             {
-                var recorder = new EventRecorder(subject.Target, eventInfo.Name, utcNow);
+                var recorder = new EventRecorder(subject.Target, eventInfo.Name, utcNow, threadSafeSequenceGenerator);
                 if (recorderMap.TryAdd(eventInfo.Name, recorder))
                 {
                     recorder.Attach(subject, eventInfo);
diff --git a/Src/FluentAssertions/Events/EventRecorder.cs b/Src/FluentAssertions/Events/EventRecorder.cs
index 647e216f9e..abea8d3b2b 100644
--- a/Src/FluentAssertions/Events/EventRecorder.cs
+++ b/Src/FluentAssertions/Events/EventRecorder.cs
@@ -25,11 +25,13 @@ internal sealed class EventRecorder : IEventRecording, IDisposable
         /// <param name="eventRaiser">The object events are recorded from</param>
         /// <param name="eventName">The name of the event that's recorded</param>
         /// <param name="utcNow">A delegate to get the current date and time in UTC format.</param>
-        public EventRecorder(object eventRaiser, string eventName, Func<DateTime> utcNow)
+        /// <param name="sequenceGenerator">Class used to generate a sequence in a thread-safe manner.</param>
+        public EventRecorder(object eventRaiser, string eventName, Func<DateTime> utcNow, ThreadSafeSequenceGenerator sequenceGenerator)
         {
             this.utcNow = utcNow;
             EventObject = eventRaiser;
             EventName = eventName;
+            this.sequenceGenerator = sequenceGenerator;
         }
 
         /// <summary>
@@ -40,6 +42,8 @@ public EventRecorder(object eventRaiser, string eventName, Func<DateTime> utcNow
         /// <inheritdoc />
         public string EventName { get; }
 
+        private readonly ThreadSafeSequenceGenerator sequenceGenerator;
+
         public Type EventHandlerType { get; private set; }
 
         public void Attach(WeakReference subject, EventInfo eventInfo)
@@ -77,7 +81,7 @@ public void RecordEvent(params object[] parameters)
         {
             lock (lockable)
             {
-                raisedEvents.Add(new RecordedEvent(utcNow(), parameters));
+                raisedEvents.Add(new RecordedEvent(utcNow(), sequenceGenerator.Increment(), parameters));
             }
         }
 
@@ -105,7 +109,8 @@ public IEnumerator<OccurredEvent> GetEnumerator()
                 {
                     EventName = EventName,
                     Parameters = @event.Parameters,
-                    TimestampUtc = @event.TimestampUtc
+                    TimestampUtc = @event.TimestampUtc,
+                    Sequence = @event.Sequence
                 };
             }
         }
diff --git a/Src/FluentAssertions/Events/OccurredEvent.cs b/Src/FluentAssertions/Events/OccurredEvent.cs
index 937025bfd3..761341ea29 100644
--- a/Src/FluentAssertions/Events/OccurredEvent.cs
+++ b/Src/FluentAssertions/Events/OccurredEvent.cs
@@ -21,5 +21,10 @@ public class OccurredEvent
         /// The exact date and time of the occurrence in <see cref="DateTimeKind.Local"/>.
         /// </summary>
         public DateTime TimestampUtc { get; set; }
+
+        /// <summary>
+        /// The order in which this event was raised on the monitored object.
+        /// </summary>
+        public int Sequence { get; set; }
     }
 }
diff --git a/Src/FluentAssertions/Events/RecordedEvent.cs b/Src/FluentAssertions/Events/RecordedEvent.cs
index 1930a605ee..69168a7692 100644
--- a/Src/FluentAssertions/Events/RecordedEvent.cs
+++ b/Src/FluentAssertions/Events/RecordedEvent.cs
@@ -12,10 +12,11 @@ internal class RecordedEvent
         /// <summary>
         /// Default constructor stores the parameters the event was raised with
         /// </summary>
-        public RecordedEvent(DateTime utcNow, params object[] parameters)
+        public RecordedEvent(DateTime utcNow, int sequence, params object[] parameters)
         {
             Parameters = parameters;
             TimestampUtc = utcNow;
+            Sequence = sequence;
         }
 
         /// <summary>
@@ -27,5 +28,10 @@ public RecordedEvent(DateTime utcNow, params object[] parameters)
         /// Parameters for the event
         /// </summary>
         public object[] Parameters { get; }
+
+        /// <summary>
+        /// The order in which this event was invoked on the monitored object.
+        /// </summary>
+        public int Sequence { get; }
     }
 }
diff --git a/Src/FluentAssertions/Events/ThreadSafeSequenceGenerator.cs b/Src/FluentAssertions/Events/ThreadSafeSequenceGenerator.cs
new file mode 100644
index 0000000000..4ccf4ad443
--- /dev/null
+++ b/Src/FluentAssertions/Events/ThreadSafeSequenceGenerator.cs
@@ -0,0 +1,20 @@
+using System.Threading;
+
+namespace FluentAssertions.Events
+{
+    /// <summary>
+    /// Generates a sequence in a thread-safe manner.
+    /// </summary>
+    internal sealed class ThreadSafeSequenceGenerator
+    {
+        private int sequence = -1;
+
+        /// <summary>
+        /// Increments the current sequence.
+        /// </summary>
+        public int Increment()
+        {
+            return Interlocked.Increment(ref sequence);
+        }
+    }
+}
diff --git a/Src/FluentAssertions/ExceptionAssertionsExtensions.cs b/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
index 13376a3a46..5572cebbc3 100644
--- a/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
+++ b/Src/FluentAssertions/ExceptionAssertionsExtensions.cs
@@ -80,6 +80,28 @@ public static async Task<ExceptionAssertions<TInnerException>> WithInnerExceptio
             return (await task).WithInnerException<TInnerException>(because, becauseArgs);
         }
 
+        /// <summary>
+        /// Asserts that the thrown exception contains an inner exception of type <param name="innerException" />.
+        /// </summary>
+        /// <typeparam name="TException">The expected type of the exception.</typeparam>
+        /// <param name="task">The <see cref="ExceptionAssertions{TException}"/> containing the thrown exception.</param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public static async Task<ExceptionAssertions<Exception>> WithInnerException<TException>(
+            this Task<ExceptionAssertions<TException>> task,
+            Type innerException,
+            string because = "",
+            params object[] becauseArgs)
+            where TException : Exception
+        {
+            return (await task).WithInnerException(innerException, because, becauseArgs);
+        }
+
         /// <summary>
         /// Asserts that the thrown exception contains an inner exception of the exact type <typeparamref name="TInnerException" /> (and not a derived exception type).
         /// </summary>
@@ -103,6 +125,28 @@ public static async Task<ExceptionAssertions<TInnerException>> WithInnerExceptio
             return (await task).WithInnerExceptionExactly<TInnerException>(because, becauseArgs);
         }
 
+        /// <summary>
+        /// Asserts that the thrown exception contains an inner exception of the exact type <param name="innerException" /> (and not a derived exception type).
+        /// </summary>
+        /// <typeparam name="TException">The expected type of the exception.</typeparam>
+        /// <param name="task">The <see cref="ExceptionAssertions{TException}"/> containing the thrown exception.</param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public static async Task<ExceptionAssertions<Exception>> WithInnerExceptionExactly<TException>(
+            this Task<ExceptionAssertions<TException>> task,
+            Type innerException,
+            string because = "",
+            params object[] becauseArgs)
+            where TException : Exception
+        {
+            return (await task).WithInnerExceptionExactly(innerException, because, becauseArgs);
+        }
+
         /// <summary>
         /// Asserts that the thrown exception has a parameter which name matches <paramref name="paramName" />.
         /// </summary>
diff --git a/Src/FluentAssertions/Execution/GivenSelector.cs b/Src/FluentAssertions/Execution/GivenSelector.cs
index 395e2aeb12..58d46f2647 100644
--- a/Src/FluentAssertions/Execution/GivenSelector.cs
+++ b/Src/FluentAssertions/Execution/GivenSelector.cs
@@ -49,7 +49,7 @@ public GivenSelector<T> ForCondition(Func<T, bool> predicate)
         /// The <paramref name="selector"/> will not be invoked if the prior assertion failed,
         /// nor will <see cref="FailWith(string, Func{T,object}[])"/> throw any exceptions.
         /// </remarks>
-        /// <inheritdoc cref="IAssertionScope.Given"/>
+        /// <inheritdoc cref="IAssertionScope.Given{T}"/>
         public GivenSelector<TOut> Given<TOut>(Func<T, TOut> selector)
         {
             Guard.ThrowIfArgumentIsNull(selector, nameof(selector));
diff --git a/Src/FluentAssertions/Execution/IAssertionScope.cs b/Src/FluentAssertions/Execution/IAssertionScope.cs
index e59099e9c4..a70a57c678 100644
--- a/Src/FluentAssertions/Execution/IAssertionScope.cs
+++ b/Src/FluentAssertions/Execution/IAssertionScope.cs
@@ -44,7 +44,7 @@ public interface IAssertionScope : IDisposable
         Continuation FailWith(string message);
 
         /// <summary>
-        /// Sets the failure message when the assertion is not met, or completes the failure message set to aprior call to
+        /// Sets the failure message when the assertion is not met, or completes the failure message set to a prior call to
         /// <see cref="AssertionScope.WithExpectation"/>.
         /// <paramref name="failReasonFunc"/> will not be called unless the assertion is not met.
         /// </summary>
diff --git a/Src/FluentAssertions/Execution/MessageBuilder.cs b/Src/FluentAssertions/Execution/MessageBuilder.cs
index c580c5bd34..d2c3a60471 100644
--- a/Src/FluentAssertions/Execution/MessageBuilder.cs
+++ b/Src/FluentAssertions/Execution/MessageBuilder.cs
@@ -91,7 +91,14 @@ private string FormatArgumentPlaceholders(string failureMessage, object[] failur
         {
             string[] values = failureArgs.Select(a => Formatter.ToString(a, formattingOptions)).ToArray();
 
-            return string.Format(CultureInfo.InvariantCulture, failureMessage, values);
+            try
+            {
+                return string.Format(CultureInfo.InvariantCulture, failureMessage, values);
+            }
+            catch (FormatException formatException)
+            {
+                return $"**WARNING** failure message '{failureMessage}' could not be formatted with string.Format{Environment.NewLine}{formatException.StackTrace}";
+            }
         }
 
         private string SanitizeReason(string reason)
diff --git a/Src/FluentAssertions/FluentAssertions.csproj b/Src/FluentAssertions/FluentAssertions.csproj
index 2204810ff1..1a3d1f3de8 100644
--- a/Src/FluentAssertions/FluentAssertions.csproj
+++ b/Src/FluentAssertions/FluentAssertions.csproj
@@ -1,4 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <!-- To reduce build times, we only enable analyzers for the newest TFM -->
   <PropertyGroup>
     <TargetFrameworks>net47;netcoreapp2.1;netcoreapp3.0;netstandard2.0;netstandard2.1</TargetFrameworks>
     <SignAssembly>True</SignAssembly>
@@ -11,6 +12,7 @@
     <CodeAnalysisRuleSet>..\..\Rules.ruleset</CodeAnalysisRuleSet>
     <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
   </PropertyGroup>
   <PropertyGroup>
     <Authors>Dennis Doomen;Jonas Nyrup</Authors>
@@ -29,6 +31,11 @@
     <Copyright>Copyright Dennis Doomen 2010-2020</Copyright>
     <LangVersion>9.0</LangVersion>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.0'">
+    <RunAnalyzersDuringBuild>false</RunAnalyzersDuringBuild>
+    <RunAnalyzersDuringLiveAnalysis>false</RunAnalyzersDuringLiveAnalysis>
+    <RunAnalyzers>false</RunAnalyzers>
+  </PropertyGroup>
   <ItemGroup>
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
       <_Parameter1>FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f</_Parameter1>
@@ -75,6 +82,7 @@
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net47'">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs
new file mode 100644
index 0000000000..3b3e96779f
--- /dev/null
+++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs
@@ -0,0 +1,236 @@
+using System.Diagnostics;
+using System.Net;
+using System.Net.Http;
+using FluentAssertions.Execution;
+
+namespace FluentAssertions.Primitives
+{
+    /// <summary>
+    /// Contains a number of methods to assert that a <see cref="HttpResponseMessage"/> is in the expected state.
+    /// </summary>
+    [DebuggerNonUserCode]
+    public class HttpResponseMessageAssertions : HttpResponseMessageAssertions<HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(HttpResponseMessage value)
+            : base(value)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Contains a number of methods to assert that a <see cref="HttpResponseMessage" /> is in the expected state.
+    /// </summary>
+    [DebuggerNonUserCode]
+    public class HttpResponseMessageAssertions<TAssertions> : ObjectAssertions<HttpResponseMessage, TAssertions>
+        where TAssertions : HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(HttpResponseMessage value)
+            : base(value)
+        {
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is successful (2xx).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but HttpResponseMessage was <null>.");
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(Subject!.IsSuccessStatusCode)
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but found {0}.", Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is redirection (3xx).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but HttpResponseMessage was <null>.");
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition((int)Subject!.StatusCode is >= 300 and <= 399)
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but found {0}.", Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is either client (4xx) or server error (5xx).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be an error{reason}, but HttpResponseMessage was <null>.");
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(IsClientError() || IsServerError())
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be an error{reason}, but found {0}.", Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is client error (4xx).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but HttpResponseMessage was <null>.");
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(IsClientError())
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but found {0}.", Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is server error (5xx).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but HttpResponseMessage was <null>.");
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(IsServerError())
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but found {0}.", Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is equal to the specified <paramref name="expected"/> value.
+        /// </summary>
+        /// <param name="expected">The expected value</param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> HaveStatusCode(HttpStatusCode expected, string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode to be {0}{reason}, but HttpResponseMessage was <null>.", expected);
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(Subject!.StatusCode == expected)
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode to be {0}{reason}, but found {1}.", expected, Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="HttpStatusCode"/> is not equal to the specified <paramref name="unexpected"/> value.
+        /// </summary>
+        /// <param name="unexpected">The unexpected value</param>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because"/>.
+        /// </param>
+        public AndConstraint<TAssertions> NotHaveStatusCode(HttpStatusCode unexpected, string because = "", params object[] becauseArgs)
+        {
+            var success = Execute.Assertion
+                .ForCondition(Subject is not null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected HttpStatusCode not to be {0}{reason}, but HttpResponseMessage was <null>.", unexpected);
+
+            if (success)
+            {
+                Execute.Assertion
+                    .ForCondition(Subject!.StatusCode != unexpected)
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected HttpStatusCode not to be {0}{reason}, but found {1}.", unexpected, Subject.StatusCode);
+            }
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        private bool IsServerError() => (int)Subject.StatusCode is >= 500 and <= 599;
+
+        private bool IsClientError() => (int)Subject.StatusCode is >= 400 and <= 499;
+
+        protected override string Identifier => "HTTP response message";
+    }
+}
diff --git a/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs b/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
index b3a56a1e56..80e53e1490 100644
--- a/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
+++ b/Src/FluentAssertions/Primitives/ReferenceTypeAssertions.cs
@@ -416,6 +416,7 @@ public AndConstraint<TAssertions> Match<T>(Expression<Func<T, bool>> predicate,
 
         /// <summary>
         /// Returns the type of the subject the assertion applies on.
+        /// It should be a user-friendly name as it is included in the failure message.
         /// </summary>
         protected abstract string Identifier { get; }
 
diff --git a/Src/FluentAssertions/Specialized/ExceptionAssertions.cs b/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
index cb559a624b..f5b735193a 100644
--- a/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
+++ b/Src/FluentAssertions/Specialized/ExceptionAssertions.cs
@@ -3,9 +3,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Linq.Expressions;
-
 using FluentAssertions.Common;
-using FluentAssertions.Equivalency;
 using FluentAssertions.Equivalency.Steps;
 using FluentAssertions.Execution;
 using FluentAssertions.Formatting;
@@ -89,7 +87,8 @@ public virtual ExceptionAssertions<TException> WithMessage(string expectedWildca
                 .ForCondition(Subject.Any())
                 .FailWith("Expected exception with message {0}{reason}, but no exception was thrown.", expectedWildcardPattern);
 
-            OuterMessageAssertion.Execute(Subject.Select(exc => exc.Message).ToArray(), expectedWildcardPattern, because, becauseArgs);
+            OuterMessageAssertion.Execute(Subject.Select(exc => exc.Message).ToArray(), expectedWildcardPattern, because,
+                becauseArgs);
 
             return this;
         }
@@ -109,28 +108,24 @@ public virtual ExceptionAssertions<TInnerException> WithInnerException<TInnerExc
             params object[] becauseArgs)
             where TInnerException : Exception
         {
-            Execute.Assertion
-                .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected inner {0}{reason}, but ", typeof(TInnerException))
-                .ForCondition(Subject is not null)
-                .FailWith("no exception was thrown.")
-                .Then
-                .ForCondition(Subject.Any(e => e.InnerException is not null))
-                .FailWith("the thrown exception has no inner exception.")
-                .Then
-                .ClearExpectation();
-
-            TInnerException[] expectedInnerExceptions = Subject
-                .Select(e => e.InnerException)
-                .OfType<TInnerException>()
-                .ToArray();
-
-            Execute.Assertion
-                .ForCondition(expectedInnerExceptions.Any())
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected inner {0}{reason}, but found {1}.", typeof(TInnerException), SingleSubject.InnerException);
+            var expectedInnerExceptions = AssertInnerExceptions(typeof(TInnerException), because, becauseArgs);
+            return new ExceptionAssertions<TInnerException>(expectedInnerExceptions.Cast<TInnerException>());
+        }
 
-            return new ExceptionAssertions<TInnerException>(expectedInnerExceptions);
+        /// <summary>
+        /// Asserts that the thrown exception contains an inner exception of type <param name="innerException" />.
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public ExceptionAssertions<Exception> WithInnerException(Type innerException, string because = null,
+            params object[] becauseArgs)
+        {
+            return new ExceptionAssertions<Exception>(AssertInnerExceptions(innerException, because, becauseArgs));
         }
 
         /// <summary>
@@ -148,19 +143,24 @@ public virtual ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TI
             params object[] becauseArgs)
             where TInnerException : Exception
         {
-            WithInnerException<TInnerException>(because, becauseArgs);
-
-            TInnerException[] expectedExceptions = Subject
-                .Select(e => e.InnerException)
-                .OfType<TInnerException>()
-                .Where(e => e?.GetType() == typeof(TInnerException)).ToArray();
-
-            Execute.Assertion
-                .ForCondition(expectedExceptions.Any())
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected inner {0}{reason}, but found {1}.", typeof(TInnerException), SingleSubject.InnerException);
+            var exceptionExpression = AssertInnerExceptionExactly(typeof(TInnerException), because, becauseArgs);
+            return new ExceptionAssertions<TInnerException>(exceptionExpression.Cast<TInnerException>());
+        }
 
-            return new ExceptionAssertions<TInnerException>(expectedExceptions);
+        /// <summary>
+        /// Asserts that the thrown exception contains an inner exception of the exact type <param name="innerException" /> (and not a derived exception type).
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public ExceptionAssertions<Exception> WithInnerExceptionExactly(Type innerException, string because = null,
+            params object[] becauseArgs)
+        {
+            return new ExceptionAssertions<Exception>(AssertInnerExceptionExactly(innerException, because, becauseArgs));
         }
 
         /// <summary>
@@ -191,6 +191,54 @@ public ExceptionAssertions<TException> Where(Expression<Func<TException, bool>>
             return this;
         }
 
+        private IEnumerable<Exception> AssertInnerExceptionExactly(Type innerException, string because = null,
+            params object[] becauseArgs)
+        {
+            Guard.ThrowIfArgumentIsNull(innerException, nameof(innerException));
+
+            AssertInnerExceptions(innerException, because, becauseArgs);
+
+            Exception[] expectedExceptions = Subject
+                .Select(e => e.InnerException)
+                .Where(e => e?.GetType() == innerException).ToArray();
+
+            Execute.Assertion
+                .ForCondition(expectedExceptions.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected inner {0}{reason}, but found {1}.", innerException, SingleSubject.InnerException);
+
+            return expectedExceptions;
+        }
+
+        private IEnumerable<Exception> AssertInnerExceptions(Type innerException, string because = null,
+            params object[] becauseArgs)
+        {
+            Guard.ThrowIfArgumentIsNull(innerException, nameof(innerException));
+
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .WithExpectation("Expected inner {0}{reason}, but ", innerException)
+                .ForCondition(Subject is not null)
+                .FailWith("no exception was thrown.")
+                .Then
+                .ForCondition(Subject.Any(e => e.InnerException is not null))
+                .FailWith("the thrown exception has no inner exception.")
+                .Then
+                .ClearExpectation();
+
+            Exception[] expectedInnerExceptions = Subject
+                .Select(e => e.InnerException)
+                .Where(e => e != null && e.GetType().IsSameOrInherits(innerException))
+                .ToArray();
+
+            Execute.Assertion
+                .ForCondition(expectedInnerExceptions.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected inner {0}{reason}, but found {1}.", innerException, SingleSubject.InnerException);
+
+            return expectedInnerExceptions;
+        }
+
         private TException SingleSubject
         {
             get
diff --git a/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs b/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
index 018e873a61..8b193ba680 100644
--- a/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
+++ b/Src/FluentAssertions/Streams/BufferedStreamAssertions.cs
@@ -27,6 +27,8 @@ public BufferedStreamAssertions(BufferedStream stream)
         {
         }
 
+        protected override string Identifier => "buffered stream";
+
 #if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1
         /// <summary>
         /// Asserts that the current <see cref="BufferedStream"/> has the <paramref name="expected"/> buffer size.
diff --git a/Src/FluentAssertions/Types/MethodBaseAssertions.cs b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
index ddf91bef42..2136b6a769 100644
--- a/Src/FluentAssertions/Types/MethodBaseAssertions.cs
+++ b/Src/FluentAssertions/Types/MethodBaseAssertions.cs
@@ -93,8 +93,6 @@ public AndConstraint<TAssertions> NotHaveAccessModifier(CSharpAccessModifier acc
             return new AndConstraint<TAssertions>((TAssertions)this);
         }
 
-        protected override string Identifier => "methodBase";
-
         internal static string GetParameterString(MethodBase methodBase)
         {
             IEnumerable<Type> parameterTypes = methodBase.GetParameters().Select(p => p.ParameterType);
diff --git a/Src/FluentAssertions/Types/MethodInfoSelector.cs b/Src/FluentAssertions/Types/MethodInfoSelector.cs
index e3ba8ca102..f800d0d656 100644
--- a/Src/FluentAssertions/Types/MethodInfoSelector.cs
+++ b/Src/FluentAssertions/Types/MethodInfoSelector.cs
@@ -35,7 +35,7 @@ public MethodInfoSelector(IEnumerable<Type> types)
             Guard.ThrowIfArgumentContainsNull(types, nameof(types));
 
             selectedMethods = types.SelectMany(t => t
-                .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
                 .Where(method => !HasSpecialName(method)));
         }
 
@@ -151,6 +151,24 @@ public MethodInfoSelector ThatAreNotAsync()
             return this;
         }
 
+        /// <summary>
+        /// Only return methods that are static. 
+        /// </summary>
+        public MethodInfoSelector ThatAreStatic()
+        {
+            selectedMethods = selectedMethods.Where(method => method.IsStatic);
+            return this;
+        }
+
+        /// <summary>
+        /// Only return methods that are not static. 
+        /// </summary>
+        public MethodInfoSelector ThatAreNotStatic()
+        {
+            selectedMethods = selectedMethods.Where(method => !method.IsStatic);
+            return this;
+        }
+
         /// <summary>
         /// Only return methods that are virtual. 
         /// </summary>
diff --git a/Src/FluentAssertions/Xml/XmlElementAssertions.cs b/Src/FluentAssertions/Xml/XmlElementAssertions.cs
index 11283d19be..46814dc5fe 100644
--- a/Src/FluentAssertions/Xml/XmlElementAssertions.cs
+++ b/Src/FluentAssertions/Xml/XmlElementAssertions.cs
@@ -165,5 +165,7 @@ public AndWhichConstraint<XmlElementAssertions, XmlElement> HaveElementWithNames
 
             return new AndWhichConstraint<XmlElementAssertions, XmlElement>(this, element);
         }
+
+        protected override string Identifier => "XML element";
     }
 }
diff --git a/Src/FluentAssertions/Xml/XmlNodeAssertions.cs b/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
index 6abe32d325..a8d571f05d 100644
--- a/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
+++ b/Src/FluentAssertions/Xml/XmlNodeAssertions.cs
@@ -80,6 +80,6 @@ public AndConstraint<TAssertions> NotBeEquivalentTo(XmlNode unexpected, string b
         /// <summary>
         /// Returns the type of the subject the assertion applies on.
         /// </summary>
-        protected override string Identifier => "Xml Node";
+        protected override string Identifier => "XML node";
     }
 }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
index ee73949aa0..64e793a717 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
@@ -66,6 +66,7 @@ namespace FluentAssertions
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
         public static FluentAssertions.Streams.BufferedStreamAssertions Should(this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should(this System.IO.Stream actualValue) { }
+        public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should(this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Reflection.AssemblyAssertions Should(this System.Reflection.Assembly assembly) { }
         public static FluentAssertions.Types.ConstructorInfoAssertions Should(this System.Reflection.ConstructorInfo constructorInfo) { }
         public static FluentAssertions.Types.MethodInfoAssertions Should(this System.Reflection.MethodInfo methodInfo) { }
@@ -241,9 +242,13 @@ namespace FluentAssertions
     {
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> Where<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerException<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerException<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerExceptionExactly<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerExceptionExactly<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
@@ -1216,6 +1221,7 @@ namespace FluentAssertions.Events
         public OccurredEvent() { }
         public string EventName { get; set; }
         public object[] Parameters { get; set; }
+        public int Sequence { get; set; }
         public System.DateTime TimestampUtc { get; set; }
     }
 }
@@ -1909,6 +1915,23 @@ namespace FluentAssertions.Primitives
         public FluentAssertions.AndConstraint<TAssertions> NotBe(string unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs) { }
     }
+    public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+    }
+    public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
+        where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected override string Identifier { get; }
+        public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { }
+    }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
         public NullableBooleanAssertions(bool? value) { }
@@ -2192,8 +2215,10 @@ namespace FluentAssertions.Specialized
         protected override string Identifier { get; }
         public TException Which { get; }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Where(System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerException(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerExceptionExactly(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { }
@@ -2267,6 +2292,7 @@ namespace FluentAssertions.Streams
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
         public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        protected override string Identifier { get; }
     }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
@@ -2325,7 +2351,6 @@ namespace FluentAssertions.Types
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
         protected MethodBaseAssertions(TSubject subject) { }
-        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
@@ -2363,7 +2388,9 @@ namespace FluentAssertions.Types
             where TAttribute : System.Attribute { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             where TAttribute : System.Attribute { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreNotStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotVirtual() { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreVirtual() { }
         public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn<TReturn>() { }
         public FluentAssertions.Types.MethodInfoSelector ThatReturn<TReturn>() { }
@@ -2620,6 +2647,7 @@ namespace FluentAssertions.Xml
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
         public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Xml.XmlElementAssertions, System.Xml.XmlElement> HaveElement(string expectedName, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt
index d5b927c7d6..78fbc1dd87 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt
@@ -66,6 +66,7 @@ namespace FluentAssertions
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
         public static FluentAssertions.Streams.BufferedStreamAssertions Should(this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should(this System.IO.Stream actualValue) { }
+        public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should(this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Reflection.AssemblyAssertions Should(this System.Reflection.Assembly assembly) { }
         public static FluentAssertions.Types.ConstructorInfoAssertions Should(this System.Reflection.ConstructorInfo constructorInfo) { }
         public static FluentAssertions.Types.MethodInfoAssertions Should(this System.Reflection.MethodInfo methodInfo) { }
@@ -241,9 +242,13 @@ namespace FluentAssertions
     {
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> Where<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerException<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerException<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerExceptionExactly<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerExceptionExactly<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
@@ -1216,6 +1221,7 @@ namespace FluentAssertions.Events
         public OccurredEvent() { }
         public string EventName { get; set; }
         public object[] Parameters { get; set; }
+        public int Sequence { get; set; }
         public System.DateTime TimestampUtc { get; set; }
     }
 }
@@ -1909,6 +1915,23 @@ namespace FluentAssertions.Primitives
         public FluentAssertions.AndConstraint<TAssertions> NotBe(string unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs) { }
     }
+    public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+    }
+    public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
+        where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected override string Identifier { get; }
+        public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { }
+    }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
         public NullableBooleanAssertions(bool? value) { }
@@ -2192,8 +2215,10 @@ namespace FluentAssertions.Specialized
         protected override string Identifier { get; }
         public TException Which { get; }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Where(System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerException(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerExceptionExactly(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { }
@@ -2267,6 +2292,7 @@ namespace FluentAssertions.Streams
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
         public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { }
     }
@@ -2327,7 +2353,6 @@ namespace FluentAssertions.Types
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
         protected MethodBaseAssertions(TSubject subject) { }
-        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
@@ -2365,7 +2390,9 @@ namespace FluentAssertions.Types
             where TAttribute : System.Attribute { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             where TAttribute : System.Attribute { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreNotStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotVirtual() { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreVirtual() { }
         public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn<TReturn>() { }
         public FluentAssertions.Types.MethodInfoSelector ThatReturn<TReturn>() { }
@@ -2622,6 +2649,7 @@ namespace FluentAssertions.Xml
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
         public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Xml.XmlElementAssertions, System.Xml.XmlElement> HaveElement(string expectedName, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt
index 62d7b60d9a..a71b144a73 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt
@@ -66,6 +66,7 @@ namespace FluentAssertions
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
         public static FluentAssertions.Streams.BufferedStreamAssertions Should(this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should(this System.IO.Stream actualValue) { }
+        public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should(this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Reflection.AssemblyAssertions Should(this System.Reflection.Assembly assembly) { }
         public static FluentAssertions.Types.ConstructorInfoAssertions Should(this System.Reflection.ConstructorInfo constructorInfo) { }
         public static FluentAssertions.Types.MethodInfoAssertions Should(this System.Reflection.MethodInfo methodInfo) { }
@@ -241,9 +242,13 @@ namespace FluentAssertions
     {
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> Where<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerException<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerException<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerExceptionExactly<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerExceptionExactly<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
@@ -1216,6 +1221,7 @@ namespace FluentAssertions.Events
         public OccurredEvent() { }
         public string EventName { get; set; }
         public object[] Parameters { get; set; }
+        public int Sequence { get; set; }
         public System.DateTime TimestampUtc { get; set; }
     }
 }
@@ -1909,6 +1915,23 @@ namespace FluentAssertions.Primitives
         public FluentAssertions.AndConstraint<TAssertions> NotBe(string unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs) { }
     }
+    public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+    }
+    public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
+        where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected override string Identifier { get; }
+        public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { }
+    }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
         public NullableBooleanAssertions(bool? value) { }
@@ -2192,8 +2215,10 @@ namespace FluentAssertions.Specialized
         protected override string Identifier { get; }
         public TException Which { get; }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Where(System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerException(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerExceptionExactly(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { }
@@ -2267,6 +2292,7 @@ namespace FluentAssertions.Streams
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
         public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { }
     }
@@ -2327,7 +2353,6 @@ namespace FluentAssertions.Types
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
         protected MethodBaseAssertions(TSubject subject) { }
-        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
@@ -2365,7 +2390,9 @@ namespace FluentAssertions.Types
             where TAttribute : System.Attribute { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             where TAttribute : System.Attribute { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreNotStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotVirtual() { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreVirtual() { }
         public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn<TReturn>() { }
         public FluentAssertions.Types.MethodInfoSelector ThatReturn<TReturn>() { }
@@ -2622,6 +2649,7 @@ namespace FluentAssertions.Xml
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
         public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Xml.XmlElementAssertions, System.Xml.XmlElement> HaveElement(string expectedName, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
index 45c197d938..da28d3d67b 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
@@ -65,6 +65,7 @@ namespace FluentAssertions
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
         public static FluentAssertions.Streams.BufferedStreamAssertions Should(this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should(this System.IO.Stream actualValue) { }
+        public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should(this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Reflection.AssemblyAssertions Should(this System.Reflection.Assembly assembly) { }
         public static FluentAssertions.Types.ConstructorInfoAssertions Should(this System.Reflection.ConstructorInfo constructorInfo) { }
         public static FluentAssertions.Types.MethodInfoAssertions Should(this System.Reflection.MethodInfo methodInfo) { }
@@ -234,9 +235,13 @@ namespace FluentAssertions
     {
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> Where<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerException<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerException<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerExceptionExactly<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerExceptionExactly<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
@@ -1862,6 +1867,23 @@ namespace FluentAssertions.Primitives
         public FluentAssertions.AndConstraint<TAssertions> NotBe(string unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs) { }
     }
+    public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+    }
+    public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
+        where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected override string Identifier { get; }
+        public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { }
+    }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
         public NullableBooleanAssertions(bool? value) { }
@@ -2145,8 +2167,10 @@ namespace FluentAssertions.Specialized
         protected override string Identifier { get; }
         public TException Which { get; }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Where(System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerException(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerExceptionExactly(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { }
@@ -2220,6 +2244,7 @@ namespace FluentAssertions.Streams
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
         public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        protected override string Identifier { get; }
     }
     public class StreamAssertions : FluentAssertions.Streams.StreamAssertions<System.IO.Stream, FluentAssertions.Streams.StreamAssertions>
     {
@@ -2278,7 +2303,6 @@ namespace FluentAssertions.Types
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
         protected MethodBaseAssertions(TSubject subject) { }
-        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
@@ -2316,7 +2340,9 @@ namespace FluentAssertions.Types
             where TAttribute : System.Attribute { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             where TAttribute : System.Attribute { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreNotStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotVirtual() { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreVirtual() { }
         public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn<TReturn>() { }
         public FluentAssertions.Types.MethodInfoSelector ThatReturn<TReturn>() { }
@@ -2573,6 +2599,7 @@ namespace FluentAssertions.Xml
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
         public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Xml.XmlElementAssertions, System.Xml.XmlElement> HaveElement(string expectedName, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
index 49ebf2d8c8..a2ecfc1c6f 100644
--- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
+++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
@@ -66,6 +66,7 @@ namespace FluentAssertions
         public static FluentAssertions.Primitives.NullableGuidAssertions Should(this System.Guid? actualValue) { }
         public static FluentAssertions.Streams.BufferedStreamAssertions Should(this System.IO.BufferedStream actualValue) { }
         public static FluentAssertions.Streams.StreamAssertions Should(this System.IO.Stream actualValue) { }
+        public static FluentAssertions.Primitives.HttpResponseMessageAssertions Should(this System.Net.Http.HttpResponseMessage actualValue) { }
         public static FluentAssertions.Reflection.AssemblyAssertions Should(this System.Reflection.Assembly assembly) { }
         public static FluentAssertions.Types.ConstructorInfoAssertions Should(this System.Reflection.ConstructorInfo constructorInfo) { }
         public static FluentAssertions.Types.MethodInfoAssertions Should(this System.Reflection.MethodInfo methodInfo) { }
@@ -241,9 +242,13 @@ namespace FluentAssertions
     {
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> Where<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerException<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerException<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
+        public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<System.Exception>> WithInnerExceptionExactly<TException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, System.Type innerException, string because = "", params object[] becauseArgs)
+            where TException : System.Exception { }
         public static System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TInnerException>> WithInnerExceptionExactly<TException, TInnerException>(this System.Threading.Tasks.Task<FluentAssertions.Specialized.ExceptionAssertions<TException>> task, string because = "", params object[] becauseArgs)
             where TException : System.Exception
             where TInnerException : System.Exception { }
@@ -1216,6 +1221,7 @@ namespace FluentAssertions.Events
         public OccurredEvent() { }
         public string EventName { get; set; }
         public object[] Parameters { get; set; }
+        public int Sequence { get; set; }
         public System.DateTime TimestampUtc { get; set; }
     }
 }
@@ -1909,6 +1915,23 @@ namespace FluentAssertions.Primitives
         public FluentAssertions.AndConstraint<TAssertions> NotBe(string unexpected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotBeEmpty(string because = "", params object[] becauseArgs) { }
     }
+    public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<FluentAssertions.Primitives.HttpResponseMessageAssertions>
+    {
+        public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+    }
+    public class HttpResponseMessageAssertions<TAssertions> : FluentAssertions.Primitives.ObjectAssertions<System.Net.Http.HttpResponseMessage, TAssertions>
+        where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions<TAssertions>
+    {
+        protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { }
+        protected override string Identifier { get; }
+        public FluentAssertions.AndConstraint<TAssertions> BeRedirection(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> BeSuccessful(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveClientError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveServerError(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<TAssertions> NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { }
+    }
     public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions<FluentAssertions.Primitives.NullableBooleanAssertions>
     {
         public NullableBooleanAssertions(bool? value) { }
@@ -2192,8 +2215,10 @@ namespace FluentAssertions.Specialized
         protected override string Identifier { get; }
         public TException Which { get; }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Where(System.Linq.Expressions.Expression<System.Func<TException, bool>> exceptionExpression, string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerException(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerException<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
+        public FluentAssertions.Specialized.ExceptionAssertions<System.Exception> WithInnerExceptionExactly(System.Type innerException, string because = null, params object[] becauseArgs) { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TInnerException> WithInnerExceptionExactly<TInnerException>(string because = null, params object[] becauseArgs)
             where TInnerException : System.Exception { }
         public virtual FluentAssertions.Specialized.ExceptionAssertions<TException> WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { }
@@ -2267,6 +2292,7 @@ namespace FluentAssertions.Streams
         where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions<TAssertions>
     {
         public BufferedStreamAssertions(System.IO.BufferedStream stream) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { }
     }
@@ -2327,7 +2353,6 @@ namespace FluentAssertions.Types
         where TAssertions : FluentAssertions.Types.MethodBaseAssertions<TSubject, TAssertions>
     {
         protected MethodBaseAssertions(TSubject subject) { }
-        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<TAssertions> HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { }
     }
@@ -2365,7 +2390,9 @@ namespace FluentAssertions.Types
             where TAttribute : System.Attribute { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             where TAttribute : System.Attribute { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreNotStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreNotVirtual() { }
+        public FluentAssertions.Types.MethodInfoSelector ThatAreStatic() { }
         public FluentAssertions.Types.MethodInfoSelector ThatAreVirtual() { }
         public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn<TReturn>() { }
         public FluentAssertions.Types.MethodInfoSelector ThatReturn<TReturn>() { }
@@ -2622,6 +2649,7 @@ namespace FluentAssertions.Xml
     public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions<System.Xml.XmlElement, FluentAssertions.Xml.XmlElementAssertions>
     {
         public XmlElementAssertions(System.Xml.XmlElement xmlElement) { }
+        protected override string Identifier { get; }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<FluentAssertions.Xml.XmlElementAssertions> HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndWhichConstraint<FluentAssertions.Xml.XmlElementAssertions, System.Xml.XmlElement> HaveElement(string expectedName, string because = "", params object[] becauseArgs) { }
diff --git a/Tests/Benchmarks/Benchmarks.csproj b/Tests/Benchmarks/Benchmarks.csproj
index 51b8040720..3e61198905 100644
--- a/Tests/Benchmarks/Benchmarks.csproj
+++ b/Tests/Benchmarks/Benchmarks.csproj
@@ -17,4 +17,4 @@
   <ItemGroup>
     <Reference Include="System.Data.DataSetExtensions" Condition="'$(TargetFramework)' == 'net472'" />
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainItemsAssignableTo.cs b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainItemsAssignableTo.cs
index 524608e968..43f3518c2a 100644
--- a/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainItemsAssignableTo.cs
+++ b/Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.ContainItemsAssignableTo.cs
@@ -24,7 +24,7 @@ public void Should_succeed_when_asserting_collection_with_all_items_of_same_type
         }
 
         [Fact]
-        public void Should_fail_when_asserting_collection_with_items_of_different_types_only_contains_item_of_one_type()
+        public void Should_succeed_when_asserting_collection_with_items_of_different_types_contains_item_of_expected_type()
         {
             // Arrange
             var collection = new List<object>
@@ -33,68 +33,50 @@ public void Should_fail_when_asserting_collection_with_items_of_different_types_
                 "2"
             };
 
-            // Act
-            Action act = () => collection.Should().ContainItemsAssignableTo<string>();
-
-            // Assert
-            act.Should().Throw<XunitException>();
+            // Act / Assert
+            collection.Should().ContainItemsAssignableTo<string>();
         }
 
         [Fact]
-        public void When_a_collection_contains_anything_other_than_strings_it_should_throw_and_report_details()
+        public void When_asserting_collection_contains_item_assignable_to_against_null_collection_it_should_throw()
         {
             // Arrange
-            var collection = new List<object>
-            {
-                1,
-                "2"
-            };
+            int[] collection = null;
 
             // Act
-            Action act = () => collection.Should().ContainItemsAssignableTo<string>();
+            Action act = () =>
+            {
+                using var _ = new AssertionScope();
+                collection.Should().ContainItemsAssignableTo<string>("because we want to test the behaviour with a null subject");
+            };
 
             // Assert
             act.Should().Throw<XunitException>().WithMessage(
-                "Expected collection to contain only items of type System.String, but item 1 at index 0 is of type System.Int32.");
+                "Expected collection to contain at least one element assignable to type \"System.String\" because we want to test the behaviour with a null subject, but found <null>.");
         }
 
         [Fact]
-        public void When_a_collection_contains_anything_other_than_strings_it_should_use_the_reason()
+        public void When_a_collection_is_empty_an_exception_should_be_thrown()
         {
             // Arrange
-            var collection = new List<object>
-            {
-                1,
-                "2"
-            };
+            int[] collection = Array.Empty<int>();
 
             // Act
-            Action act = () => collection.Should().ContainItemsAssignableTo<string>(
-                "because we want to test the failure {0}", "message");
+            Action act = () => collection.Should().ContainItemsAssignableTo<int>();
 
             // Assert
-            act.Should().Throw<XunitException>()
-                .WithMessage(
-                    "Expected collection to contain only items of type System.String because we want to test the failure message" +
-                        ", but item 1 at index 0 is of type System.Int32.");
+            act.Should().Throw<XunitException>().WithMessage("Expected collection to contain at least one element assignable to type \"System.Int32\", but found {empty}.");
         }
 
         [Fact]
-        public void When_asserting_collection_contains_item_assignable_to_against_null_collection_it_should_throw()
+        public void Should_throw_exception_when_asserting_collection_for_missing_item_type()
         {
-            // Arrange
-            int[] collection = null;
+            var collection = new object[] { "1", 1.0m };
 
-            // Act
-            Action act = () =>
-            {
-                using var _ = new AssertionScope();
-                collection.Should().ContainItemsAssignableTo<string>("because we want to test the behaviour with a null subject");
-            };
+            Action act = () => collection.Should().ContainItemsAssignableTo<int>();
 
-            // Assert
-            act.Should().Throw<XunitException>().WithMessage(
-                "Expected collection to contain element assignable to type System.String because we want to test the behaviour with a null subject, but found <null>.");
+            act.Should().Throw<XunitException>()
+                .WithMessage("Expected collection to contain at least one element assignable to type \"System.Int32\", but found {System.String, System.Decimal}.");
         }
 
         #endregion
diff --git a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.cs
index a60f261f50..86c451cf7d 100644
--- a/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Collections/GenericDictionaryAssertionSpecs.cs
@@ -874,7 +874,7 @@ public void When_asserting_dictionary_with_items_is_not_empty_it_should_succeed(
             dictionary.Should().NotBeEmpty();
         }
 
-        #if !NET5_0_OR_GREATER
+#if !NET5_0_OR_GREATER
 
         [Fact]
         public void When_asserting_dictionary_with_items_is_not_empty_it_should_enumerate_the_dictionary_only_once()
@@ -889,7 +889,7 @@ public void When_asserting_dictionary_with_items_is_not_empty_it_should_enumerat
             trackingDictionary.Enumerator.LoopCount.Should().Be(1);
         }
 
-        #endif
+#endif
 
         [Fact]
         public void When_asserting_dictionary_without_items_is_not_empty_it_should_fail()
@@ -2638,6 +2638,15 @@ public void When_a_dictionary_like_collection_contains_the_expected_key_it_shoul
             act.Should().NotThrow();
         }
 
+        [Theory]
+        [MemberData(nameof(SingleDictionaryData))]
+        public void When_a_dictionary_like_collection_contains_the_expected_key_and_value_it_should_succeed<T>(T subject)
+            where T : IEnumerable<KeyValuePair<int, int>>
+        {
+            // Assert
+            subject.Should().Contain(1, 42);
+        }
+
         [Theory]
         [MemberData(nameof(SingleDictionaryData))]
         public void When_a_dictionary_like_collection_contains_the_expected_value_it_should_succeed<T>(T subject)
@@ -2675,6 +2684,19 @@ private static object[] Dictionaries()
             };
         }
 
+        [Fact]
+        public void When_a_dictionary_like_collection_contains_the_default_key_it_should_succeed()
+        {
+            // Arrange
+            var subject = new List<KeyValuePair<int, int>>() { new(0, 0) };
+
+            // Act
+            Action act = () => subject.Should().Contain(0, 0);
+
+            // Assert
+            act.Should().NotThrow();
+        }
+
         /// <summary>
         /// This class only implements <see cref="IReadOnlyDictionary{TKey, TValue}"/>,
         /// as <see cref="ReadOnlyDictionary{TKey, TValue}"/> also implements <see cref="IDictionary{TKey, TValue}"/>.
diff --git a/Tests/FluentAssertions.Specs/Events/EventAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Events/EventAssertionSpecs.cs
index 432996e070..f07bc28c78 100644
--- a/Tests/FluentAssertions.Specs/Events/EventAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Events/EventAssertionSpecs.cs
@@ -411,6 +411,28 @@ public void When_constraints_are_specified_it_should_filter_the_events_based_on_
                 .Which.PropertyName.Should().Be("Boo");
         }
 
+        [Fact]
+        public void When_events_are_raised_regardless_of_time_tick_it_should_return_by_invokation_order()
+        {
+            // Arrange
+            var observable = new TestEventRaisingInOrder();
+            var utcNow = 11.January(2022).At(12, 00).AsUtc();
+            using var monitor = observable.Monitor(() => utcNow);
+
+            // Act
+            observable.RaiseAllEvents();
+
+            // Assert
+            monitor.OccurredEvents[0].EventName.Should().Be(nameof(TestEventRaisingInOrder.InterfaceEvent));
+            monitor.OccurredEvents[0].Sequence.Should().Be(0);
+
+            monitor.OccurredEvents[1].EventName.Should().Be(nameof(TestEventRaisingInOrder.Interface2Event));
+            monitor.OccurredEvents[1].Sequence.Should().Be(1);
+
+            monitor.OccurredEvents[2].EventName.Should().Be(nameof(TestEventRaisingInOrder.Interface3Event));
+            monitor.OccurredEvents[2].Sequence.Should().Be(2);
+        }
+
         #endregion
 
         #region Should(Not)RaisePropertyChanged events
@@ -817,6 +839,22 @@ public void RaiseBothEvents()
             }
         }
 
+        private class TestEventRaisingInOrder : IEventRaisingInterface, IEventRaisingInterface2, IEventRaisingInterface3
+        {
+            public event EventHandler Interface3Event;
+
+            public event EventHandler Interface2Event;
+
+            public event EventHandler InterfaceEvent;
+
+            public void RaiseAllEvents()
+            {
+                InterfaceEvent?.Invoke(this, EventArgs.Empty);
+                Interface2Event?.Invoke(this, EventArgs.Empty);
+                Interface3Event?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
         public interface IEventRaisingInterface
         {
             event EventHandler InterfaceEvent;
@@ -827,6 +865,11 @@ public interface IEventRaisingInterface2
             event EventHandler Interface2Event;
         }
 
+        public interface IEventRaisingInterface3
+        {
+            event EventHandler Interface3Event;
+        }
+
         public interface IInheritsEventRaisingInterface : IEventRaisingInterface
         {
         }
diff --git a/Tests/FluentAssertions.Specs/Exceptions/AsyncFunctionExceptionAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Exceptions/AsyncFunctionExceptionAssertionSpecs.cs
index 4c2558ffb5..f454271169 100644
--- a/Tests/FluentAssertions.Specs/Exceptions/AsyncFunctionExceptionAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Exceptions/AsyncFunctionExceptionAssertionSpecs.cs
@@ -832,6 +832,21 @@ public async Task When_async_method_throws_the_expected_inner_exception_it_shoul
             await action.Should().NotThrowAsync();
         }
 
+        [Fact]
+        public async Task When_async_method_throws_the_expected_inner_exception_from_argument_it_should_succeed()
+        {
+            // Arrange
+            Func<Task> task = () => Throw.Async(new AggregateException(new InvalidOperationException()));
+
+            // Act
+            Func<Task> action = () => task
+                .Should().ThrowAsync<AggregateException>()
+                .WithInnerException(typeof(InvalidOperationException));
+
+            // Assert
+            await action.Should().NotThrowAsync();
+        }
+
         [Fact]
         public async Task When_async_method_throws_the_expected_inner_exception_exactly_it_should_succeed()
         {
@@ -847,6 +862,21 @@ public async Task When_async_method_throws_the_expected_inner_exception_exactly_
             await action.Should().NotThrowAsync();
         }
 
+        [Fact]
+        public async Task When_async_method_throws_the_expected_inner_exception_exactly_defined_in_arguments_it_should_succeed()
+        {
+            // Arrange
+            Func<Task> task = () => Throw.Async(new AggregateException(new ArgumentException()));
+
+            // Act
+            Func<Task> action = () => task
+                .Should().ThrowAsync<AggregateException>()
+                .WithInnerExceptionExactly(typeof(ArgumentException));
+
+            // Assert
+            await action.Should().NotThrowAsync();
+        }
+
         [Fact]
         public async Task When_async_method_throws_aggregate_exception_containing_expected_exception_it_should_succeed()
         {
@@ -890,6 +920,21 @@ public async Task When_async_method_does_not_throw_the_expected_inner_exception_
             await action.Should().ThrowAsync<XunitException>().WithMessage("*InvalidOperation*Argument*");
         }
 
+        [Fact]
+        public async Task When_async_method_does_not_throw_the_expected_inner_exception_from_argument_it_should_fail()
+        {
+            // Arrange
+            Func<Task> task = () => Throw.Async(new AggregateException(new ArgumentException()));
+
+            // Act
+            Func<Task> action = () => task
+                .Should().ThrowAsync<AggregateException>()
+                .WithInnerException(typeof(InvalidOperationException));
+
+            // Assert
+            await action.Should().ThrowAsync<XunitException>().WithMessage("*InvalidOperation*Argument*");
+        }
+
         [Fact]
         public async Task When_async_method_does_not_throw_the_expected_inner_exception_exactly_it_should_fail()
         {
@@ -905,6 +950,22 @@ public async Task When_async_method_does_not_throw_the_expected_inner_exception_
             await action.Should().ThrowAsync<XunitException>().WithMessage("*ArgumentException*ArgumentNullException*");
         }
 
+        [Fact]
+        public async Task
+            When_async_method_does_not_throw_the_expected_inner_exception_exactly_defined_in_arguments_it_should_fail()
+        {
+            // Arrange
+            Func<Task> task = () => Throw.Async(new AggregateException(new ArgumentNullException()));
+
+            // Act
+            Func<Task> action = () => task
+                .Should().ThrowAsync<AggregateException>()
+                .WithInnerExceptionExactly(typeof(ArgumentException));
+
+            // Assert
+            await action.Should().ThrowAsync<XunitException>().WithMessage("*ArgumentException*ArgumentNullException*");
+        }
+
         [Fact]
         public async Task When_async_method_does_not_throw_the_expected_exception_it_should_fail()
         {
diff --git a/Tests/FluentAssertions.Specs/Exceptions/ExceptionAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Exceptions/ExceptionAssertionSpecs.cs
index 36085cbe62..8562dc40e2 100644
--- a/Tests/FluentAssertions.Specs/Exceptions/ExceptionAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Exceptions/ExceptionAssertionSpecs.cs
@@ -409,6 +409,22 @@ public void When_asserting_with_an_aggregate_exception_type_the_asserts_should_o
                 .WithMessage("Inner Message");
         }
 
+        [Fact]
+        public void When_asserting_with_an_aggregate_exception_and_inner_exception_type_from_argument_the_asserts_should_occur_against_the_aggregate_exception()
+        {
+            // Arrange
+            Does testSubject = Does.Throw(new AggregateException("Outer Message", new Exception("Inner Message")));
+
+            // Act
+            Action act = testSubject.Do;
+
+            // Assert
+            act.Should().Throw<AggregateException>()
+                .WithMessage("Outer Message*")
+                .WithInnerException(typeof(Exception))
+                .WithMessage("Inner Message");
+        }
+
         #endregion
 
         #region Inner Exceptions
@@ -426,6 +442,32 @@ public void When_subject_throws_an_exception_with_the_expected_inner_exception_i
                 .WithInnerException<ArgumentException>();
         }
 
+        [Fact]
+        public void When_subject_throws_an_exception_with_the_expected_inner_base_exception_it_should_not_do_anything()
+        {
+            // Arrange
+            Does testSubject = Does.Throw(new Exception("", new ArgumentNullException()));
+
+            // Act / Assert
+            testSubject
+                .Invoking(x => x.Do())
+                .Should().Throw<Exception>()
+                .WithInnerException<ArgumentException>();
+        }
+
+        [Fact]
+        public void When_subject_throws_an_exception_with_the_expected_inner_exception_from_argument_it_should_not_do_anything()
+        {
+            // Arrange
+            Does testSubject = Does.Throw(new Exception("", new ArgumentException()));
+
+            // Act / Assert
+            testSubject
+                .Invoking(x => x.Do())
+                .Should().Throw<Exception>()
+                .WithInnerException(typeof(ArgumentException));
+        }
+
         [Fact]
         public void WithInnerExceptionExactly_no_parameters_when_subject_throws_subclass_of_expected_inner_exception_it_should_throw_with_clear_description()
         {
@@ -487,6 +529,53 @@ public void WithInnerExceptionExactly_when_subject_throws_subclass_of_expected_i
             }
         }
 
+        [Fact]
+        public void WithInnerExceptionExactly_with_type_exception_when_subject_throws_expected_inner_exception_it_should_not_do_anything()
+        {
+            // Arrange
+            Action act = () => throw new BadImageFormatException("", new ArgumentNullException());
+
+            // Act / Assert
+            act.Should().Throw<BadImageFormatException>()
+                .WithInnerExceptionExactly(typeof(ArgumentNullException), "because {0} should do just that", "the action");
+        }
+
+        [Fact]
+        public void WithInnerExceptionExactly_with_type_exception_no_parameters_when_subject_throws_expected_inner_exception_it_should_not_do_anything()
+        {
+            // Arrange
+            Action act = () => throw new BadImageFormatException("", new ArgumentNullException());
+
+            // Act / Assert
+            act.Should().Throw<BadImageFormatException>()
+                .WithInnerExceptionExactly(typeof(ArgumentNullException));
+        }
+
+        [Fact]
+        public void WithInnerExceptionExactly_with_type_exception_when_subject_throws_subclass_of_expected_inner_exception_it_should_throw_with_clear_description()
+        {
+            // Arrange
+            var innerException = new ArgumentNullException();
+
+            Action act = () => throw new BadImageFormatException("", innerException);
+
+            try
+            {
+                // Act
+                act.Should().Throw<BadImageFormatException>()
+                    .WithInnerExceptionExactly(typeof(ArgumentException), "because {0} should do just that", "the action");
+
+                throw new XunitException("This point should not be reached.");
+            }
+            catch (XunitException ex)
+            {
+                // Assert
+                var expectedMessage = BuildExpectedMessageForWithInnerExceptionExactly("Expected inner System.ArgumentException because the action should do just that, but found System.ArgumentNullException with message", innerException.Message);
+
+                ex.Message.Should().Be(expectedMessage);
+            }
+        }
+
         [Fact]
         public void WithInnerExceptionExactly_when_subject_throws_expected_inner_exception_it_should_not_do_anything()
         {
@@ -585,6 +674,20 @@ public void When_an_inner_exception_matches_exactly_it_should_allow_chaining_mor
                 .Where(i => i.Message == "InnerMessage");
         }
 
+        [Fact]
+        public void When_an_inner_exception_matches_exactly_it_should_allow_chaining_more_asserts_on_that_exception_type_from_argument()
+        {
+            // Act
+            Action act = () =>
+                throw new ArgumentException("OuterMessage", new InvalidOperationException("InnerMessage"));
+
+            // Assert
+            act
+                .Should().ThrowExactly<ArgumentException>()
+                .WithInnerExceptionExactly(typeof(InvalidOperationException))
+                .Where(i => i.Message == "InnerMessage");
+        }
+
         [Fact]
         public void When_injecting_a_null_predicate_it_should_throw()
         {
diff --git a/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs b/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs
index 96098ebde3..a539f4f942 100644
--- a/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Execution/CallerIdentifierSpecs.cs
@@ -452,6 +452,22 @@ public void When_the_method_has_Should_prefix_it_should_read_whole_method()
             act.Should().Throw<XunitException>()
                 .WithMessage("Expected foo.ShouldReturnSomeBool() to be false*");
         }
+
+        [UIFact]
+        public async Task Caller_identification_should_also_work_for_statements_following_async_code()
+        {
+            // Arrange
+            const string someText = "Hello";
+            Func<Task> task = async () => await Task.Yield();
+
+            // Act
+            await task.Should().NotThrowAsync();
+            Action act = () => someText.Should().Be("Hi");
+
+            // Assert
+            act.Should().Throw<XunitException>()
+                .WithMessage("*someText*", "it should capture the variable name");
+        }
     }
 
     [SuppressMessage("The name of a C# element does not begin with an upper-case letter", "SA1300")]
diff --git a/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
index df431da601..d2a73ae8ae 100644
--- a/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Execution/GivenSelectorSpecs.cs
@@ -10,7 +10,7 @@ public class GivenSelectorSpecs
         [Fact]
         public void A_consecutive_subject_should_be_selected()
         {
-            // Arange
+            // Arrange
             string value = string.Empty;
 
             // Act
@@ -26,7 +26,7 @@ public void A_consecutive_subject_should_be_selected()
         [Fact]
         public void After_a_failed_condition_a_consecutive_subject_should_be_ignored()
         {
-            // Arange
+            // Arrange
             string value = string.Empty;
 
             // Act
diff --git a/Tests/FluentAssertions.Specs/FluentAssertions.Specs.csproj b/Tests/FluentAssertions.Specs/FluentAssertions.Specs.csproj
index 5c7e276c02..9845cf5918 100644
--- a/Tests/FluentAssertions.Specs/FluentAssertions.Specs.csproj
+++ b/Tests/FluentAssertions.Specs/FluentAssertions.Specs.csproj
@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <!-- To reduce build times, we only enable analyzers for the newest TFM -->
   <PropertyGroup>
     <TargetFrameworks>net47;net5.0;netcoreapp2.0;netcoreapp2.1;netcoreapp3.0</TargetFrameworks>
     <LangVersion>9.0</LangVersion>
@@ -8,24 +9,24 @@
     <IsPackable>false</IsPackable>
     <CodeAnalysisRuleSet>..\..\TestRules.ruleset</CodeAnalysisRuleSet>
     <!-- https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA0001.md -->
-    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
+    <DocumentationFile Condition="'$(TargetFramework)' == 'net5.0'">$(OutputPath)$(AssemblyName).xml</DocumentationFile>
     <NoWarn>$(NoWarn),IDE0052,1573,1591,1712</NoWarn>
     <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <DebugType>full</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' != 'net5.0'">
+    <RunAnalyzersDuringBuild>false</RunAnalyzersDuringBuild>
+    <RunAnalyzersDuringLiveAnalysis>false</RunAnalyzersDuringLiveAnalysis>
+    <RunAnalyzers>false</RunAnalyzers>
   </PropertyGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.0' ">
     <Compile Remove="Events\*.cs" />
   </ItemGroup>
 
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <DebugType>full</DebugType>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <DebugType>full</DebugType>
-  </PropertyGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net47'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net47'">
     <!--
       (SRCU = System.Runtime.CompilerServices.Unsafe)
       FluentAssertions.csproj depends on SRCU 4.5.0 (AssemblyVersion 4.0.4.0)
@@ -40,14 +41,14 @@
     </PackageReference>
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.0'">
     <PackageReference Include="xunit.runner.visualstudio" Version="[2.4.1]">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.1' Or '$(TargetFramework)' == 'netcoreapp3.0' or '$(TargetFramework)' == 'net5.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1' Or '$(TargetFramework)' == 'netcoreapp3.0' or '$(TargetFramework)' == 'net5.0'">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
@@ -63,7 +64,7 @@
     <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net5.0'">
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.3.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs
new file mode 100644
index 0000000000..d0513cacc7
--- /dev/null
+++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs
@@ -0,0 +1,271 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using Xunit;
+using Xunit.Sdk;
+
+namespace FluentAssertions.Specs.Primitives
+{
+    public class HttpResponseMessageAssertionSpecs
+    {
+        [Theory]
+        [InlineData(HttpStatusCode.OK)]
+        [InlineData(HttpStatusCode.Accepted)]
+        public void Should_succeed_when_status_code_is_successful(HttpStatusCode statusCodeOfResponse)
+        {
+            // Arrange
+            var testee = new HttpResponseMessage(statusCodeOfResponse);
+
+            // Act / Assert
+            testee.Should().BeSuccessful();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_error_is_successful()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.Gone).Should()
+                .BeSuccessful("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but found HttpStatusCode.Gone {value: 410}.");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_success_but_response_is_null()
+        {
+            // Arrange
+            Action action = () =>
+                ((HttpResponseMessage)null).Should().BeSuccessful("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Theory]
+        [InlineData(HttpStatusCode.Moved)]
+        public void Should_succeed_when_status_code_is_redirect(HttpStatusCode statusCodeOfResponse)
+        {
+            // Arrange
+            var testee = new HttpResponseMessage(statusCodeOfResponse);
+
+            // Act / Assert
+            testee.Should().BeRedirection();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_error_is_redirection()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.Gone).Should()
+                .BeRedirection("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but found HttpStatusCode.Gone {value: 410}.");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_redirect_but_response_is_null()
+        {
+            // Arrange
+            Action action = () =>
+                ((HttpResponseMessage)null).Should().BeRedirection("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Theory]
+        [InlineData(HttpStatusCode.Gone)]
+        [InlineData(HttpStatusCode.BadRequest)]
+        public void Should_succeed_when_status_code_is_client_error(HttpStatusCode statusCodeOfResponse)
+        {
+            // Arrange
+            var testee = new HttpResponseMessage(statusCodeOfResponse);
+
+            // Act / Assert
+            testee.Should().HaveClientError();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_success_is_client_error()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should()
+                .HaveClientError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_client_error_but_response_is_null()
+        {
+            // Arrange
+            Action action = () =>
+                ((HttpResponseMessage)null).Should().HaveClientError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Theory]
+        [InlineData(HttpStatusCode.InternalServerError)]
+        public void Should_succeed_when_status_code_is_server_error(HttpStatusCode statusCodeOfResponse)
+        {
+            // Arrange
+            var testee = new HttpResponseMessage(statusCodeOfResponse);
+
+            // Act / Assert
+            testee.Should().HaveServerError();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_success_is_server_error()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should()
+                .HaveServerError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_server_error_but_response_is_null()
+        {
+            // Arrange
+            Action action = () =>
+                ((HttpResponseMessage)null).Should().HaveServerError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Theory]
+        [InlineData(HttpStatusCode.BadRequest)]
+        [InlineData(HttpStatusCode.InternalServerError)]
+        public void Should_succeed_when_status_code_is_error(HttpStatusCode statusCodeOfResponse)
+        {
+            // Arrange
+            var testee = new HttpResponseMessage(statusCodeOfResponse);
+
+            // Act / Assert
+            testee.Should().HaveError();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_success_is_error()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should()
+                .HaveError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be an error because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_error_but_response_is_null()
+        {
+            // Arrange
+            Action action = () =>
+                ((HttpResponseMessage)null).Should().HaveError("because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be an error because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Fact]
+        public void Should_succeed_when_status_code_to_be_equal_to_the_same_value()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.OK);
+
+            // Act / Assert
+            action.Should().NotThrow();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_value_to_be_equal_to_a_different_value()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone,
+                "because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.*");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_certain_status_code_but_response_is_null()
+        {
+            // Arrange
+            Action action = () => ((HttpResponseMessage)null).Should()
+                .HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+
+        [Fact]
+        public void Should_succeed_when_status_code_value_not_to_be_equal_to_the_same_value()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.Gone);
+
+            // Act / Assert
+            action.Should().NotThrow();
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_status_code_value_not_to_be_equal_to_a_different_value()
+        {
+            // Arrange
+            Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK,
+                "because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode not to be HttpStatusCode.OK {value: 200} because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.*");
+        }
+
+        [Fact]
+        public void Should_fail_with_descriptive_message_when_asserting_against_certain_status_code_but_response_is_null()
+        {
+            // Arrange
+            Action action = () => ((HttpResponseMessage)null).Should()
+                .NotHaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message");
+
+            // Act / Assert
+            action.Should().Throw<XunitException>()
+                .WithMessage(
+                    "Expected HttpStatusCode not to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was <null>.");
+        }
+    }
+}
diff --git a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
index 6ccd38ca5e..b5bbaebb70 100644
--- a/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/AssemblyAssertionSpecs.cs
@@ -63,7 +63,7 @@ public void When_subject_is_null_not_reference_should_fail()
             Assembly assemblyB = FindAssembly.Containing<ClassB>();
 
             // Act
-            Action act = () => assemblyA.Should().NotReference(assemblyB, "we want to to test the failure {0}", "message");
+            Action act = () => assemblyA.Should().NotReference(assemblyB, "we want to test the failure {0}", "message");
 
             // Assert
             act.Should().Throw<XunitException>()
@@ -140,7 +140,7 @@ public void When_subject_is_null_reference_should_fail()
             Assembly assemblyB = FindAssembly.Containing<ClassB>();
 
             // Act
-            Action act = () => assemblyA.Should().Reference(assemblyB, "we want to to test the failure {0}", "message");
+            Action act = () => assemblyA.Should().Reference(assemblyB, "we want to test the failure {0}", "message");
 
             // Assert
             act.Should().Throw<XunitException>()
@@ -207,7 +207,7 @@ public void When_subject_is_null_define_type_should_fail()
             // Act
             Action act = () =>
                 thisAssembly.Should().DefineType(GetType().Namespace, "WellKnownClassWithAttribute",
-                    "we want to to test the failure {0}", "message");
+                    "we want to test the failure {0}", "message");
 
             // Assert
             act.Should().Throw<XunitException>()
diff --git a/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs b/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
index 5b7d12ff1d..64c291e032 100644
--- a/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Specialized/ExecutionTimeAssertionsSpecs.cs
@@ -163,7 +163,7 @@ public void When_the_execution_time_of_an_async_action_is_less_than_a_limit_it_s
             Func<Task> someAction = () => Task.Delay(TimeSpan.FromMilliseconds(100));
 
             // Act
-            Action act = () => someAction.ExecutionTime().Should().BeLessThan(2.Seconds());
+            Action act = () => someAction.ExecutionTime().Should().BeLessThan(20.Seconds());
 
             // Assert
             act.Should().NotThrow();
diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs
index f32f2c9911..e56e41f242 100644
--- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs
+++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs
@@ -332,6 +332,34 @@ public void When_selecting_methods_that_are_not_virtual_it_should_only_return_th
                 .And.NotContain(m => m.Name == "PublicVirtualVoidMethodWithAttribute")
                 .And.NotContain(m => m.Name == "ProtectedVirtualVoidMethodWithAttribute");
         }
+        
+        [Fact]
+        public void When_selecting_methods_that_are_static_it_should_only_return_the_applicable_methods()
+        {
+            // Arrange
+            Type type = typeof(TestClassForMethodSelectorWithStaticAndNonStaticMethod);
+
+            // Act
+            MethodInfo[] methods = type.Methods().ThatAreStatic().ToArray();
+
+            // Assert
+            methods.Should().ContainSingle()
+                .Which.Name.Should().Be("PublicStaticMethod");
+        }
+
+        [Fact]
+        public void When_selecting_methods_that_are_not_static_it_should_only_return_the_applicable_methods()
+        {
+            // Arrange
+            Type type = typeof(TestClassForMethodSelectorWithStaticAndNonStaticMethod);
+
+            // Act
+            MethodInfo[] methods = type.Methods().ThatAreNotStatic().ToArray();
+
+            // Assert
+            methods.Should().ContainSingle()
+                .Which.Name.Should().Be("PublicNonStaticMethod");
+        }
 
         [Fact]
         public void When_selecting_methods_not_decorated_with_or_inheriting_a_noninheritable_attribute_it_should_only_return_the_applicable_methods()
@@ -435,6 +463,13 @@ internal class TestClassForMethodSelectorWithAsyncAndNonAsyncMethod
         public Task PublicNonAsyncMethod() => Task.CompletedTask;
     }
 
+    internal class TestClassForMethodSelectorWithStaticAndNonStaticMethod
+    {
+        public static void PublicStaticMethod() { }
+
+        public void PublicNonStaticMethod() { }
+    }
+
     internal class TestClassForMethodReturnTypesSelector
     {
         public void SomeMethod() { }
diff --git a/Tests/UWP.Specs/App.xaml b/Tests/UWP.Specs/App.xaml
new file mode 100644
index 0000000000..0d5a0c69ec
--- /dev/null
+++ b/Tests/UWP.Specs/App.xaml
@@ -0,0 +1,4 @@
+<Application
+    x:Class="UWP.Specs.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" />
diff --git a/Tests/UWP.Specs/App.xaml.cs b/Tests/UWP.Specs/App.xaml.cs
new file mode 100644
index 0000000000..a96acf33e0
--- /dev/null
+++ b/Tests/UWP.Specs/App.xaml.cs
@@ -0,0 +1,37 @@
+using System;
+using Microsoft.VisualStudio.TestPlatform.TestExecutor;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Navigation;
+
+namespace UWP.Specs
+{
+    internal sealed partial class App : Application
+    {
+        public App()
+        {
+            InitializeComponent();
+            Suspending += OnSuspending;
+        }
+
+        protected override void OnLaunched(LaunchActivatedEventArgs e)
+        {
+            if (Window.Current.Content is not Frame rootFrame)
+            {
+                rootFrame = new Frame();
+                rootFrame.NavigationFailed += OnNavigationFailed;
+                Window.Current.Content = rootFrame;
+            }
+
+            UnitTestClient.Run(e.Arguments);
+        }
+
+        private void OnNavigationFailed(object sender, NavigationFailedEventArgs e) =>
+            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
+
+        private void OnSuspending(object sender, SuspendingEventArgs e) =>
+            e.SuspendingOperation.GetDeferral().Complete();
+    }
+}
diff --git a/Tests/UWP.Specs/Assets/LockScreenLogo.scale-200.png b/Tests/UWP.Specs/Assets/LockScreenLogo.scale-200.png
new file mode 100644
index 0000000000..735f57adb5
Binary files /dev/null and b/Tests/UWP.Specs/Assets/LockScreenLogo.scale-200.png differ
diff --git a/Tests/UWP.Specs/Assets/SplashScreen.scale-200.png b/Tests/UWP.Specs/Assets/SplashScreen.scale-200.png
new file mode 100644
index 0000000000..023e7f1fed
Binary files /dev/null and b/Tests/UWP.Specs/Assets/SplashScreen.scale-200.png differ
diff --git a/Tests/UWP.Specs/Assets/Square150x150Logo.scale-200.png b/Tests/UWP.Specs/Assets/Square150x150Logo.scale-200.png
new file mode 100644
index 0000000000..af49fec1a5
Binary files /dev/null and b/Tests/UWP.Specs/Assets/Square150x150Logo.scale-200.png differ
diff --git a/Tests/UWP.Specs/Assets/Square44x44Logo.scale-200.png b/Tests/UWP.Specs/Assets/Square44x44Logo.scale-200.png
new file mode 100644
index 0000000000..ce342a2ec8
Binary files /dev/null and b/Tests/UWP.Specs/Assets/Square44x44Logo.scale-200.png differ
diff --git a/Tests/UWP.Specs/Assets/Square44x44Logo.targetsize-24_altform-unplated.png b/Tests/UWP.Specs/Assets/Square44x44Logo.targetsize-24_altform-unplated.png
new file mode 100644
index 0000000000..f6c02ce97e
Binary files /dev/null and b/Tests/UWP.Specs/Assets/Square44x44Logo.targetsize-24_altform-unplated.png differ
diff --git a/Tests/UWP.Specs/Assets/StoreLogo.png b/Tests/UWP.Specs/Assets/StoreLogo.png
new file mode 100644
index 0000000000..7385b56c0e
Binary files /dev/null and b/Tests/UWP.Specs/Assets/StoreLogo.png differ
diff --git a/Tests/UWP.Specs/Assets/Wide310x150Logo.scale-200.png b/Tests/UWP.Specs/Assets/Wide310x150Logo.scale-200.png
new file mode 100644
index 0000000000..288995b397
Binary files /dev/null and b/Tests/UWP.Specs/Assets/Wide310x150Logo.scale-200.png differ
diff --git a/Tests/UWP.Specs/Package.appxmanifest b/Tests/UWP.Specs/Package.appxmanifest
new file mode 100644
index 0000000000..2a32c3ad91
--- /dev/null
+++ b/Tests/UWP.Specs/Package.appxmanifest
@@ -0,0 +1,25 @@
+<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest" xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" IgnorableNamespaces="uap mp">
+  <Identity Name="17e912aa-d754-4239-acf6-e6863cff80b9" Publisher="CN=FluentAssertions" Version="1.0.0.0" />
+  <mp:PhoneIdentity PhoneProductId="17e912aa-d754-4239-acf6-e6863cff80b9" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
+  <Properties>
+    <DisplayName>UWP.Specs</DisplayName>
+    <PublisherDisplayName>FluentAssertions</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
+  </Dependencies>
+  <Resources>
+    <Resource Language="x-generate" />
+  </Resources>
+  <Applications>
+    <Application Id="vstest.executionengine.universal.App" Executable="$targetnametoken$.exe" EntryPoint="UWP.Specs.App">
+      <uap:VisualElements DisplayName="UWP.Specs" Square150x150Logo="Assets\Square150x150Logo.png" Square44x44Logo="Assets\Square44x44Logo.png" Description="UWP.Specs" BackgroundColor="transparent"> 
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+  <Capabilities>
+  </Capabilities>
+</Package>
\ No newline at end of file
diff --git a/Tests/UWP.Specs/Properties/AssemblyInfo.cs b/Tests/UWP.Specs/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000000..f7cdff3769
--- /dev/null
+++ b/Tests/UWP.Specs/Properties/AssemblyInfo.cs
@@ -0,0 +1,17 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("UWP.Specs")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("UWP.Specs")]
+[assembly: AssemblyCopyright("Copyright ©  2022")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyMetadata("TargetPlatform","UAP")]
+
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: ComVisible(false)]
\ No newline at end of file
diff --git a/Tests/UWP.Specs/Properties/Default.rd.xml b/Tests/UWP.Specs/Properties/Default.rd.xml
new file mode 100644
index 0000000000..f3d2603c7e
--- /dev/null
+++ b/Tests/UWP.Specs/Properties/Default.rd.xml
@@ -0,0 +1,5 @@
+<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
+  <Application>
+    <Assembly Name="*Application*" Dynamic="Required All" />
+  </Application>
+</Directives>
\ No newline at end of file
diff --git a/Tests/UWP.Specs/UWP.Specs.csproj b/Tests/UWP.Specs/UWP.Specs.csproj
new file mode 100644
index 0000000000..45a4d06107
--- /dev/null
+++ b/Tests/UWP.Specs/UWP.Specs.csproj
@@ -0,0 +1,100 @@
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProjectGuid>{08087654-2C32-4818-95E4-45362373441D}</ProjectGuid>
+    <OutputType>AppContainerExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>UWP.Specs</RootNamespace>
+    <AssemblyName>UWP.Specs</AssemblyName>
+    <LangVersion>9.0</LangVersion>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion>10.0.19041.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.18362.0</TargetPlatformMinVersion>
+    <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <UnitTestPlatformVersion Condition="'$(UnitTestPlatformVersion)' == ''">$(VisualStudioVersion)</UnitTestPlatformVersion>
+    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <NoWarn>$(NoWarn);2008</NoWarn>
+    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
+  </PropertyGroup>
+  <ItemGroup>
+    <SDKReference Include="TestPlatform.Universal, Version=$(UnitTestPlatformVersion)" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="UwpSpecs.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+  </ItemGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Properties\Default.rd.xml" />
+    <Content Include="Assets\LockScreenLogo.scale-200.png" />
+    <Content Include="Assets\SplashScreen.scale-200.png" />
+    <Content Include="Assets\Square150x150Logo.scale-200.png" />
+    <Content Include="Assets\Square44x44Logo.scale-200.png" />
+    <Content Include="Assets\Square44x44Logo.targetsize-24_altform-unplated.png" />
+    <Content Include="Assets\StoreLogo.png" />
+    <Content Include="Assets\Wide310x150Logo.scale-200.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Src\FluentAssertions\FluentAssertions.csproj">
+      <HintPath>Src\FluentAssertions\bin\$(Configuration)\netstandard2.0\FluentAssertions.dll</HintPath>
+      <Project>{34E3713D-C02F-4868-BBE7-47DAD2C7F03D}</Project>
+      <Name>FluentAssertions</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
+      <Version>6.2.13</Version>
+    </PackageReference>
+    <PackageReference Include="MSTest.TestAdapter">
+      <Version>2.2.8</Version>
+    </PackageReference>
+    <PackageReference Include="MSTest.TestFramework">
+      <Version>2.2.8</Version>
+    </PackageReference>
+    <PackageReference Include="System.Xml.XPath.XmlDocument">
+      <Version>4.3.0</Version>
+    </PackageReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/Tests/UWP.Specs/UwpSpecs.cs b/Tests/UWP.Specs/UwpSpecs.cs
new file mode 100644
index 0000000000..07b6878949
--- /dev/null
+++ b/Tests/UWP.Specs/UwpSpecs.cs
@@ -0,0 +1,23 @@
+using System;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UWP.Specs
+{
+    [TestClass]
+    public class UwpSpecs
+    {
+        [TestMethod]
+        public void Determining_caller_identity_should_not_throw_for_native_programs()
+        {
+            // Arrange
+            Action someAction = () => throw new Exception();
+
+            // Act
+            Action act = () => someAction.Should().NotThrow();
+
+            // Assert
+            act.Should().Throw<AssertFailedException>();
+        }
+    }
+}
diff --git a/build.ps1 b/build.ps1
index 7403af110e..b3a8824d33 100644
--- a/build.ps1
+++ b/build.ps1
@@ -14,15 +14,16 @@ $PSScriptRoot = Split-Path $MyInvocation.MyCommand.Path -Parent
 ###########################################################################
 
 $BuildProjectFile = "$PSScriptRoot\build\_build.csproj"
-$TempDirectory = "$PSScriptRoot\\.nuke\temp"
+$TempDirectory = "$PSScriptRoot\.nuke\temp"
 
-$DotNetGlobalFile = "$PSScriptRoot\\global.json"
+$DotNetGlobalFile = "$PSScriptRoot\global.json"
 $DotNetInstallUrl = "https://dot.net/v1/dotnet-install.ps1"
 $DotNetChannel = "Current"
 
 $env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE = 1
 $env:DOTNET_CLI_TELEMETRY_OPTOUT = 1
 $env:DOTNET_MULTILEVEL_LOOKUP = 0
+$env:DOTNET_ROLL_FORWARD = "Major"
 $env:NUKE_TELEMETRY_OPTOUT = 1
 
 ###########################################################################
@@ -34,9 +35,18 @@ function ExecSafe([scriptblock] $cmd) {
     if ($LASTEXITCODE) { exit $LASTEXITCODE }
 }
 
+# Print environment variables
+# WARNING: Make sure that secrets are actually scrambled in build log
+# Get-Item -Path Env:* | Sort-Object -Property Name | ForEach-Object {"{0}={1}" -f $_.Name,$_.Value}
+
+# Check if any dotnet is installed
+if ($null -ne (Get-Command "dotnet" -ErrorAction SilentlyContinue)) {
+    ExecSafe { & dotnet --info }
+}
+
 # If dotnet CLI is installed globally and it matches requested version, use for execution
 if ($null -ne (Get-Command "dotnet" -ErrorAction SilentlyContinue) -and `
-     $(dotnet --version) -and $LASTEXITCODE -eq 0) {
+    $(dotnet --version) -and $LASTEXITCODE -eq 0) {
     $env:DOTNET_EXE = (Get-Command "dotnet").Path
 }
 else {
@@ -66,5 +76,5 @@ else {
 
 Write-Output "Microsoft (R) .NET Core SDK version $(& $env:DOTNET_EXE --version)"
 
-ExecSafe { & $env:DOTNET_EXE build $BuildProjectFile /nodeReuse:false /p:UseSharedCompilation=false -nologo -clp:NoSummary --verbosity quiet }
+ExecSafe { & $env:DOTNET_EXE build $BuildProjectFile /nodeReuse:false /p:UseSharedCompilation=false -nologo -clp:NoSummary }
 ExecSafe { & $env:DOTNET_EXE run --project $BuildProjectFile --no-build -- $BuildArguments }
diff --git a/build.sh b/build.sh
index 435dac52bc..f5bf05e1c4 100755
--- a/build.sh
+++ b/build.sh
@@ -10,15 +10,16 @@ SCRIPT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd)
 ###########################################################################
 
 BUILD_PROJECT_FILE="$SCRIPT_DIR/Build/_build.csproj"
-TEMP_DIRECTORY="$SCRIPT_DIR//.nuke/temp"
+TEMP_DIRECTORY="$SCRIPT_DIR/.nuke/temp"
 
-DOTNET_GLOBAL_FILE="$SCRIPT_DIR//global.json"
+DOTNET_GLOBAL_FILE="$SCRIPT_DIR/global.json"
 DOTNET_INSTALL_URL="https://dot.net/v1/dotnet-install.sh"
 DOTNET_CHANNEL="Current"
 
 export DOTNET_CLI_TELEMETRY_OPTOUT=1
 export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
 export DOTNET_MULTILEVEL_LOOKUP=0
+export DOTNET_ROLL_FORWARD="Major"
 export NUKE_TELEMETRY_OPTOUT=1
 
 ###########################################################################
@@ -29,6 +30,15 @@ function FirstJsonValue {
     perl -nle 'print $1 if m{"'"$1"'": "([^"]+)",?}' <<< "${@:2}"
 }
 
+# Print environment variables
+# WARNING: Make sure that secrets are actually scrambled in build log
+# env | sort
+
+# Check if any dotnet is installed
+if [[ -x "$(command -v dotnet)" ]]; then
+    dotnet --info
+fi
+
 # If dotnet CLI is installed globally and it matches requested version, use for execution
 if [ -x "$(command -v dotnet)" ] && dotnet --version &>/dev/null; then
     export DOTNET_EXE="$(command -v dotnet)"
@@ -59,5 +69,5 @@ fi
 
 echo "Microsoft (R) .NET Core SDK version $("$DOTNET_EXE" --version)"
 
-"$DOTNET_EXE" build "$BUILD_PROJECT_FILE" /nodeReuse:false /p:UseSharedCompilation=false -nologo -clp:NoSummary --verbosity quiet
+"$DOTNET_EXE" build "$BUILD_PROJECT_FILE" /nodeReuse:false /p:UseSharedCompilation=false -nologo -clp:NoSummary
 "$DOTNET_EXE" run --project "$BUILD_PROJECT_FILE" --no-build -- "$@"
diff --git a/docs/_data/navigation.yml b/docs/_data/navigation.yml
index 51c26a1224..0ec09d306d 100644
--- a/docs/_data/navigation.yml
+++ b/docs/_data/navigation.yml
@@ -73,6 +73,8 @@ sidebar:
         url: /xml
       - title: Execution Time
         url: /executiontime
+      - title: HTTP response messages
+        url: /httpresponsemessages
 
   - title: Extensibility
     url: /extensibility
diff --git a/docs/_pages/httpresponsemessages.md b/docs/_pages/httpresponsemessages.md
new file mode 100644
index 0000000000..96575c1087
--- /dev/null
+++ b/docs/_pages/httpresponsemessages.md
@@ -0,0 +1,28 @@
+---
+title: HttpResponseMessages
+permalink: /httpresponsemessages/
+layout: single
+classes: wide
+sidebar:
+nav: "sidebar"
+---
+
+```csharp
+var successfulResponse = new HttpResponseMessage(HttpStatusCode.OK);
+successfulResponse.Should().BeSuccessful("it's set to OK"); // (HttpStatusCode = 2xx)
+
+var redirectResponse = new HttpResponseMessage(HttpStatusCode.Moved);
+redirectResponse.Should().BeRedirection("it's set to Moved"); // (HttpStatusCode = 3xx)
+
+var clientErrorResponse = new HttpResponseMessage(HttpStatusCode.BadRequest);
+clientErrorResponse.Should().HaveClientError("it's set to BadRequest"); // (HttpStatusCode = 4xx)
+clientErrorResponse.Should().HaveError("it's set to BadRequest"); // (HttpStatusCode = 4xx or 5xx)
+
+var serverErrorResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError);
+serverErrorResponse.Should().HaveServerError("it's set to InternalServerError"); // (HttpStatusCode = 5xx)
+serverErrorResponse.Should().HaveError("it's set to InternalServerError"); // (HttpStatusCode = 4xx or 5xx)
+
+var anotherResponse = new HttpResponseMessage(HttpStatusCode.Moved);
+anotherResponse.Should().HaveStatusCode(HttpStatusCode.Moved);
+anotherResponse.Should().NotHaveStatusCode(HttpStatusCode.OK);
+```
diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md
index b7846665a0..361c2bdeb0 100644
--- a/docs/_pages/releases.md
+++ b/docs/_pages/releases.md
@@ -9,6 +9,28 @@ sidebar:
 
 ## Unreleased
 
+### What's New
+
+### Fixes
+
+## 6.4.0
+
+### What's New
+* Adding `ThatAreStatic()` and `ThatAreNotStatic()` for filtering in method assertions - [#1740](https://github.com/fluentassertions/fluentassertions/pull/1740)
+* Adding new assertions for the `HttpStatusCode` of an `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737)
+* Adding non-generic overloads for `WithInnerExceptionExactly` and `WithInnerException` - [#1769](https://github.com/fluentassertions/fluentassertions/pull/1769)
+
+### Fixes
+* `ContainItemsAssignableTo` now expects at least one item assignable to `T` - [#1765](https://github.com/fluentassertions/fluentassertions/pull/1765)
+* Querying methods on classes, e.g. `typeof(MyController).Methods()`, now also includes static methods - [#1740](https://github.com/fluentassertions/fluentassertions/pull/1740)
+* Variable name is not captured after await assertion - [#1770](https://github.com/fluentassertions/fluentassertions/pull/1770)
+* `OccurredEvent` ordering on monitored object is now done via thread-safe counter - [#1773](https://github.com/fluentassertions/fluentassertions/pull/1773)
+* Avoid a `NullReferenceException` when testing an application compiled with .NET Native - [#1776](https://github.com/fluentassertions/fluentassertions/pull/1776)
+* `[Not]Contain(key, value)` for dictionary-like enumerables incorrectly checked if the key was present - [#1786](https://github.com/fluentassertions/fluentassertions/pull/1786)
+* Avoid throwing a `FormatException` when caller name determination returns an unformattable string - [#1788](https://github.com/fluentassertions/fluentassertions/pull/1788)
+
+## 6.3.0
+
 ### What's New
 * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725)
 * Adding `ThatAreVirtual()` and `ThatAreNotVirtual()` for filtering in method assertions - [#1744](https://github.com/fluentassertions/fluentassertions/pull/1744)
diff --git a/docs/index.html b/docs/index.html
index c5349dcddc..22965c7402 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -6,7 +6,7 @@
   overlay_color: "#373737"
   overlay_filter: "0.7"
   overlay_image: "/assets/images/fluent_assertions_large_horizontal.svg"
-  cta_label: "v6 is out NOW!"
+  cta_label: "Happy 2022! And don't forget to grab 6.4.0"
   cta_url: "https://www.continuousimprover.com/2021/08/fluent-assertions-v6"
   caption: "Logo by [**IUserName**](https://github.com/IUsername) and icons by [**Zlatko Najdenovski**](https://www.flaticon.com/authors/zlatko-najdenovski) from [Flaticon](https://www.flaticon.com/)
   "