From 0e36272d26bd2b3604193084c4d69273a52cab06 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Tue, 9 Nov 2021 13:44:37 +0100 Subject: [PATCH 01/19] Introduce new assertions for StatusCode of HttpResponseMessage (#1698) --- Src/FluentAssertions/AssertionExtensions.cs | 19 ++ .../HttpResponseMessageAssertions.cs | 181 ++++++++++++ .../FluentAssertions/net47.verified.txt | 22 ++ .../netcoreapp2.1.verified.txt | 22 ++ .../netcoreapp3.0.verified.txt | 22 ++ .../netstandard2.0.verified.txt | 22 ++ .../netstandard2.1.verified.txt | 22 ++ Tests/Benchmarks/Benchmarks.csproj | 1 + .../HttpResponseMessageAssertionSpecs.cs | 261 ++++++++++++++++++ 9 files changed, 572 insertions(+) create mode 100644 Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs create mode 100644 Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs diff --git a/Src/FluentAssertions/AssertionExtensions.cs b/Src/FluentAssertions/AssertionExtensions.cs index 9eb3e85dfc..4d1d4e6093 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); } + /// + /// Returns an object that can be used to assert the + /// current . + /// + [Pure] + public static HttpResponseMessageAssertions Should(this HttpResponseMessage actualValue) + { + return new HttpResponseMessageAssertions(actualValue); + } + /// /// Returns an object that can be used to assert the /// current . @@ -865,6 +876,14 @@ public static void Should(this BooleanAssertions _) InvalidShouldCall(); } + /// + [Obsolete("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'", error: true)] + public static void Should(this HttpResponseMessageAssertions _) + where TAssertions : HttpResponseMessageAssertions + { + InvalidShouldCall(); + } + /// [Obsolete("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'", error: true)] public static void Should(this DateTimeAssertions _) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs new file mode 100644 index 0000000000..2c692ce1cd --- /dev/null +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -0,0 +1,181 @@ +using System.Diagnostics; +using System.Net; +using System.Net.Http; +using FluentAssertions.Execution; + +namespace FluentAssertions.Primitives +{ + /// + /// Contains a number of methods to assert that a is in the expected state. + /// + [DebuggerNonUserCode] + public class HttpResponseMessageAssertions + : HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(HttpResponseMessage value) + : base(value) + { + } + } + + /// + /// Contains a number of methods to assert that a is in the expected state. + /// + [DebuggerNonUserCode] + public class HttpResponseMessageAssertions + where TAssertions : HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(HttpResponseMessage value) => Subject = value; + + /// + /// Gets the object which value is being asserted. + /// + public HttpResponseMessage Subject { get; } + + /// + /// Asserts that the is successful. + /// + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) + { + 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)this); + } + + /// + /// Asserts that the is redirection. + /// + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint BeRedirection(string because = "", params object[] becauseArgs) + { + Execute.Assertion + .ForCondition((int)Subject.StatusCode >= 300 && (int)Subject.StatusCode <= 399) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but found {0}.", Subject.StatusCode); + + return new AndConstraint((TAssertions)this); + } + + /// + /// Asserts that the is either client (4xx) or server error (5xx). + /// + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint BeError(string because = "", params object[] becauseArgs) + { + 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)this); + } + + /// + /// Asserts that the is client error (4xx). + /// + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint BeClientError(string because = "", params object[] becauseArgs) + { + 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)this); + } + + /// + /// Asserts that the is server error (5xx). + /// + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint BeServerError(string because = "", params object[] becauseArgs) + { + 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)this); + } + + /// + /// Asserts that the value is equal to the specified value. + /// + /// The expected value + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint HaveStatusCode(HttpStatusCode expected, string because = "", params object[] becauseArgs) + { + 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)this); + } + + /// + /// Asserts that the value is not equal to the specified value. + /// + /// The unexpected value + /// + /// A formatted phrase as is supported by explaining why the assertion + /// is needed. If the phrase does not start with the word because, it is prepended automatically. + /// + /// + /// Zero or more objects to format using the placeholders in . + /// + public AndConstraint NotHaveStatusCode(HttpStatusCode unexpected, string because = "", params object[] becauseArgs) + { + 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)this); + } + + private bool IsServerError() => (int)Subject.StatusCode >= 500 && (int)Subject.StatusCode <= 599; + + private bool IsClientError() => (int)Subject.StatusCode >= 400 && (int)Subject.StatusCode <= 499; + } +} diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt index 1cbd954a9f..8f11ea0439 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) { } @@ -120,6 +121,10 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1901,6 +1906,23 @@ namespace FluentAssertions.Primitives public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions { public NullableBooleanAssertions(bool? value) { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt index 54d8ce0fa1..e1bce05e5c 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) { } @@ -120,6 +121,10 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1901,6 +1906,23 @@ namespace FluentAssertions.Primitives public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions { public NullableBooleanAssertions(bool? value) { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt index 3fcf43b8c0..320a3c3188 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) { } @@ -120,6 +121,10 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1901,6 +1906,23 @@ namespace FluentAssertions.Primitives public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions { public NullableBooleanAssertions(bool? value) { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt index 6d5c80ceb5..2dc2108562 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) { } @@ -119,6 +120,10 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1854,6 +1859,23 @@ namespace FluentAssertions.Primitives public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions { public NullableBooleanAssertions(bool? value) { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt index 530ed216a8..551c07d87a 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) { } @@ -120,6 +121,10 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1901,6 +1906,23 @@ namespace FluentAssertions.Primitives public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions { public NullableBooleanAssertions(bool? value) { } diff --git a/Tests/Benchmarks/Benchmarks.csproj b/Tests/Benchmarks/Benchmarks.csproj index 51b8040720..29d901653b 100644 --- a/Tests/Benchmarks/Benchmarks.csproj +++ b/Tests/Benchmarks/Benchmarks.csproj @@ -16,5 +16,6 @@ + \ No newline at end of file diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs new file mode 100644 index 0000000000..51b5303649 --- /dev/null +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -0,0 +1,261 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using Xunit; +using Xunit.Sdk; + +namespace FluentAssertions.Specs.Primitives +{ + public class HttpResponseMessageAssertionSpecs + { + [Theory] + [MemberData(nameof(GetSuccessStatusCodes))] + public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeSuccessful(); + } + + [Theory] + [MemberData(nameof(GetRedirectionStatusCodes))] + public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeRedirection(); + } + + [Theory] + [MemberData(nameof(GetClientErrorStatusCodes))] + public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeClientError(); + } + + [Theory] + [MemberData(nameof(GetServerErrorStatusCodes))] + public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeServerError(); + } + + [Theory] + [MemberData(nameof(GetClientErrorStatusCodes))] + [MemberData(nameof(GetServerErrorStatusCodes))] + public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeError(); + } + + [Fact] + public void Should_fail_when_asserting_statuscode_error_is_successful() + { + // Arrange + var testee = new HttpResponseMessage(HttpStatusCode.Gone); + + // Act + Action action = () => testee.Should().BeSuccessful(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_error_is_successful() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.Gone).Should().BeSuccessful("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .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_when_asserting_statuscode_error_is_redirection() + { + // Arrange + var testee = new HttpResponseMessage(HttpStatusCode.Gone); + + // Act + Action action = () => testee.Should().BeRedirection(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_error_is_redirection() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.Gone).Should().BeRedirection("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .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_when_asserting_statuscode_success_is_client_error() + { + // Arrange + var testee = new HttpResponseMessage(HttpStatusCode.OK); + + // Act + Action action = () => testee.Should().BeClientError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_client_error() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().BeClientError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .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_when_asserting_statuscode_success_is_server_error() + { + // Arrange + var testee = new HttpResponseMessage(HttpStatusCode.OK); + + // Act + Action action = () => testee.Should().BeServerError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_server_error() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().BeServerError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .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_succeed_when_asserting_statuscode_to_be_equal_to_the_same_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.OK); + + // Assert + action.Should().NotThrow(); + } + + [Fact] + public void Should_fail_when_asserting_statuscode_to_be_equal_to_a_different_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_value_to_be_equal_to_a_different_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); + + // Assert + action.Should().Throw() + .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_succeed_when_asserting_statuscode_value_not_to_be_equal_to_the_same_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.Gone); + + // Assert + action.Should().NotThrow(); + } + + [Fact] + public void Should_fail_when_asserting_statuscode_value_not_to_be_equal_to_a_different_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_value_not_to_be_equal_to_a_different_value() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK, "because we want to test the failure {0}", "message"); + + // Assert + action.Should().Throw() + .WithMessage("Expected HttpStatusCode not to be HttpStatusCode.OK {value: 200} because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.*"); + } + + public static IEnumerable GetSuccessStatusCodes() => GetStatusCodesWithinRange(200, 299); + + public static IEnumerable GetRedirectionStatusCodes() => GetStatusCodesWithinRange(300, 399); + + public static IEnumerable GetClientErrorStatusCodes() => GetStatusCodesWithinRange(400, 499); + + public static IEnumerable GetServerErrorStatusCodes() => GetStatusCodesWithinRange(500, 599); + + private static IEnumerable GetStatusCodesWithinRange(int lowerLimit, int upperLimit) + { + foreach (HttpStatusCode httpStatusCode in Enum.GetValues(typeof(HttpStatusCode))) + { + if ((int)httpStatusCode < lowerLimit || (int)httpStatusCode > upperLimit) + { + continue; + } + + yield return new object[] { httpStatusCode }; + } + } + } +} From d56a5ae1d54698883aea22181080690296a7e2cd Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Tue, 9 Nov 2021 13:45:11 +0100 Subject: [PATCH 02/19] Add docu (#1698) --- docs/_pages/httpresponsemessages.md | 28 ++++++++++++++++++++++++++++ docs/_pages/releases.md | 1 + 2 files changed, 29 insertions(+) create mode 100644 docs/_pages/httpresponsemessages.md diff --git a/docs/_pages/httpresponsemessages.md b/docs/_pages/httpresponsemessages.md new file mode 100644 index 0000000000..74a8b1faf1 --- /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"); + +var redirectResponse = new HttpResponseMessage(HttpStatusCode.Moved); +redirectResponse.Should().BeRedirection("it's set to Moved"); + +var clientErrorResponse = new HttpResponseMessage(HttpStatusCode.BadRequest); +clientErrorResponse.Should().BeClientError("it's set to BadRequest"); +clientErrorResponse.Should().BeError("it's set to BadRequest"); + +var serverErrorResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError); +serverErrorResponse.Should().BeServerError("it's set to InternalServerError"); +serverErrorResponse.Should().BeError("it's set to InternalServerError"); + +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 18f13432f5..4f329af2ef 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -11,6 +11,7 @@ sidebar: ### What's New * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725) +* Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1698](https://github.com/fluentassertions/fluentassertions/discussions/1698) ### Fixes From c25f6a91b62c9b22c1e9033a2f6ff5769709534b Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:23:23 +0100 Subject: [PATCH 03/19] Use 'HaveXXError' pattern instead of 'BeXXError' --- .../HttpResponseMessageAssertions.cs | 6 +- .../FluentAssertions/net47.verified.txt | 2653 ---------------- .../netcoreapp2.1.verified.txt | 2655 ----------------- .../netcoreapp3.0.verified.txt | 2655 ----------------- .../netstandard2.0.verified.txt | 2606 ---------------- .../netstandard2.1.verified.txt | 2655 ----------------- .../HttpResponseMessageAssertionSpecs.cs | 14 +- 7 files changed, 10 insertions(+), 13234 deletions(-) delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index 2c692ce1cd..7ffde2d160 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -82,7 +82,7 @@ public AndConstraint BeRedirection(string because = "", params obje /// /// Zero or more objects to format using the placeholders in . /// - public AndConstraint BeError(string because = "", params object[] becauseArgs) + public AndConstraint HaveError(string because = "", params object[] becauseArgs) { Execute.Assertion .ForCondition(IsClientError() || IsServerError()) @@ -102,7 +102,7 @@ public AndConstraint BeError(string because = "", params object[] b /// /// Zero or more objects to format using the placeholders in . /// - public AndConstraint BeClientError(string because = "", params object[] becauseArgs) + public AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { Execute.Assertion .ForCondition(IsClientError()) @@ -122,7 +122,7 @@ public AndConstraint BeClientError(string because = "", params obje /// /// Zero or more objects to format using the placeholders in . /// - public AndConstraint BeServerError(string because = "", params object[] becauseArgs) + public AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { Execute.Assertion .ForCondition(IsServerError()) diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt deleted file mode 100644 index 8f11ea0439..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt +++ /dev/null @@ -1,2653 +0,0 @@ -[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7", FrameworkDisplayName=".NET Framework 4.7")] -namespace FluentAssertions -{ - public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions - { - public AggregateExceptionExtractor() { } - public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception { } - } - public class AndConstraint - { - public AndConstraint(T parentConstraint) { } - public T And { get; } - } - public class AndWhichConstraint : FluentAssertions.AndConstraint - { - public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } - public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } - public TMatchedElement Subject { get; } - public TMatchedElement Which { get; } - } - public static class AssertionExtensions - { - public static TTo As(this object subject) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Action Enumerating(this System.Func enumerable) { } - public static System.Action Enumerating(this System.Func> enumerable) { } - public static System.Action Enumerating(this T subject, System.Func> enumerable) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static System.Action Invoking(this T subject, System.Action action) { } - public static System.Func Invoking(this T subject, System.Func action) { } - public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } - public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } - public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } - public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } - public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } - public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } - public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } - public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } - public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } - 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) { } - public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } - public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } - public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } - public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } - public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } - public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } - public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } - public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } - public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } - public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } - public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) - where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.GuidAssertions _) - where TAssertions : FluentAssertions.Primitives.GuidAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } - public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } - public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } - public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } - public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } - public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Numeric.NumericAssertions _) - where TSubject : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.EnumAssertions _) - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } - public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) - where TCollection : System.Collections.Generic.IEnumerable> { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } - public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - public static class AsyncAssertionsExtensions - { - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - } - public static class AtLeast - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class AtMost - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class CallerIdentifier - { - public static System.Action Logger { get; set; } - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public static class DataRowAssertionExtensions - { - public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) - where TDataRow : System.Data.DataRow { } - } - public static class DataSetAssertionExtensions - { - public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) - where TDataSet : System.Data.DataSet { } - } - public static class DataTableAssertionExtensions - { - public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) - where TDataTable : System.Data.DataTable { } - } - public static class EnumAssertionsExtensions - { - public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) - where TEnum : struct, System.Enum { } - public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) - where TEnum : struct, System.Enum { } - } - public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyPlan() { } - public void Add() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void AddAfter() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Clear() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void Insert() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void InsertBefore() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Remove() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } - public void Reset() { } - } - public static class EventRaisingExtensions - { - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } - } - public static class Exactly - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class ExceptionAssertionsExtensions - { - public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - } - public static class FluentActions - { - public static System.Func Awaiting(System.Func action) { } - public static System.Func> Awaiting(System.Func> func) { } - public static System.Action Enumerating(System.Func enumerable) { } - public static System.Action Enumerating(System.Func> enumerable) { } - public static System.Action Invoking(System.Action action) { } - public static System.Func Invoking(System.Func func) { } - } - public static class LessThan - { - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class MoreThan - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class NumericAssertionsExtensions - { - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - } - public static class ObjectAssertionsExtensions - { - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - } - public abstract class OccurrenceConstraint - { - protected OccurrenceConstraint(int expectedCount) { } - } - public static class TypeEnumerableExtensions - { - public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } - } - public static class TypeExtensions - { - public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } - } - public static class XmlAssertionExtensions - { - public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } - public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } - } -} -namespace FluentAssertions.Collections -{ - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> - { - public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public GenericCollectionAssertions(TCollection actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } - protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params T[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } - public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } - public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } - public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } - public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } - public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } - public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } - public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - { - public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public StringCollectionAssertions(TCollection actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Equal(params string[] expected) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> - { - public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - } - public class WhoseValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhoseValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public class Configuration - { - public Configuration(FluentAssertions.Common.IConfigurationStore store) { } - public string TestFrameworkName { get; set; } - public string ValueFormatterAssembly { get; set; } - public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } - public static FluentAssertions.Common.Configuration Current { get; } - } - public static class DateTimeExtensions - { - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } - } - public interface IClock - { - void Delay(System.TimeSpan timeToDelay); - System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); - FluentAssertions.Common.ITimer StartTimer(); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer : System.IDisposable - { - System.TimeSpan Elapsed { get; } - } - public static class Services - { - public static FluentAssertions.Common.Configuration Configuration { get; } - public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } - public static FluentAssertions.Common.IReflector Reflector { get; set; } - public static System.Action ThrowException { get; set; } - public static void ResetToDefaults() { } - } - public delegate FluentAssertions.Common.ITimer StartTimer(); - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Data -{ - public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public DataColumnAssertions(System.Data.DataColumn dataColumn) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataRow : System.Data.DataRow - { - public DataRowAssertions(TDataRow dataRow) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - } - public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataSet : System.Data.DataSet - { - public DataSetAssertions(TDataSet dataSet) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } - public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } - } - public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataTable : System.Data.DataTable - { - public DataTableAssertions(TDataTable dataTable) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } - } - public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - { - FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); - } - public enum RowMatchMode - { - Index = 0, - PrimaryKey = 1, - } -} -namespace FluentAssertions.Equivalency -{ - public class Comparands - { - public Comparands() { } - public Comparands(object subject, object expectation, System.Type compileTimeType) { } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public System.Type RuntimeType { get; } - public object Subject { get; set; } - public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public override string ToString() { } - } - public class ConversionSelector - { - public ConversionSelector() { } - public FluentAssertions.Equivalency.ConversionSelector Clone() { } - public void Exclude(System.Linq.Expressions.Expression> predicate) { } - public void Include(System.Linq.Expressions.Expression> predicate) { } - public void IncludeAll() { } - public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public enum EqualityStrategy - { - Equals = 0, - Members = 1, - ForceEquals = 2, - ForceMembers = 3, - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - public EquivalencyAssertionOptions() { } - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> - { - public EquivalencyAssertionOptions() { } - public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public enum EquivalencyResult - { - ContinueWithNext = 0, - AssertionCompleted = 1, - } - public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - protected EquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext - { - public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.INode CurrentNode { get; } - public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - public FluentAssertions.Execution.Reason Reason { get; set; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } - public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } - public bool IsCyclicReference(object expectation) { } - public override string ToString() { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator() { } - public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; set; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public delegate string GetSubjectId(); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - FluentAssertions.Equivalency.INode SelectedNode { get; } - TSubject Subject { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - bool CompareRecordsByValue { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public interface IEquivalencyValidationContext - { - FluentAssertions.Equivalency.INode CurrentNode { get; } - FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - FluentAssertions.Execution.Reason Reason { get; } - FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); - FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); - bool IsCyclicReference(object expectation); - } - public interface IEquivalencyValidator - { - void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMember : FluentAssertions.Equivalency.INode - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - System.Type ReflectedType { get; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - object GetValue(object obj); - } - public interface IMemberInfo - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - string Name { get; } - string Path { get; set; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - System.Type Type { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); - } - public interface INode - { - int Depth { get; } - string Description { get; } - FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } - bool IsRoot { get; } - string Name { get; } - string Path { get; } - string PathAndName { get; } - bool RootIsCollection { get; } - System.Type Type { get; } - } - public interface IObjectInfo - { - System.Type CompileTimeType { get; } - string Path { get; set; } - System.Type RuntimeType { get; } - System.Type Type { get; } - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); - } - public static class MemberFactory - { - public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } - } - public class MemberSelectionContext - { - public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - public System.Type Type { get; } - } - [System.Flags] - public enum MemberVisibility - { - None = 0, - Internal = 1, - Public = 2, - } - public class Node : FluentAssertions.Equivalency.INode - { - public Node() { } - public int Depth { get; } - public virtual string Description { get; } - public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } - public bool IsRoot { get; } - public string Name { get; set; } - public string Path { get; set; } - public string PathAndName { get; } - public bool RootIsCollection { get; set; } - public System.Type Type { get; set; } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } - public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } - public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } - } - public enum OrderStrictness - { - Strict = 0, - NotStrict = 1, - Irrelevant = 2, - } - public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public OrderingRuleCollection() { } - public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } - public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } - } - public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public bool CompareRecordsByValue { get; } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers(System.Type type) { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue(System.Type type) { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - public TSelf ComparingRecordsByMembers() { } - public TSelf ComparingRecordsByValue() { } - public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } - public TSelf ExcludingFields() { } - public TSelf ExcludingMissingMembers() { } - public TSelf ExcludingNestedObjects() { } - public TSelf ExcludingProperties() { } - public TSelf IgnoringCyclicReferences() { } - public TSelf Including(System.Linq.Expressions.Expression> predicate) { } - public TSelf IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - public TSelf IncludingInternalFields() { } - public TSelf IncludingInternalProperties() { } - public TSelf IncludingNestedObjects() { } - public TSelf IncludingProperties() { } - public TSelf RespectingDeclaredTypes() { } - public TSelf RespectingRuntimeTypes() { } - public TSelf ThrowingOnMissingMembers() { } - public override string ToString() { } - public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } - public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } - public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } - public TSelf Using() - where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } - public TSelf WithAutoConversion() { } - public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithStrictOrdering() { } - public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } - public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public void WithoutMatchingRules() { } - public void WithoutSelectionRules() { } - public TSelf WithoutStrictOrdering() { } - public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public class Restriction - { - public Restriction(TSelf options, System.Action> action) { } - public TSelf When(System.Linq.Expressions.Expression> predicate) { } - public TSelf WhenTypeIs() - where TMemberType : TMember { } - } - } - public static class SubjectInfoExtensions - { - public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - } -} -namespace FluentAssertions.Equivalency.Steps -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataColumnEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRelationEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataSetEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataTableEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DictionaryEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XAttributeEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XDocumentEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XElementEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } -} -namespace FluentAssertions.Equivalency.Tracing -{ - public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class Tracer - { - public override string ToString() { } - public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - } -} -namespace FluentAssertions.Events -{ - public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - { - protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } - protected override string Identifier { get; } - public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } - public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - } - public class EventMetadata - { - public EventMetadata(string eventName, System.Type handlerType) { } - public string EventName { get; } - public System.Type HandlerType { get; } - } - public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); - FluentAssertions.Events.EventAssertions Should(); - } - public class OccurredEvent - { - public OccurredEvent() { } - public string EventName { get; set; } - public object[] Parameters { get; set; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - [System.Serializable] - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(System.Lazy context) { } - public AssertionScope(string context) { } - public string CallerIdentity { get; } - public System.Lazy Context { get; set; } - public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } - public static FluentAssertions.Execution.AssertionScope Current { get; } - public void AddNonReportable(string key, object value) { } - public void AddPreFormattedFailure(string formattedFailureMessage) { } - public void AddReportable(string key, System.Func valueFunc) { } - public void AddReportable(string key, string value) { } - public void AssumeSingleCaller() { } - public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } - public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } - public T Get(string key) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public bool HasFailures() { } - public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } - } - public class Continuation - { - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } - } - public static class Execute - { - public static FluentAssertions.Execution.AssertionScope Assertion { get; } - } - public class FailReason - { - public FailReason(string message, params object[] args) { } - public object[] Args { get; } - public string Message { get; } - } - public class GivenSelector - { - public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - } - public interface IAssertionScope : System.IDisposable - { - FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); - FluentAssertions.Execution.Continuation ClearExpectation(); - string[] Discard(); - FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); - FluentAssertions.Execution.Continuation FailWith(string message); - FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); - FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); - FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); - FluentAssertions.Execution.GivenSelector Given(System.Func selector); - FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); - FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); - } - public interface IAssertionStrategy - { - System.Collections.Generic.IEnumerable FailureMessages { get; } - System.Collections.Generic.IEnumerable DiscardFailures(); - void HandleFailure(string message); - void ThrowIfAny(System.Collections.Generic.IDictionary context); - } - public interface ICloneable2 - { - object Clone(); - } - public class Reason - { - public Reason(string formattedMessage, object[] arguments) { } - public object[] Arguments { get; set; } - public string FormattedMessage { get; set; } - } -} -namespace FluentAssertions.Extensions -{ - public static class FluentDateTimeExtensions - { - public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } - public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } - public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } - public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } - public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime April(this int day, int year) { } - public static System.DateTime AsLocal(this System.DateTime dateTime) { } - public static System.DateTime AsUtc(this System.DateTime dateTime) { } - public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } - public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTime August(this int day, int year) { } - public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime December(this int day, int year) { } - public static System.DateTime February(this int day, int year) { } - public static System.DateTime January(this int day, int year) { } - public static System.DateTime July(this int day, int year) { } - public static System.DateTime June(this int day, int year) { } - public static System.DateTime March(this int day, int year) { } - public static System.DateTime May(this int day, int year) { } - public static int Microsecond(this System.DateTime self) { } - public static int Microsecond(this System.DateTimeOffset self) { } - public static int Nanosecond(this System.DateTime self) { } - public static int Nanosecond(this System.DateTimeOffset self) { } - public static System.DateTime November(this int day, int year) { } - public static System.DateTime October(this int day, int year) { } - public static System.DateTime September(this int day, int year) { } - public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } - } - public static class FluentTimeSpanExtensions - { - public const long TicksPerMicrosecond = 10; - public const double TicksPerNanosecond = 0.01D; - public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } - public static System.TimeSpan Days(this double days) { } - public static System.TimeSpan Days(this int days) { } - public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } - public static System.TimeSpan Hours(this double hours) { } - public static System.TimeSpan Hours(this int hours) { } - public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } - public static int Microseconds(this System.TimeSpan self) { } - public static System.TimeSpan Microseconds(this int microseconds) { } - public static System.TimeSpan Microseconds(this long microseconds) { } - public static System.TimeSpan Milliseconds(this double milliseconds) { } - public static System.TimeSpan Milliseconds(this int milliseconds) { } - public static System.TimeSpan Minutes(this double minutes) { } - public static System.TimeSpan Minutes(this int minutes) { } - public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } - public static int Nanoseconds(this System.TimeSpan self) { } - public static System.TimeSpan Nanoseconds(this int nanoseconds) { } - public static System.TimeSpan Nanoseconds(this long nanoseconds) { } - public static System.TimeSpan Seconds(this double seconds) { } - public static System.TimeSpan Seconds(this int seconds) { } - public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } - public static System.TimeSpan Ticks(this int ticks) { } - public static System.TimeSpan Ticks(this long ticks) { } - public static double TotalMicroseconds(this System.TimeSpan self) { } - public static double TotalNanoseconds(this System.TimeSpan self) { } - } -} -namespace FluentAssertions.Formatting -{ - public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AggregateExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DefaultValueFormatter() { } - protected virtual int SpacesPerIndentionLevel { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DictionaryValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumValueFormatter() { } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumerableValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); - public class FormattedObjectGraph - { - public FormattedObjectGraph(int maxLines) { } - public int LineCount { get; } - public static int SpacesPerIndentation { get; } - public void AddFragment(string fragment) { } - public void AddFragmentOnNewLine(string fragment) { } - public void AddLine(string line) { } - public override string ToString() { } - public System.IDisposable WithIndentation() { } - } - public static class Formatter - { - public static System.Collections.Generic.IEnumerable Formatters { get; } - public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } - } - public class FormattingContext - { - public FormattingContext() { } - public bool UseLineBreaks { get; set; } - } - public class FormattingOptions - { - public FormattingOptions() { } - public int MaxDepth { get; set; } - public int MaxLines { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MaxLinesExceededException : System.Exception - { - public MaxLinesExceededException() { } - public MaxLinesExceededException(string message) { } - public MaxLinesExceededException(string message, System.Exception innerException) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PredicateLambdaExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class ValueFormatterAttribute : System.Attribute - { - public ValueFormatterAttribute() { } - } - public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XAttributeValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlReaderValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} -namespace FluentAssertions.Numeric -{ - public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> - { - public ComparableTypeAssertions(System.IComparable value) { } - } - public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> - where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions - { - public ComparableTypeAssertions(System.IComparable value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> - where T : struct, System.IComparable - { - public NullableNumericAssertions(T? value) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions - { - public NullableNumericAssertions(T? value) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> - where T : struct, System.IComparable - { - public NumericAssertions(T value) { } - } - public class NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions - { - public NumericAssertions(T value) { } - public T? Subject { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Primitives -{ - public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - } - public class BooleanAssertions - where TAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - public bool? Subject { get; } - public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - } - public class DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - public System.DateTime? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - } - public class DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - public System.DateTimeOffset? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - } - public class DateTimeRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } - } - public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> - where TEnum : struct, System.Enum - { - public EnumAssertions(TEnum subject) { } - } - public class EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions - { - public EnumAssertions(TEnum subject) { } - public TEnum? Subject { get; } - public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } - } - public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - } - public class GuidAssertions - where TAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - public System.Guid? Subject { get; } - public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - } - public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - } - public class HttpResponseMessageAssertions - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } - public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> - where TEnum : struct, System.Enum - { - public NullableEnumAssertions(TEnum? subject) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions - { - public NullableEnumAssertions(TEnum? subject) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions - where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(object value) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(TSubject value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public abstract class ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - protected ReferenceTypeAssertions(TSubject subject) { } - protected abstract string Identifier { get; } - public TSubject Subject { get; } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where T : TSubject { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } - } - public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - public System.TimeSpan? Subject { get; } - public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - } - public class StringAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - } - public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAll(params string[] values) { } - public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAny(params string[] values) { } - public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - } - public enum TimeSpanCondition - { - MoreThan = 0, - AtLeast = 1, - Exactly = 2, - Within = 3, - LessThan = 4, - } -} -namespace FluentAssertions.Reflection -{ - public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public AssemblyAssertions(System.Reflection.Assembly assembly) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Specialized -{ - public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions - { - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - } - public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> - where TTask : System.Threading.Tasks.Task - where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - { - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertions - { - protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } - protected abstract void InvokeSubject(); - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> - where TException : System.Exception - { - public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } - public TException And { get; } - protected override string Identifier { get; } - public TException Which { get; } - public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class ExecutionTime - { - public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } - public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - } - public class ExecutionTimeAssertions - { - public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - } - public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> - { - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - } - public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> - { - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } - } - public interface IExtractExceptions - { - System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception; - } - public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime - { - public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } - } - public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - } - public class TaskCompletionSourceAssertions - { - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Streams -{ - public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions - where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class StreamAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(System.IO.Stream stream) { } - } - public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.IO.Stream - where TAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(TSubject stream) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Types -{ - public static class AllTypes - { - public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } - } - public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } - protected override string Identifier { get; } - } - public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Reflection.MemberInfo - where TAssertions : FluentAssertions.Types.MemberInfoAssertions - { - protected MemberInfoAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - } - public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions - where TSubject : System.Reflection.MethodBase - where TAssertions : FluentAssertions.Types.MethodBaseAssertions - { - protected MethodBaseAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - } - public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } - } - public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } - public MethodInfoSelector(System.Type type) { } - public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } - public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } - public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } - public System.Reflection.MethodInfo[] ToArray() { } - } - public class MethodInfoSelectorAssertions - { - public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectMethods { get; } - public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions - { - public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } - public PropertyInfoSelector(System.Type type) { } - public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } - public FluentAssertions.Types.PropertyInfoSelector OfType() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public System.Reflection.PropertyInfo[] ToArray() { } - } - public class PropertyInfoSelectorAssertions - { - public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectProperties { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - } - public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public TypeAssertions(System.Type type) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) - where TInterface : class { } - } - public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public TypeSelector(System.Collections.Generic.IEnumerable types) { } - public TypeSelector(System.Type type) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ThatAreClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } - public FluentAssertions.Types.TypeSelector ThatImplement() { } - public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } - public System.Type[] ToArray() { } - public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } - public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } - } - public class TypeSelectorAssertions - { - public TypeSelectorAssertions(params System.Type[] types) { } - public System.Collections.Generic.IEnumerable Subject { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Xml -{ - public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } - } - public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XDocumentAssertions(System.Xml.Linq.XDocument document) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - } - public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XElementAssertions(System.Xml.Linq.XElement xElement) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } - } - public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Xml.XmlNode - where TAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(TSubject xmlNode) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt deleted file mode 100644 index e1bce05e5c..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt +++ /dev/null @@ -1,2655 +0,0 @@ -[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v2.1", FrameworkDisplayName="")] -namespace FluentAssertions -{ - public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions - { - public AggregateExceptionExtractor() { } - public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception { } - } - public class AndConstraint - { - public AndConstraint(T parentConstraint) { } - public T And { get; } - } - public class AndWhichConstraint : FluentAssertions.AndConstraint - { - public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } - public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } - public TMatchedElement Subject { get; } - public TMatchedElement Which { get; } - } - public static class AssertionExtensions - { - public static TTo As(this object subject) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Action Enumerating(this System.Func enumerable) { } - public static System.Action Enumerating(this System.Func> enumerable) { } - public static System.Action Enumerating(this T subject, System.Func> enumerable) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static System.Action Invoking(this T subject, System.Action action) { } - public static System.Func Invoking(this T subject, System.Func action) { } - public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } - public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } - public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } - public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } - public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } - public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } - public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } - public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } - public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } - 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) { } - public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } - public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } - public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } - public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } - public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } - public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } - public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } - public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } - public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } - public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } - public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) - where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.GuidAssertions _) - where TAssertions : FluentAssertions.Primitives.GuidAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } - public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } - public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } - public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } - public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } - public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Numeric.NumericAssertions _) - where TSubject : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.EnumAssertions _) - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } - public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) - where TCollection : System.Collections.Generic.IEnumerable> { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } - public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - public static class AsyncAssertionsExtensions - { - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - } - public static class AtLeast - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class AtMost - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class CallerIdentifier - { - public static System.Action Logger { get; set; } - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public static class DataRowAssertionExtensions - { - public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) - where TDataRow : System.Data.DataRow { } - } - public static class DataSetAssertionExtensions - { - public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) - where TDataSet : System.Data.DataSet { } - } - public static class DataTableAssertionExtensions - { - public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) - where TDataTable : System.Data.DataTable { } - } - public static class EnumAssertionsExtensions - { - public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) - where TEnum : struct, System.Enum { } - public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) - where TEnum : struct, System.Enum { } - } - public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyPlan() { } - public void Add() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void AddAfter() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Clear() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void Insert() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void InsertBefore() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Remove() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } - public void Reset() { } - } - public static class EventRaisingExtensions - { - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } - } - public static class Exactly - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class ExceptionAssertionsExtensions - { - public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - } - public static class FluentActions - { - public static System.Func Awaiting(System.Func action) { } - public static System.Func> Awaiting(System.Func> func) { } - public static System.Action Enumerating(System.Func enumerable) { } - public static System.Action Enumerating(System.Func> enumerable) { } - public static System.Action Invoking(System.Action action) { } - public static System.Func Invoking(System.Func func) { } - } - public static class LessThan - { - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class MoreThan - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class NumericAssertionsExtensions - { - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - } - public static class ObjectAssertionsExtensions - { - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - } - public abstract class OccurrenceConstraint - { - protected OccurrenceConstraint(int expectedCount) { } - } - public static class TypeEnumerableExtensions - { - public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } - } - public static class TypeExtensions - { - public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } - } - public static class XmlAssertionExtensions - { - public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } - public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } - } -} -namespace FluentAssertions.Collections -{ - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> - { - public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public GenericCollectionAssertions(TCollection actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } - protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params T[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } - public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } - public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } - public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } - public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } - public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } - public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } - public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - { - public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public StringCollectionAssertions(TCollection actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Equal(params string[] expected) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> - { - public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - } - public class WhoseValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhoseValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public class Configuration - { - public Configuration(FluentAssertions.Common.IConfigurationStore store) { } - public string TestFrameworkName { get; set; } - public string ValueFormatterAssembly { get; set; } - public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } - public static FluentAssertions.Common.Configuration Current { get; } - } - public static class DateTimeExtensions - { - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } - } - public interface IClock - { - void Delay(System.TimeSpan timeToDelay); - System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); - FluentAssertions.Common.ITimer StartTimer(); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer : System.IDisposable - { - System.TimeSpan Elapsed { get; } - } - public static class Services - { - public static FluentAssertions.Common.Configuration Configuration { get; } - public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } - public static FluentAssertions.Common.IReflector Reflector { get; set; } - public static System.Action ThrowException { get; set; } - public static void ResetToDefaults() { } - } - public delegate FluentAssertions.Common.ITimer StartTimer(); - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Data -{ - public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public DataColumnAssertions(System.Data.DataColumn dataColumn) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataRow : System.Data.DataRow - { - public DataRowAssertions(TDataRow dataRow) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - } - public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataSet : System.Data.DataSet - { - public DataSetAssertions(TDataSet dataSet) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } - public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } - } - public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataTable : System.Data.DataTable - { - public DataTableAssertions(TDataTable dataTable) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } - } - public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - { - FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); - } - public enum RowMatchMode - { - Index = 0, - PrimaryKey = 1, - } -} -namespace FluentAssertions.Equivalency -{ - public class Comparands - { - public Comparands() { } - public Comparands(object subject, object expectation, System.Type compileTimeType) { } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public System.Type RuntimeType { get; } - public object Subject { get; set; } - public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public override string ToString() { } - } - public class ConversionSelector - { - public ConversionSelector() { } - public FluentAssertions.Equivalency.ConversionSelector Clone() { } - public void Exclude(System.Linq.Expressions.Expression> predicate) { } - public void Include(System.Linq.Expressions.Expression> predicate) { } - public void IncludeAll() { } - public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public enum EqualityStrategy - { - Equals = 0, - Members = 1, - ForceEquals = 2, - ForceMembers = 3, - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - public EquivalencyAssertionOptions() { } - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> - { - public EquivalencyAssertionOptions() { } - public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public enum EquivalencyResult - { - ContinueWithNext = 0, - AssertionCompleted = 1, - } - public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - protected EquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext - { - public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.INode CurrentNode { get; } - public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - public FluentAssertions.Execution.Reason Reason { get; set; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } - public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } - public bool IsCyclicReference(object expectation) { } - public override string ToString() { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator() { } - public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; set; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public delegate string GetSubjectId(); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - FluentAssertions.Equivalency.INode SelectedNode { get; } - TSubject Subject { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - bool CompareRecordsByValue { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public interface IEquivalencyValidationContext - { - FluentAssertions.Equivalency.INode CurrentNode { get; } - FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - FluentAssertions.Execution.Reason Reason { get; } - FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); - FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); - bool IsCyclicReference(object expectation); - } - public interface IEquivalencyValidator - { - void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMember : FluentAssertions.Equivalency.INode - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - System.Type ReflectedType { get; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - object GetValue(object obj); - } - public interface IMemberInfo - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - string Name { get; } - string Path { get; set; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - System.Type Type { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); - } - public interface INode - { - int Depth { get; } - string Description { get; } - FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } - bool IsRoot { get; } - string Name { get; } - string Path { get; } - string PathAndName { get; } - bool RootIsCollection { get; } - System.Type Type { get; } - } - public interface IObjectInfo - { - System.Type CompileTimeType { get; } - string Path { get; set; } - System.Type RuntimeType { get; } - System.Type Type { get; } - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); - } - public static class MemberFactory - { - public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } - } - public class MemberSelectionContext - { - public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - public System.Type Type { get; } - } - [System.Flags] - public enum MemberVisibility - { - None = 0, - Internal = 1, - Public = 2, - } - public class Node : FluentAssertions.Equivalency.INode - { - public Node() { } - public int Depth { get; } - public virtual string Description { get; } - public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } - public bool IsRoot { get; } - public string Name { get; set; } - public string Path { get; set; } - public string PathAndName { get; } - public bool RootIsCollection { get; set; } - public System.Type Type { get; set; } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } - public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } - public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } - } - public enum OrderStrictness - { - Strict = 0, - NotStrict = 1, - Irrelevant = 2, - } - public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public OrderingRuleCollection() { } - public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } - public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } - } - public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public bool CompareRecordsByValue { get; } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers(System.Type type) { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue(System.Type type) { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - public TSelf ComparingRecordsByMembers() { } - public TSelf ComparingRecordsByValue() { } - public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } - public TSelf ExcludingFields() { } - public TSelf ExcludingMissingMembers() { } - public TSelf ExcludingNestedObjects() { } - public TSelf ExcludingProperties() { } - public TSelf IgnoringCyclicReferences() { } - public TSelf Including(System.Linq.Expressions.Expression> predicate) { } - public TSelf IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - public TSelf IncludingInternalFields() { } - public TSelf IncludingInternalProperties() { } - public TSelf IncludingNestedObjects() { } - public TSelf IncludingProperties() { } - public TSelf RespectingDeclaredTypes() { } - public TSelf RespectingRuntimeTypes() { } - public TSelf ThrowingOnMissingMembers() { } - public override string ToString() { } - public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } - public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } - public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } - public TSelf Using() - where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } - public TSelf WithAutoConversion() { } - public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithStrictOrdering() { } - public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } - public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public void WithoutMatchingRules() { } - public void WithoutSelectionRules() { } - public TSelf WithoutStrictOrdering() { } - public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public class Restriction - { - public Restriction(TSelf options, System.Action> action) { } - public TSelf When(System.Linq.Expressions.Expression> predicate) { } - public TSelf WhenTypeIs() - where TMemberType : TMember { } - } - } - public static class SubjectInfoExtensions - { - public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - } -} -namespace FluentAssertions.Equivalency.Steps -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataColumnEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRelationEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataSetEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataTableEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DictionaryEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XAttributeEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XDocumentEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XElementEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } -} -namespace FluentAssertions.Equivalency.Tracing -{ - public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class Tracer - { - public override string ToString() { } - public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - } -} -namespace FluentAssertions.Events -{ - public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - { - protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } - protected override string Identifier { get; } - public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } - public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - } - public class EventMetadata - { - public EventMetadata(string eventName, System.Type handlerType) { } - public string EventName { get; } - public System.Type HandlerType { get; } - } - public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); - FluentAssertions.Events.EventAssertions Should(); - } - public class OccurredEvent - { - public OccurredEvent() { } - public string EventName { get; set; } - public object[] Parameters { get; set; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - [System.Serializable] - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(System.Lazy context) { } - public AssertionScope(string context) { } - public string CallerIdentity { get; } - public System.Lazy Context { get; set; } - public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } - public static FluentAssertions.Execution.AssertionScope Current { get; } - public void AddNonReportable(string key, object value) { } - public void AddPreFormattedFailure(string formattedFailureMessage) { } - public void AddReportable(string key, System.Func valueFunc) { } - public void AddReportable(string key, string value) { } - public void AssumeSingleCaller() { } - public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } - public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } - public T Get(string key) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public bool HasFailures() { } - public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } - } - public class Continuation - { - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } - } - public static class Execute - { - public static FluentAssertions.Execution.AssertionScope Assertion { get; } - } - public class FailReason - { - public FailReason(string message, params object[] args) { } - public object[] Args { get; } - public string Message { get; } - } - public class GivenSelector - { - public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - } - public interface IAssertionScope : System.IDisposable - { - FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); - FluentAssertions.Execution.Continuation ClearExpectation(); - string[] Discard(); - FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); - FluentAssertions.Execution.Continuation FailWith(string message); - FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); - FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); - FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); - FluentAssertions.Execution.GivenSelector Given(System.Func selector); - FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); - FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); - } - public interface IAssertionStrategy - { - System.Collections.Generic.IEnumerable FailureMessages { get; } - System.Collections.Generic.IEnumerable DiscardFailures(); - void HandleFailure(string message); - void ThrowIfAny(System.Collections.Generic.IDictionary context); - } - public interface ICloneable2 - { - object Clone(); - } - public class Reason - { - public Reason(string formattedMessage, object[] arguments) { } - public object[] Arguments { get; set; } - public string FormattedMessage { get; set; } - } -} -namespace FluentAssertions.Extensions -{ - public static class FluentDateTimeExtensions - { - public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } - public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } - public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } - public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } - public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime April(this int day, int year) { } - public static System.DateTime AsLocal(this System.DateTime dateTime) { } - public static System.DateTime AsUtc(this System.DateTime dateTime) { } - public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } - public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTime August(this int day, int year) { } - public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime December(this int day, int year) { } - public static System.DateTime February(this int day, int year) { } - public static System.DateTime January(this int day, int year) { } - public static System.DateTime July(this int day, int year) { } - public static System.DateTime June(this int day, int year) { } - public static System.DateTime March(this int day, int year) { } - public static System.DateTime May(this int day, int year) { } - public static int Microsecond(this System.DateTime self) { } - public static int Microsecond(this System.DateTimeOffset self) { } - public static int Nanosecond(this System.DateTime self) { } - public static int Nanosecond(this System.DateTimeOffset self) { } - public static System.DateTime November(this int day, int year) { } - public static System.DateTime October(this int day, int year) { } - public static System.DateTime September(this int day, int year) { } - public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } - } - public static class FluentTimeSpanExtensions - { - public const long TicksPerMicrosecond = 10; - public const double TicksPerNanosecond = 0.01D; - public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } - public static System.TimeSpan Days(this double days) { } - public static System.TimeSpan Days(this int days) { } - public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } - public static System.TimeSpan Hours(this double hours) { } - public static System.TimeSpan Hours(this int hours) { } - public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } - public static int Microseconds(this System.TimeSpan self) { } - public static System.TimeSpan Microseconds(this int microseconds) { } - public static System.TimeSpan Microseconds(this long microseconds) { } - public static System.TimeSpan Milliseconds(this double milliseconds) { } - public static System.TimeSpan Milliseconds(this int milliseconds) { } - public static System.TimeSpan Minutes(this double minutes) { } - public static System.TimeSpan Minutes(this int minutes) { } - public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } - public static int Nanoseconds(this System.TimeSpan self) { } - public static System.TimeSpan Nanoseconds(this int nanoseconds) { } - public static System.TimeSpan Nanoseconds(this long nanoseconds) { } - public static System.TimeSpan Seconds(this double seconds) { } - public static System.TimeSpan Seconds(this int seconds) { } - public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } - public static System.TimeSpan Ticks(this int ticks) { } - public static System.TimeSpan Ticks(this long ticks) { } - public static double TotalMicroseconds(this System.TimeSpan self) { } - public static double TotalNanoseconds(this System.TimeSpan self) { } - } -} -namespace FluentAssertions.Formatting -{ - public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AggregateExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DefaultValueFormatter() { } - protected virtual int SpacesPerIndentionLevel { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DictionaryValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumValueFormatter() { } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumerableValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); - public class FormattedObjectGraph - { - public FormattedObjectGraph(int maxLines) { } - public int LineCount { get; } - public static int SpacesPerIndentation { get; } - public void AddFragment(string fragment) { } - public void AddFragmentOnNewLine(string fragment) { } - public void AddLine(string line) { } - public override string ToString() { } - public System.IDisposable WithIndentation() { } - } - public static class Formatter - { - public static System.Collections.Generic.IEnumerable Formatters { get; } - public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } - } - public class FormattingContext - { - public FormattingContext() { } - public bool UseLineBreaks { get; set; } - } - public class FormattingOptions - { - public FormattingOptions() { } - public int MaxDepth { get; set; } - public int MaxLines { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MaxLinesExceededException : System.Exception - { - public MaxLinesExceededException() { } - public MaxLinesExceededException(string message) { } - public MaxLinesExceededException(string message, System.Exception innerException) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PredicateLambdaExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class ValueFormatterAttribute : System.Attribute - { - public ValueFormatterAttribute() { } - } - public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XAttributeValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlReaderValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} -namespace FluentAssertions.Numeric -{ - public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> - { - public ComparableTypeAssertions(System.IComparable value) { } - } - public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> - where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions - { - public ComparableTypeAssertions(System.IComparable value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> - where T : struct, System.IComparable - { - public NullableNumericAssertions(T? value) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions - { - public NullableNumericAssertions(T? value) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> - where T : struct, System.IComparable - { - public NumericAssertions(T value) { } - } - public class NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions - { - public NumericAssertions(T value) { } - public T? Subject { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Primitives -{ - public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - } - public class BooleanAssertions - where TAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - public bool? Subject { get; } - public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - } - public class DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - public System.DateTime? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - } - public class DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - public System.DateTimeOffset? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - } - public class DateTimeRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } - } - public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> - where TEnum : struct, System.Enum - { - public EnumAssertions(TEnum subject) { } - } - public class EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions - { - public EnumAssertions(TEnum subject) { } - public TEnum? Subject { get; } - public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } - } - public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - } - public class GuidAssertions - where TAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - public System.Guid? Subject { get; } - public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - } - public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - } - public class HttpResponseMessageAssertions - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } - public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> - where TEnum : struct, System.Enum - { - public NullableEnumAssertions(TEnum? subject) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions - { - public NullableEnumAssertions(TEnum? subject) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions - where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(object value) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(TSubject value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public abstract class ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - protected ReferenceTypeAssertions(TSubject subject) { } - protected abstract string Identifier { get; } - public TSubject Subject { get; } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where T : TSubject { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } - } - public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - public System.TimeSpan? Subject { get; } - public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - } - public class StringAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - } - public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAll(params string[] values) { } - public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAny(params string[] values) { } - public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - } - public enum TimeSpanCondition - { - MoreThan = 0, - AtLeast = 1, - Exactly = 2, - Within = 3, - LessThan = 4, - } -} -namespace FluentAssertions.Reflection -{ - public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public AssemblyAssertions(System.Reflection.Assembly assembly) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Specialized -{ - public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions - { - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - } - public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> - where TTask : System.Threading.Tasks.Task - where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - { - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertions - { - protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } - protected abstract void InvokeSubject(); - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> - where TException : System.Exception - { - public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } - public TException And { get; } - protected override string Identifier { get; } - public TException Which { get; } - public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class ExecutionTime - { - public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } - public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - } - public class ExecutionTimeAssertions - { - public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - } - public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> - { - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - } - public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> - { - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } - } - public interface IExtractExceptions - { - System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception; - } - public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime - { - public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } - } - public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - } - public class TaskCompletionSourceAssertions - { - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Streams -{ - public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions - where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class StreamAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(System.IO.Stream stream) { } - } - public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.IO.Stream - where TAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(TSubject stream) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Types -{ - public static class AllTypes - { - public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } - } - public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } - protected override string Identifier { get; } - } - public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Reflection.MemberInfo - where TAssertions : FluentAssertions.Types.MemberInfoAssertions - { - protected MemberInfoAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - } - public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions - where TSubject : System.Reflection.MethodBase - where TAssertions : FluentAssertions.Types.MethodBaseAssertions - { - protected MethodBaseAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - } - public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } - } - public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } - public MethodInfoSelector(System.Type type) { } - public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } - public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } - public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } - public System.Reflection.MethodInfo[] ToArray() { } - } - public class MethodInfoSelectorAssertions - { - public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectMethods { get; } - public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions - { - public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } - public PropertyInfoSelector(System.Type type) { } - public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } - public FluentAssertions.Types.PropertyInfoSelector OfType() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public System.Reflection.PropertyInfo[] ToArray() { } - } - public class PropertyInfoSelectorAssertions - { - public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectProperties { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - } - public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public TypeAssertions(System.Type type) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) - where TInterface : class { } - } - public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public TypeSelector(System.Collections.Generic.IEnumerable types) { } - public TypeSelector(System.Type type) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ThatAreClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } - public FluentAssertions.Types.TypeSelector ThatImplement() { } - public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } - public System.Type[] ToArray() { } - public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } - public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } - } - public class TypeSelectorAssertions - { - public TypeSelectorAssertions(params System.Type[] types) { } - public System.Collections.Generic.IEnumerable Subject { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Xml -{ - public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } - } - public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XDocumentAssertions(System.Xml.Linq.XDocument document) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - } - public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XElementAssertions(System.Xml.Linq.XElement xElement) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } - } - public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Xml.XmlNode - where TAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(TSubject xmlNode) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt deleted file mode 100644 index 320a3c3188..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt +++ /dev/null @@ -1,2655 +0,0 @@ -[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v3.0", FrameworkDisplayName="")] -namespace FluentAssertions -{ - public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions - { - public AggregateExceptionExtractor() { } - public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception { } - } - public class AndConstraint - { - public AndConstraint(T parentConstraint) { } - public T And { get; } - } - public class AndWhichConstraint : FluentAssertions.AndConstraint - { - public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } - public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } - public TMatchedElement Subject { get; } - public TMatchedElement Which { get; } - } - public static class AssertionExtensions - { - public static TTo As(this object subject) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Action Enumerating(this System.Func enumerable) { } - public static System.Action Enumerating(this System.Func> enumerable) { } - public static System.Action Enumerating(this T subject, System.Func> enumerable) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static System.Action Invoking(this T subject, System.Action action) { } - public static System.Func Invoking(this T subject, System.Func action) { } - public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } - public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } - public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } - public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } - public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } - public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } - public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } - public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } - public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } - 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) { } - public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } - public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } - public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } - public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } - public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } - public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } - public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } - public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } - public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } - public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } - public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) - where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.GuidAssertions _) - where TAssertions : FluentAssertions.Primitives.GuidAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } - public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } - public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } - public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } - public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } - public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Numeric.NumericAssertions _) - where TSubject : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.EnumAssertions _) - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } - public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) - where TCollection : System.Collections.Generic.IEnumerable> { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } - public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - public static class AsyncAssertionsExtensions - { - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - } - public static class AtLeast - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class AtMost - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class CallerIdentifier - { - public static System.Action Logger { get; set; } - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public static class DataRowAssertionExtensions - { - public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) - where TDataRow : System.Data.DataRow { } - } - public static class DataSetAssertionExtensions - { - public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) - where TDataSet : System.Data.DataSet { } - } - public static class DataTableAssertionExtensions - { - public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) - where TDataTable : System.Data.DataTable { } - } - public static class EnumAssertionsExtensions - { - public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) - where TEnum : struct, System.Enum { } - public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) - where TEnum : struct, System.Enum { } - } - public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyPlan() { } - public void Add() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void AddAfter() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Clear() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void Insert() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void InsertBefore() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Remove() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } - public void Reset() { } - } - public static class EventRaisingExtensions - { - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } - } - public static class Exactly - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class ExceptionAssertionsExtensions - { - public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - } - public static class FluentActions - { - public static System.Func Awaiting(System.Func action) { } - public static System.Func> Awaiting(System.Func> func) { } - public static System.Action Enumerating(System.Func enumerable) { } - public static System.Action Enumerating(System.Func> enumerable) { } - public static System.Action Invoking(System.Action action) { } - public static System.Func Invoking(System.Func func) { } - } - public static class LessThan - { - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class MoreThan - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class NumericAssertionsExtensions - { - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - } - public static class ObjectAssertionsExtensions - { - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - } - public abstract class OccurrenceConstraint - { - protected OccurrenceConstraint(int expectedCount) { } - } - public static class TypeEnumerableExtensions - { - public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } - } - public static class TypeExtensions - { - public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } - } - public static class XmlAssertionExtensions - { - public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } - public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } - } -} -namespace FluentAssertions.Collections -{ - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> - { - public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public GenericCollectionAssertions(TCollection actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } - protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params T[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } - public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } - public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } - public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } - public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } - public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } - public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } - public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - { - public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public StringCollectionAssertions(TCollection actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Equal(params string[] expected) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> - { - public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - } - public class WhoseValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhoseValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public class Configuration - { - public Configuration(FluentAssertions.Common.IConfigurationStore store) { } - public string TestFrameworkName { get; set; } - public string ValueFormatterAssembly { get; set; } - public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } - public static FluentAssertions.Common.Configuration Current { get; } - } - public static class DateTimeExtensions - { - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } - } - public interface IClock - { - void Delay(System.TimeSpan timeToDelay); - System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); - FluentAssertions.Common.ITimer StartTimer(); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer : System.IDisposable - { - System.TimeSpan Elapsed { get; } - } - public static class Services - { - public static FluentAssertions.Common.Configuration Configuration { get; } - public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } - public static FluentAssertions.Common.IReflector Reflector { get; set; } - public static System.Action ThrowException { get; set; } - public static void ResetToDefaults() { } - } - public delegate FluentAssertions.Common.ITimer StartTimer(); - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Data -{ - public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public DataColumnAssertions(System.Data.DataColumn dataColumn) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataRow : System.Data.DataRow - { - public DataRowAssertions(TDataRow dataRow) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - } - public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataSet : System.Data.DataSet - { - public DataSetAssertions(TDataSet dataSet) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } - public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } - } - public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataTable : System.Data.DataTable - { - public DataTableAssertions(TDataTable dataTable) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } - } - public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - { - FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); - } - public enum RowMatchMode - { - Index = 0, - PrimaryKey = 1, - } -} -namespace FluentAssertions.Equivalency -{ - public class Comparands - { - public Comparands() { } - public Comparands(object subject, object expectation, System.Type compileTimeType) { } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public System.Type RuntimeType { get; } - public object Subject { get; set; } - public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public override string ToString() { } - } - public class ConversionSelector - { - public ConversionSelector() { } - public FluentAssertions.Equivalency.ConversionSelector Clone() { } - public void Exclude(System.Linq.Expressions.Expression> predicate) { } - public void Include(System.Linq.Expressions.Expression> predicate) { } - public void IncludeAll() { } - public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public enum EqualityStrategy - { - Equals = 0, - Members = 1, - ForceEquals = 2, - ForceMembers = 3, - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - public EquivalencyAssertionOptions() { } - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> - { - public EquivalencyAssertionOptions() { } - public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public enum EquivalencyResult - { - ContinueWithNext = 0, - AssertionCompleted = 1, - } - public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - protected EquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext - { - public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.INode CurrentNode { get; } - public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - public FluentAssertions.Execution.Reason Reason { get; set; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } - public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } - public bool IsCyclicReference(object expectation) { } - public override string ToString() { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator() { } - public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; set; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public delegate string GetSubjectId(); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - FluentAssertions.Equivalency.INode SelectedNode { get; } - TSubject Subject { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - bool CompareRecordsByValue { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public interface IEquivalencyValidationContext - { - FluentAssertions.Equivalency.INode CurrentNode { get; } - FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - FluentAssertions.Execution.Reason Reason { get; } - FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); - FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); - bool IsCyclicReference(object expectation); - } - public interface IEquivalencyValidator - { - void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMember : FluentAssertions.Equivalency.INode - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - System.Type ReflectedType { get; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - object GetValue(object obj); - } - public interface IMemberInfo - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - string Name { get; } - string Path { get; set; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - System.Type Type { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); - } - public interface INode - { - int Depth { get; } - string Description { get; } - FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } - bool IsRoot { get; } - string Name { get; } - string Path { get; } - string PathAndName { get; } - bool RootIsCollection { get; } - System.Type Type { get; } - } - public interface IObjectInfo - { - System.Type CompileTimeType { get; } - string Path { get; set; } - System.Type RuntimeType { get; } - System.Type Type { get; } - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); - } - public static class MemberFactory - { - public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } - } - public class MemberSelectionContext - { - public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - public System.Type Type { get; } - } - [System.Flags] - public enum MemberVisibility - { - None = 0, - Internal = 1, - Public = 2, - } - public class Node : FluentAssertions.Equivalency.INode - { - public Node() { } - public int Depth { get; } - public virtual string Description { get; } - public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } - public bool IsRoot { get; } - public string Name { get; set; } - public string Path { get; set; } - public string PathAndName { get; } - public bool RootIsCollection { get; set; } - public System.Type Type { get; set; } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } - public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } - public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } - } - public enum OrderStrictness - { - Strict = 0, - NotStrict = 1, - Irrelevant = 2, - } - public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public OrderingRuleCollection() { } - public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } - public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } - } - public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public bool CompareRecordsByValue { get; } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers(System.Type type) { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue(System.Type type) { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - public TSelf ComparingRecordsByMembers() { } - public TSelf ComparingRecordsByValue() { } - public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } - public TSelf ExcludingFields() { } - public TSelf ExcludingMissingMembers() { } - public TSelf ExcludingNestedObjects() { } - public TSelf ExcludingProperties() { } - public TSelf IgnoringCyclicReferences() { } - public TSelf Including(System.Linq.Expressions.Expression> predicate) { } - public TSelf IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - public TSelf IncludingInternalFields() { } - public TSelf IncludingInternalProperties() { } - public TSelf IncludingNestedObjects() { } - public TSelf IncludingProperties() { } - public TSelf RespectingDeclaredTypes() { } - public TSelf RespectingRuntimeTypes() { } - public TSelf ThrowingOnMissingMembers() { } - public override string ToString() { } - public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } - public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } - public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } - public TSelf Using() - where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } - public TSelf WithAutoConversion() { } - public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithStrictOrdering() { } - public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } - public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public void WithoutMatchingRules() { } - public void WithoutSelectionRules() { } - public TSelf WithoutStrictOrdering() { } - public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public class Restriction - { - public Restriction(TSelf options, System.Action> action) { } - public TSelf When(System.Linq.Expressions.Expression> predicate) { } - public TSelf WhenTypeIs() - where TMemberType : TMember { } - } - } - public static class SubjectInfoExtensions - { - public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - } -} -namespace FluentAssertions.Equivalency.Steps -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataColumnEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRelationEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataSetEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataTableEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DictionaryEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XAttributeEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XDocumentEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XElementEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } -} -namespace FluentAssertions.Equivalency.Tracing -{ - public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class Tracer - { - public override string ToString() { } - public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - } -} -namespace FluentAssertions.Events -{ - public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - { - protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } - protected override string Identifier { get; } - public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } - public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - } - public class EventMetadata - { - public EventMetadata(string eventName, System.Type handlerType) { } - public string EventName { get; } - public System.Type HandlerType { get; } - } - public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); - FluentAssertions.Events.EventAssertions Should(); - } - public class OccurredEvent - { - public OccurredEvent() { } - public string EventName { get; set; } - public object[] Parameters { get; set; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - [System.Serializable] - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(System.Lazy context) { } - public AssertionScope(string context) { } - public string CallerIdentity { get; } - public System.Lazy Context { get; set; } - public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } - public static FluentAssertions.Execution.AssertionScope Current { get; } - public void AddNonReportable(string key, object value) { } - public void AddPreFormattedFailure(string formattedFailureMessage) { } - public void AddReportable(string key, System.Func valueFunc) { } - public void AddReportable(string key, string value) { } - public void AssumeSingleCaller() { } - public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } - public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } - public T Get(string key) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public bool HasFailures() { } - public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } - } - public class Continuation - { - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } - } - public static class Execute - { - public static FluentAssertions.Execution.AssertionScope Assertion { get; } - } - public class FailReason - { - public FailReason(string message, params object[] args) { } - public object[] Args { get; } - public string Message { get; } - } - public class GivenSelector - { - public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - } - public interface IAssertionScope : System.IDisposable - { - FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); - FluentAssertions.Execution.Continuation ClearExpectation(); - string[] Discard(); - FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); - FluentAssertions.Execution.Continuation FailWith(string message); - FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); - FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); - FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); - FluentAssertions.Execution.GivenSelector Given(System.Func selector); - FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); - FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); - } - public interface IAssertionStrategy - { - System.Collections.Generic.IEnumerable FailureMessages { get; } - System.Collections.Generic.IEnumerable DiscardFailures(); - void HandleFailure(string message); - void ThrowIfAny(System.Collections.Generic.IDictionary context); - } - public interface ICloneable2 - { - object Clone(); - } - public class Reason - { - public Reason(string formattedMessage, object[] arguments) { } - public object[] Arguments { get; set; } - public string FormattedMessage { get; set; } - } -} -namespace FluentAssertions.Extensions -{ - public static class FluentDateTimeExtensions - { - public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } - public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } - public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } - public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } - public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime April(this int day, int year) { } - public static System.DateTime AsLocal(this System.DateTime dateTime) { } - public static System.DateTime AsUtc(this System.DateTime dateTime) { } - public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } - public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTime August(this int day, int year) { } - public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime December(this int day, int year) { } - public static System.DateTime February(this int day, int year) { } - public static System.DateTime January(this int day, int year) { } - public static System.DateTime July(this int day, int year) { } - public static System.DateTime June(this int day, int year) { } - public static System.DateTime March(this int day, int year) { } - public static System.DateTime May(this int day, int year) { } - public static int Microsecond(this System.DateTime self) { } - public static int Microsecond(this System.DateTimeOffset self) { } - public static int Nanosecond(this System.DateTime self) { } - public static int Nanosecond(this System.DateTimeOffset self) { } - public static System.DateTime November(this int day, int year) { } - public static System.DateTime October(this int day, int year) { } - public static System.DateTime September(this int day, int year) { } - public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } - } - public static class FluentTimeSpanExtensions - { - public const long TicksPerMicrosecond = 10; - public const double TicksPerNanosecond = 0.01D; - public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } - public static System.TimeSpan Days(this double days) { } - public static System.TimeSpan Days(this int days) { } - public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } - public static System.TimeSpan Hours(this double hours) { } - public static System.TimeSpan Hours(this int hours) { } - public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } - public static int Microseconds(this System.TimeSpan self) { } - public static System.TimeSpan Microseconds(this int microseconds) { } - public static System.TimeSpan Microseconds(this long microseconds) { } - public static System.TimeSpan Milliseconds(this double milliseconds) { } - public static System.TimeSpan Milliseconds(this int milliseconds) { } - public static System.TimeSpan Minutes(this double minutes) { } - public static System.TimeSpan Minutes(this int minutes) { } - public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } - public static int Nanoseconds(this System.TimeSpan self) { } - public static System.TimeSpan Nanoseconds(this int nanoseconds) { } - public static System.TimeSpan Nanoseconds(this long nanoseconds) { } - public static System.TimeSpan Seconds(this double seconds) { } - public static System.TimeSpan Seconds(this int seconds) { } - public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } - public static System.TimeSpan Ticks(this int ticks) { } - public static System.TimeSpan Ticks(this long ticks) { } - public static double TotalMicroseconds(this System.TimeSpan self) { } - public static double TotalNanoseconds(this System.TimeSpan self) { } - } -} -namespace FluentAssertions.Formatting -{ - public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AggregateExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DefaultValueFormatter() { } - protected virtual int SpacesPerIndentionLevel { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DictionaryValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumValueFormatter() { } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumerableValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); - public class FormattedObjectGraph - { - public FormattedObjectGraph(int maxLines) { } - public int LineCount { get; } - public static int SpacesPerIndentation { get; } - public void AddFragment(string fragment) { } - public void AddFragmentOnNewLine(string fragment) { } - public void AddLine(string line) { } - public override string ToString() { } - public System.IDisposable WithIndentation() { } - } - public static class Formatter - { - public static System.Collections.Generic.IEnumerable Formatters { get; } - public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } - } - public class FormattingContext - { - public FormattingContext() { } - public bool UseLineBreaks { get; set; } - } - public class FormattingOptions - { - public FormattingOptions() { } - public int MaxDepth { get; set; } - public int MaxLines { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MaxLinesExceededException : System.Exception - { - public MaxLinesExceededException() { } - public MaxLinesExceededException(string message) { } - public MaxLinesExceededException(string message, System.Exception innerException) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PredicateLambdaExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class ValueFormatterAttribute : System.Attribute - { - public ValueFormatterAttribute() { } - } - public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XAttributeValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlReaderValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} -namespace FluentAssertions.Numeric -{ - public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> - { - public ComparableTypeAssertions(System.IComparable value) { } - } - public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> - where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions - { - public ComparableTypeAssertions(System.IComparable value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> - where T : struct, System.IComparable - { - public NullableNumericAssertions(T? value) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions - { - public NullableNumericAssertions(T? value) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> - where T : struct, System.IComparable - { - public NumericAssertions(T value) { } - } - public class NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions - { - public NumericAssertions(T value) { } - public T? Subject { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Primitives -{ - public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - } - public class BooleanAssertions - where TAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - public bool? Subject { get; } - public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - } - public class DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - public System.DateTime? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - } - public class DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - public System.DateTimeOffset? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - } - public class DateTimeRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } - } - public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> - where TEnum : struct, System.Enum - { - public EnumAssertions(TEnum subject) { } - } - public class EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions - { - public EnumAssertions(TEnum subject) { } - public TEnum? Subject { get; } - public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } - } - public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - } - public class GuidAssertions - where TAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - public System.Guid? Subject { get; } - public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - } - public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - } - public class HttpResponseMessageAssertions - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } - public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> - where TEnum : struct, System.Enum - { - public NullableEnumAssertions(TEnum? subject) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions - { - public NullableEnumAssertions(TEnum? subject) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions - where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(object value) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(TSubject value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public abstract class ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - protected ReferenceTypeAssertions(TSubject subject) { } - protected abstract string Identifier { get; } - public TSubject Subject { get; } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where T : TSubject { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } - } - public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - public System.TimeSpan? Subject { get; } - public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - } - public class StringAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - } - public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAll(params string[] values) { } - public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAny(params string[] values) { } - public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - } - public enum TimeSpanCondition - { - MoreThan = 0, - AtLeast = 1, - Exactly = 2, - Within = 3, - LessThan = 4, - } -} -namespace FluentAssertions.Reflection -{ - public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public AssemblyAssertions(System.Reflection.Assembly assembly) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Specialized -{ - public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions - { - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - } - public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> - where TTask : System.Threading.Tasks.Task - where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - { - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertions - { - protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } - protected abstract void InvokeSubject(); - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> - where TException : System.Exception - { - public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } - public TException And { get; } - protected override string Identifier { get; } - public TException Which { get; } - public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class ExecutionTime - { - public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } - public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - } - public class ExecutionTimeAssertions - { - public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - } - public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> - { - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - } - public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> - { - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } - } - public interface IExtractExceptions - { - System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception; - } - public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime - { - public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } - } - public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - } - public class TaskCompletionSourceAssertions - { - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Streams -{ - public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions - where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class StreamAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(System.IO.Stream stream) { } - } - public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.IO.Stream - where TAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(TSubject stream) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Types -{ - public static class AllTypes - { - public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } - } - public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } - protected override string Identifier { get; } - } - public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Reflection.MemberInfo - where TAssertions : FluentAssertions.Types.MemberInfoAssertions - { - protected MemberInfoAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - } - public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions - where TSubject : System.Reflection.MethodBase - where TAssertions : FluentAssertions.Types.MethodBaseAssertions - { - protected MethodBaseAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - } - public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } - } - public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } - public MethodInfoSelector(System.Type type) { } - public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } - public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } - public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } - public System.Reflection.MethodInfo[] ToArray() { } - } - public class MethodInfoSelectorAssertions - { - public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectMethods { get; } - public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions - { - public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } - public PropertyInfoSelector(System.Type type) { } - public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } - public FluentAssertions.Types.PropertyInfoSelector OfType() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public System.Reflection.PropertyInfo[] ToArray() { } - } - public class PropertyInfoSelectorAssertions - { - public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectProperties { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - } - public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public TypeAssertions(System.Type type) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) - where TInterface : class { } - } - public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public TypeSelector(System.Collections.Generic.IEnumerable types) { } - public TypeSelector(System.Type type) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ThatAreClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } - public FluentAssertions.Types.TypeSelector ThatImplement() { } - public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } - public System.Type[] ToArray() { } - public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } - public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } - } - public class TypeSelectorAssertions - { - public TypeSelectorAssertions(params System.Type[] types) { } - public System.Collections.Generic.IEnumerable Subject { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Xml -{ - public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } - } - public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XDocumentAssertions(System.Xml.Linq.XDocument document) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - } - public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XElementAssertions(System.Xml.Linq.XElement xElement) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } - } - public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Xml.XmlNode - where TAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(TSubject xmlNode) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt deleted file mode 100644 index 2dc2108562..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt +++ /dev/null @@ -1,2606 +0,0 @@ -[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName="")] -namespace FluentAssertions -{ - public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions - { - public AggregateExceptionExtractor() { } - public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception { } - } - public class AndConstraint - { - public AndConstraint(T parentConstraint) { } - public T And { get; } - } - public class AndWhichConstraint : FluentAssertions.AndConstraint - { - public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } - public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } - public TMatchedElement Subject { get; } - public TMatchedElement Which { get; } - } - public static class AssertionExtensions - { - public static TTo As(this object subject) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Action Enumerating(this System.Func enumerable) { } - public static System.Action Enumerating(this System.Func> enumerable) { } - public static System.Action Enumerating(this T subject, System.Func> enumerable) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static System.Action Invoking(this T subject, System.Action action) { } - public static System.Func Invoking(this T subject, System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } - public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } - public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } - public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } - public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } - public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } - public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } - public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } - 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) { } - public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } - public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } - public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } - public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } - public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } - public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } - public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } - public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } - public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } - public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } - public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) - where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.GuidAssertions _) - where TAssertions : FluentAssertions.Primitives.GuidAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } - public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } - public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } - public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } - public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } - public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Numeric.NumericAssertions _) - where TSubject : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.EnumAssertions _) - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } - public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) - where TCollection : System.Collections.Generic.IEnumerable> { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } - public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - public static class AsyncAssertionsExtensions - { - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - } - public static class AtLeast - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class AtMost - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class CallerIdentifier - { - public static System.Action Logger { get; set; } - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public static class DataRowAssertionExtensions - { - public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) - where TDataRow : System.Data.DataRow { } - } - public static class DataSetAssertionExtensions - { - public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) - where TDataSet : System.Data.DataSet { } - } - public static class DataTableAssertionExtensions - { - public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) - where TDataTable : System.Data.DataTable { } - } - public static class EnumAssertionsExtensions - { - public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) - where TEnum : struct, System.Enum { } - public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) - where TEnum : struct, System.Enum { } - } - public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyPlan() { } - public void Add() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void AddAfter() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Clear() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void Insert() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void InsertBefore() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Remove() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } - public void Reset() { } - } - public static class Exactly - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class ExceptionAssertionsExtensions - { - public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - } - public static class FluentActions - { - public static System.Func Awaiting(System.Func action) { } - public static System.Func> Awaiting(System.Func> func) { } - public static System.Action Enumerating(System.Func enumerable) { } - public static System.Action Enumerating(System.Func> enumerable) { } - public static System.Action Invoking(System.Action action) { } - public static System.Func Invoking(System.Func func) { } - } - public static class LessThan - { - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class MoreThan - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class NumericAssertionsExtensions - { - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - } - public static class ObjectAssertionsExtensions - { - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - } - public abstract class OccurrenceConstraint - { - protected OccurrenceConstraint(int expectedCount) { } - } - public static class TypeEnumerableExtensions - { - public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } - } - public static class TypeExtensions - { - public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } - } - public static class XmlAssertionExtensions - { - public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } - public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } - } -} -namespace FluentAssertions.Collections -{ - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> - { - public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public GenericCollectionAssertions(TCollection actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } - protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params T[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } - public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } - public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } - public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } - public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } - public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } - public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } - public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - { - public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public StringCollectionAssertions(TCollection actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Equal(params string[] expected) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> - { - public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - } - public class WhoseValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhoseValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public class Configuration - { - public Configuration(FluentAssertions.Common.IConfigurationStore store) { } - public string TestFrameworkName { get; set; } - public string ValueFormatterAssembly { get; set; } - public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } - public static FluentAssertions.Common.Configuration Current { get; } - } - public static class DateTimeExtensions - { - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } - } - public interface IClock - { - void Delay(System.TimeSpan timeToDelay); - System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); - FluentAssertions.Common.ITimer StartTimer(); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer : System.IDisposable - { - System.TimeSpan Elapsed { get; } - } - public static class Services - { - public static FluentAssertions.Common.Configuration Configuration { get; } - public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } - public static FluentAssertions.Common.IReflector Reflector { get; set; } - public static System.Action ThrowException { get; set; } - public static void ResetToDefaults() { } - } - public delegate FluentAssertions.Common.ITimer StartTimer(); - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Data -{ - public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public DataColumnAssertions(System.Data.DataColumn dataColumn) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataRow : System.Data.DataRow - { - public DataRowAssertions(TDataRow dataRow) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - } - public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataSet : System.Data.DataSet - { - public DataSetAssertions(TDataSet dataSet) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } - public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } - } - public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataTable : System.Data.DataTable - { - public DataTableAssertions(TDataTable dataTable) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } - } - public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - { - FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); - } - public enum RowMatchMode - { - Index = 0, - PrimaryKey = 1, - } -} -namespace FluentAssertions.Equivalency -{ - public class Comparands - { - public Comparands() { } - public Comparands(object subject, object expectation, System.Type compileTimeType) { } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public System.Type RuntimeType { get; } - public object Subject { get; set; } - public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public override string ToString() { } - } - public class ConversionSelector - { - public ConversionSelector() { } - public FluentAssertions.Equivalency.ConversionSelector Clone() { } - public void Exclude(System.Linq.Expressions.Expression> predicate) { } - public void Include(System.Linq.Expressions.Expression> predicate) { } - public void IncludeAll() { } - public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public enum EqualityStrategy - { - Equals = 0, - Members = 1, - ForceEquals = 2, - ForceMembers = 3, - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - public EquivalencyAssertionOptions() { } - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> - { - public EquivalencyAssertionOptions() { } - public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public enum EquivalencyResult - { - ContinueWithNext = 0, - AssertionCompleted = 1, - } - public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - protected EquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext - { - public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.INode CurrentNode { get; } - public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - public FluentAssertions.Execution.Reason Reason { get; set; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } - public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } - public bool IsCyclicReference(object expectation) { } - public override string ToString() { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator() { } - public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; set; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public delegate string GetSubjectId(); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - FluentAssertions.Equivalency.INode SelectedNode { get; } - TSubject Subject { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - bool CompareRecordsByValue { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public interface IEquivalencyValidationContext - { - FluentAssertions.Equivalency.INode CurrentNode { get; } - FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - FluentAssertions.Execution.Reason Reason { get; } - FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); - FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); - bool IsCyclicReference(object expectation); - } - public interface IEquivalencyValidator - { - void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMember : FluentAssertions.Equivalency.INode - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - System.Type ReflectedType { get; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - object GetValue(object obj); - } - public interface IMemberInfo - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - string Name { get; } - string Path { get; set; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - System.Type Type { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); - } - public interface INode - { - int Depth { get; } - string Description { get; } - FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } - bool IsRoot { get; } - string Name { get; } - string Path { get; } - string PathAndName { get; } - bool RootIsCollection { get; } - System.Type Type { get; } - } - public interface IObjectInfo - { - System.Type CompileTimeType { get; } - string Path { get; set; } - System.Type RuntimeType { get; } - System.Type Type { get; } - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); - } - public static class MemberFactory - { - public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } - } - public class MemberSelectionContext - { - public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - public System.Type Type { get; } - } - [System.Flags] - public enum MemberVisibility - { - None = 0, - Internal = 1, - Public = 2, - } - public class Node : FluentAssertions.Equivalency.INode - { - public Node() { } - public int Depth { get; } - public virtual string Description { get; } - public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } - public bool IsRoot { get; } - public string Name { get; set; } - public string Path { get; set; } - public string PathAndName { get; } - public bool RootIsCollection { get; set; } - public System.Type Type { get; set; } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } - public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } - public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } - } - public enum OrderStrictness - { - Strict = 0, - NotStrict = 1, - Irrelevant = 2, - } - public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public OrderingRuleCollection() { } - public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } - public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } - } - public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public bool CompareRecordsByValue { get; } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers(System.Type type) { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue(System.Type type) { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - public TSelf ComparingRecordsByMembers() { } - public TSelf ComparingRecordsByValue() { } - public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } - public TSelf ExcludingFields() { } - public TSelf ExcludingMissingMembers() { } - public TSelf ExcludingNestedObjects() { } - public TSelf ExcludingProperties() { } - public TSelf IgnoringCyclicReferences() { } - public TSelf Including(System.Linq.Expressions.Expression> predicate) { } - public TSelf IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - public TSelf IncludingInternalFields() { } - public TSelf IncludingInternalProperties() { } - public TSelf IncludingNestedObjects() { } - public TSelf IncludingProperties() { } - public TSelf RespectingDeclaredTypes() { } - public TSelf RespectingRuntimeTypes() { } - public TSelf ThrowingOnMissingMembers() { } - public override string ToString() { } - public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } - public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } - public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } - public TSelf Using() - where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } - public TSelf WithAutoConversion() { } - public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithStrictOrdering() { } - public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } - public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public void WithoutMatchingRules() { } - public void WithoutSelectionRules() { } - public TSelf WithoutStrictOrdering() { } - public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public class Restriction - { - public Restriction(TSelf options, System.Action> action) { } - public TSelf When(System.Linq.Expressions.Expression> predicate) { } - public TSelf WhenTypeIs() - where TMemberType : TMember { } - } - } - public static class SubjectInfoExtensions - { - public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - } -} -namespace FluentAssertions.Equivalency.Steps -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataColumnEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRelationEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataSetEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataTableEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DictionaryEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XAttributeEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XDocumentEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XElementEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } -} -namespace FluentAssertions.Equivalency.Tracing -{ - public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class Tracer - { - public override string ToString() { } - public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - } -} -namespace FluentAssertions.Execution -{ - [System.Serializable] - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(System.Lazy context) { } - public AssertionScope(string context) { } - public string CallerIdentity { get; } - public System.Lazy Context { get; set; } - public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } - public static FluentAssertions.Execution.AssertionScope Current { get; } - public void AddNonReportable(string key, object value) { } - public void AddPreFormattedFailure(string formattedFailureMessage) { } - public void AddReportable(string key, System.Func valueFunc) { } - public void AddReportable(string key, string value) { } - public void AssumeSingleCaller() { } - public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } - public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } - public T Get(string key) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public bool HasFailures() { } - public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } - } - public class Continuation - { - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } - } - public static class Execute - { - public static FluentAssertions.Execution.AssertionScope Assertion { get; } - } - public class FailReason - { - public FailReason(string message, params object[] args) { } - public object[] Args { get; } - public string Message { get; } - } - public class GivenSelector - { - public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - } - public interface IAssertionScope : System.IDisposable - { - FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); - FluentAssertions.Execution.Continuation ClearExpectation(); - string[] Discard(); - FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); - FluentAssertions.Execution.Continuation FailWith(string message); - FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); - FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); - FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); - FluentAssertions.Execution.GivenSelector Given(System.Func selector); - FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); - FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); - } - public interface IAssertionStrategy - { - System.Collections.Generic.IEnumerable FailureMessages { get; } - System.Collections.Generic.IEnumerable DiscardFailures(); - void HandleFailure(string message); - void ThrowIfAny(System.Collections.Generic.IDictionary context); - } - public interface ICloneable2 - { - object Clone(); - } - public class Reason - { - public Reason(string formattedMessage, object[] arguments) { } - public object[] Arguments { get; set; } - public string FormattedMessage { get; set; } - } -} -namespace FluentAssertions.Extensions -{ - public static class FluentDateTimeExtensions - { - public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } - public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } - public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } - public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } - public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime April(this int day, int year) { } - public static System.DateTime AsLocal(this System.DateTime dateTime) { } - public static System.DateTime AsUtc(this System.DateTime dateTime) { } - public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } - public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTime August(this int day, int year) { } - public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime December(this int day, int year) { } - public static System.DateTime February(this int day, int year) { } - public static System.DateTime January(this int day, int year) { } - public static System.DateTime July(this int day, int year) { } - public static System.DateTime June(this int day, int year) { } - public static System.DateTime March(this int day, int year) { } - public static System.DateTime May(this int day, int year) { } - public static int Microsecond(this System.DateTime self) { } - public static int Microsecond(this System.DateTimeOffset self) { } - public static int Nanosecond(this System.DateTime self) { } - public static int Nanosecond(this System.DateTimeOffset self) { } - public static System.DateTime November(this int day, int year) { } - public static System.DateTime October(this int day, int year) { } - public static System.DateTime September(this int day, int year) { } - public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } - } - public static class FluentTimeSpanExtensions - { - public const long TicksPerMicrosecond = 10; - public const double TicksPerNanosecond = 0.01D; - public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } - public static System.TimeSpan Days(this double days) { } - public static System.TimeSpan Days(this int days) { } - public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } - public static System.TimeSpan Hours(this double hours) { } - public static System.TimeSpan Hours(this int hours) { } - public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } - public static int Microseconds(this System.TimeSpan self) { } - public static System.TimeSpan Microseconds(this int microseconds) { } - public static System.TimeSpan Microseconds(this long microseconds) { } - public static System.TimeSpan Milliseconds(this double milliseconds) { } - public static System.TimeSpan Milliseconds(this int milliseconds) { } - public static System.TimeSpan Minutes(this double minutes) { } - public static System.TimeSpan Minutes(this int minutes) { } - public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } - public static int Nanoseconds(this System.TimeSpan self) { } - public static System.TimeSpan Nanoseconds(this int nanoseconds) { } - public static System.TimeSpan Nanoseconds(this long nanoseconds) { } - public static System.TimeSpan Seconds(this double seconds) { } - public static System.TimeSpan Seconds(this int seconds) { } - public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } - public static System.TimeSpan Ticks(this int ticks) { } - public static System.TimeSpan Ticks(this long ticks) { } - public static double TotalMicroseconds(this System.TimeSpan self) { } - public static double TotalNanoseconds(this System.TimeSpan self) { } - } -} -namespace FluentAssertions.Formatting -{ - public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AggregateExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DefaultValueFormatter() { } - protected virtual int SpacesPerIndentionLevel { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DictionaryValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumValueFormatter() { } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumerableValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); - public class FormattedObjectGraph - { - public FormattedObjectGraph(int maxLines) { } - public int LineCount { get; } - public static int SpacesPerIndentation { get; } - public void AddFragment(string fragment) { } - public void AddFragmentOnNewLine(string fragment) { } - public void AddLine(string line) { } - public override string ToString() { } - public System.IDisposable WithIndentation() { } - } - public static class Formatter - { - public static System.Collections.Generic.IEnumerable Formatters { get; } - public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } - } - public class FormattingContext - { - public FormattingContext() { } - public bool UseLineBreaks { get; set; } - } - public class FormattingOptions - { - public FormattingOptions() { } - public int MaxDepth { get; set; } - public int MaxLines { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MaxLinesExceededException : System.Exception - { - public MaxLinesExceededException() { } - public MaxLinesExceededException(string message) { } - public MaxLinesExceededException(string message, System.Exception innerException) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PredicateLambdaExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class ValueFormatterAttribute : System.Attribute - { - public ValueFormatterAttribute() { } - } - public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XAttributeValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlReaderValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} -namespace FluentAssertions.Numeric -{ - public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> - { - public ComparableTypeAssertions(System.IComparable value) { } - } - public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> - where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions - { - public ComparableTypeAssertions(System.IComparable value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> - where T : struct, System.IComparable - { - public NullableNumericAssertions(T? value) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions - { - public NullableNumericAssertions(T? value) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> - where T : struct, System.IComparable - { - public NumericAssertions(T value) { } - } - public class NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions - { - public NumericAssertions(T value) { } - public T? Subject { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Primitives -{ - public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - } - public class BooleanAssertions - where TAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - public bool? Subject { get; } - public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - } - public class DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - public System.DateTime? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - } - public class DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - public System.DateTimeOffset? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - } - public class DateTimeRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } - } - public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> - where TEnum : struct, System.Enum - { - public EnumAssertions(TEnum subject) { } - } - public class EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions - { - public EnumAssertions(TEnum subject) { } - public TEnum? Subject { get; } - public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } - } - public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - } - public class GuidAssertions - where TAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - public System.Guid? Subject { get; } - public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - } - public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - } - public class HttpResponseMessageAssertions - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } - public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> - where TEnum : struct, System.Enum - { - public NullableEnumAssertions(TEnum? subject) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions - { - public NullableEnumAssertions(TEnum? subject) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions - where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(object value) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(TSubject value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public abstract class ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - protected ReferenceTypeAssertions(TSubject subject) { } - protected abstract string Identifier { get; } - public TSubject Subject { get; } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where T : TSubject { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } - } - public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - public System.TimeSpan? Subject { get; } - public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - } - public class StringAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - } - public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAll(params string[] values) { } - public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAny(params string[] values) { } - public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - } - public enum TimeSpanCondition - { - MoreThan = 0, - AtLeast = 1, - Exactly = 2, - Within = 3, - LessThan = 4, - } -} -namespace FluentAssertions.Reflection -{ - public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public AssemblyAssertions(System.Reflection.Assembly assembly) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Specialized -{ - public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions - { - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - } - public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> - where TTask : System.Threading.Tasks.Task - where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - { - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertions - { - protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } - protected abstract void InvokeSubject(); - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> - where TException : System.Exception - { - public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } - public TException And { get; } - protected override string Identifier { get; } - public TException Which { get; } - public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class ExecutionTime - { - public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } - public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - } - public class ExecutionTimeAssertions - { - public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - } - public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> - { - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - } - public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> - { - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } - } - public interface IExtractExceptions - { - System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception; - } - public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime - { - public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } - } - public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - } - public class TaskCompletionSourceAssertions - { - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Streams -{ - public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions - where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class StreamAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(System.IO.Stream stream) { } - } - public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.IO.Stream - where TAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(TSubject stream) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Types -{ - public static class AllTypes - { - public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } - } - public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } - protected override string Identifier { get; } - } - public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Reflection.MemberInfo - where TAssertions : FluentAssertions.Types.MemberInfoAssertions - { - protected MemberInfoAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - } - public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions - where TSubject : System.Reflection.MethodBase - where TAssertions : FluentAssertions.Types.MethodBaseAssertions - { - protected MethodBaseAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - } - public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } - } - public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } - public MethodInfoSelector(System.Type type) { } - public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } - public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } - public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } - public System.Reflection.MethodInfo[] ToArray() { } - } - public class MethodInfoSelectorAssertions - { - public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectMethods { get; } - public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions - { - public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } - public PropertyInfoSelector(System.Type type) { } - public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } - public FluentAssertions.Types.PropertyInfoSelector OfType() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public System.Reflection.PropertyInfo[] ToArray() { } - } - public class PropertyInfoSelectorAssertions - { - public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectProperties { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - } - public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public TypeAssertions(System.Type type) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) - where TInterface : class { } - } - public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public TypeSelector(System.Collections.Generic.IEnumerable types) { } - public TypeSelector(System.Type type) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ThatAreClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } - public FluentAssertions.Types.TypeSelector ThatImplement() { } - public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } - public System.Type[] ToArray() { } - public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } - public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } - } - public class TypeSelectorAssertions - { - public TypeSelectorAssertions(params System.Type[] types) { } - public System.Collections.Generic.IEnumerable Subject { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Xml -{ - public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } - } - public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XDocumentAssertions(System.Xml.Linq.XDocument document) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - } - public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XElementAssertions(System.Xml.Linq.XElement xElement) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } - } - public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Xml.XmlNode - where TAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(TSubject xmlNode) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt deleted file mode 100644 index 551c07d87a..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt +++ /dev/null @@ -1,2655 +0,0 @@ -[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] -[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName="")] -namespace FluentAssertions -{ - public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions - { - public AggregateExceptionExtractor() { } - public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception { } - } - public class AndConstraint - { - public AndConstraint(T parentConstraint) { } - public T And { get; } - } - public class AndWhichConstraint : FluentAssertions.AndConstraint - { - public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } - public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } - public TMatchedElement Subject { get; } - public TMatchedElement Which { get; } - } - public static class AssertionExtensions - { - public static TTo As(this object subject) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func Awaiting(this T subject, System.Func action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Func> Awaiting(this T subject, System.Func> action) { } - public static System.Action Enumerating(this System.Func enumerable) { } - public static System.Action Enumerating(this System.Func> enumerable) { } - public static System.Action Enumerating(this T subject, System.Func> enumerable) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } - public static System.Action Invoking(this T subject, System.Action action) { } - public static System.Func Invoking(this T subject, System.Func action) { } - public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } - public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } - public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } - public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } - public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } - public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } - public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } - public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } - public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } - public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } - 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) { } - public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } - public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } - public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } - public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } - public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } - public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } - public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } - public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } - public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } - public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } - public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } - public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } - public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) - where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.GuidAssertions _) - where TAssertions : FluentAssertions.Primitives.GuidAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } - public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } - public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } - public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } - public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } - public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Numeric.NumericAssertions _) - where TSubject : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.EnumAssertions _) - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } - public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } - public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) - where TCollection : System.Collections.Generic.IEnumerable> { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } - public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - public static class AsyncAssertionsExtensions - { - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } - } - public static class AtLeast - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class AtMost - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class CallerIdentifier - { - public static System.Action Logger { get; set; } - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public static class DataRowAssertionExtensions - { - public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) - where TDataRow : System.Data.DataRow { } - } - public static class DataSetAssertionExtensions - { - public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) - where TDataSet : System.Data.DataSet { } - } - public static class DataTableAssertionExtensions - { - public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) - where TDataTable : System.Data.DataTable { } - } - public static class EnumAssertionsExtensions - { - public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) - where TEnum : struct, System.Enum { } - public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) - where TEnum : struct, System.Enum { } - } - public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyPlan() { } - public void Add() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void AddAfter() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Clear() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void Insert() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void InsertBefore() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } - public void Remove() - where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } - public void Reset() { } - } - public static class EventRaisingExtensions - { - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } - } - public static class Exactly - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class ExceptionAssertionsExtensions - { - public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) - where TException : System.Exception - where TInnerException : System.Exception { } - public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) - where TException : System.ArgumentException { } - } - public static class FluentActions - { - public static System.Func Awaiting(System.Func action) { } - public static System.Func> Awaiting(System.Func> func) { } - public static System.Action Enumerating(System.Func enumerable) { } - public static System.Action Enumerating(System.Func> enumerable) { } - public static System.Action Invoking(System.Action action) { } - public static System.Func Invoking(System.Func func) { } - } - public static class LessThan - { - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class MoreThan - { - public static FluentAssertions.OccurrenceConstraint Once() { } - public static FluentAssertions.OccurrenceConstraint Thrice() { } - public static FluentAssertions.OccurrenceConstraint Times(int expected) { } - public static FluentAssertions.OccurrenceConstraint Twice() { } - } - public static class NumericAssertionsExtensions - { - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } - } - public static class ObjectAssertionsExtensions - { - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } - public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } - } - public abstract class OccurrenceConstraint - { - protected OccurrenceConstraint(int expectedCount) { } - } - public static class TypeEnumerableExtensions - { - public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) - where TAttribute : System.Attribute { } - public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } - public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } - } - public static class TypeExtensions - { - public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } - public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } - public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } - } - public static class XmlAssertionExtensions - { - public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } - public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } - } -} -namespace FluentAssertions.Collections -{ - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> - { - public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public GenericCollectionAssertions(TCollection actualValue) { } - } - public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } - protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params T[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } - public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } - public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } - public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - } - public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public GenericDictionaryAssertions(TCollection keyValuePairs) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } - public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } - public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } - public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } - public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) - where T : System.Collections.Generic.IEnumerable> { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - { - public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public StringCollectionAssertions(TCollection actualValue) { } - } - public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Equal(params string[] expected) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> - { - public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> - where TCollection : System.Collections.Generic.IEnumerable - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - } - public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions - { - public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } - } - public class WhoseValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhoseValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public class Configuration - { - public Configuration(FluentAssertions.Common.IConfigurationStore store) { } - public string TestFrameworkName { get; set; } - public string ValueFormatterAssembly { get; set; } - public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } - public static FluentAssertions.Common.Configuration Current { get; } - } - public static class DateTimeExtensions - { - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } - public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } - } - public interface IClock - { - void Delay(System.TimeSpan timeToDelay); - System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); - FluentAssertions.Common.ITimer StartTimer(); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer : System.IDisposable - { - System.TimeSpan Elapsed { get; } - } - public static class Services - { - public static FluentAssertions.Common.Configuration Configuration { get; } - public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } - public static FluentAssertions.Common.IReflector Reflector { get; set; } - public static System.Action ThrowException { get; set; } - public static void ResetToDefaults() { } - } - public delegate FluentAssertions.Common.ITimer StartTimer(); - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Data -{ - public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public DataColumnAssertions(System.Data.DataColumn dataColumn) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataRow : System.Data.DataRow - { - public DataRowAssertions(TDataRow dataRow) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - } - public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataSet : System.Data.DataSet - { - public DataSetAssertions(TDataSet dataSet) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } - public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } - } - public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDataTable : System.Data.DataTable - { - public DataTableAssertions(TDataTable dataTable) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } - public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } - } - public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - { - FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); - FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); - FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); - FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); - } - public enum RowMatchMode - { - Index = 0, - PrimaryKey = 1, - } -} -namespace FluentAssertions.Equivalency -{ - public class Comparands - { - public Comparands() { } - public Comparands(object subject, object expectation, System.Type compileTimeType) { } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public System.Type RuntimeType { get; } - public object Subject { get; set; } - public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public override string ToString() { } - } - public class ConversionSelector - { - public ConversionSelector() { } - public FluentAssertions.Equivalency.ConversionSelector Clone() { } - public void Exclude(System.Linq.Expressions.Expression> predicate) { } - public void Include(System.Linq.Expressions.Expression> predicate) { } - public void IncludeAll() { } - public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public enum EqualityStrategy - { - Equals = 0, - Members = 1, - ForceEquals = 2, - ForceMembers = 3, - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - public EquivalencyAssertionOptions() { } - } - public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> - { - public EquivalencyAssertionOptions() { } - public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public enum EquivalencyResult - { - ContinueWithNext = 0, - AssertionCompleted = 1, - } - public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - protected EquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext - { - public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.INode CurrentNode { get; } - public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - public FluentAssertions.Execution.Reason Reason { get; set; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } - public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } - public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } - public bool IsCyclicReference(object expectation) { } - public override string ToString() { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator() { } - public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; set; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public delegate string GetSubjectId(); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - FluentAssertions.Equivalency.INode SelectedNode { get; } - TSubject Subject { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - bool CompareRecordsByValue { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); - } - public interface IEquivalencyValidationContext - { - FluentAssertions.Equivalency.INode CurrentNode { get; } - FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } - FluentAssertions.Execution.Reason Reason { get; } - FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } - FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); - FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); - FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); - bool IsCyclicReference(object expectation); - } - public interface IEquivalencyValidator - { - void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMember : FluentAssertions.Equivalency.INode - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - System.Type ReflectedType { get; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - object GetValue(object obj); - } - public interface IMemberInfo - { - System.Type DeclaringType { get; } - FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - string Name { get; } - string Path { get; set; } - FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - System.Type Type { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); - } - public interface INode - { - int Depth { get; } - string Description { get; } - FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } - bool IsRoot { get; } - string Name { get; } - string Path { get; } - string PathAndName { get; } - bool RootIsCollection { get; } - System.Type Type { get; } - } - public interface IObjectInfo - { - System.Type CompileTimeType { get; } - string Path { get; set; } - System.Type RuntimeType { get; } - System.Type Type { get; } - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); - } - public static class MemberFactory - { - public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } - } - public class MemberSelectionContext - { - public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } - public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } - public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } - public System.Type Type { get; } - } - [System.Flags] - public enum MemberVisibility - { - None = 0, - Internal = 1, - Public = 2, - } - public class Node : FluentAssertions.Equivalency.INode - { - public Node() { } - public int Depth { get; } - public virtual string Description { get; } - public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } - public bool IsRoot { get; } - public string Name { get; set; } - public string Path { get; set; } - public string PathAndName { get; } - public bool RootIsCollection { get; set; } - public System.Type Type { get; set; } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } - public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } - public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } - } - public enum OrderStrictness - { - Strict = 0, - NotStrict = 1, - Irrelevant = 2, - } - public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public OrderingRuleCollection() { } - public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } - public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } - } - public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode - { - public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } - public System.Type DeclaringType { get; } - public override string Description { get; } - public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } - public System.Type ReflectedType { get; } - public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } - public object GetValue(object obj) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public bool CompareRecordsByValue { get; } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers(System.Type type) { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue(System.Type type) { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - public TSelf ComparingRecordsByMembers() { } - public TSelf ComparingRecordsByValue() { } - public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } - public TSelf ExcludingFields() { } - public TSelf ExcludingMissingMembers() { } - public TSelf ExcludingNestedObjects() { } - public TSelf ExcludingProperties() { } - public TSelf IgnoringCyclicReferences() { } - public TSelf Including(System.Linq.Expressions.Expression> predicate) { } - public TSelf IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - public TSelf IncludingInternalFields() { } - public TSelf IncludingInternalProperties() { } - public TSelf IncludingNestedObjects() { } - public TSelf IncludingProperties() { } - public TSelf RespectingDeclaredTypes() { } - public TSelf RespectingRuntimeTypes() { } - public TSelf ThrowingOnMissingMembers() { } - public override string ToString() { } - public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } - public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } - public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } - public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } - public TSelf Using() - where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } - public TSelf WithAutoConversion() { } - public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithStrictOrdering() { } - public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } - public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } - public void WithoutMatchingRules() { } - public void WithoutSelectionRules() { } - public TSelf WithoutStrictOrdering() { } - public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } - public class Restriction - { - public Restriction(TSelf options, System.Action> action) { } - public TSelf When(System.Linq.Expressions.Expression> predicate) { } - public TSelf WhenTypeIs() - where TMemberType : TMember { } - } - } - public static class SubjectInfoExtensions - { - public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } - } -} -namespace FluentAssertions.Equivalency.Steps -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public ConstraintEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataColumnEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRelationEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowCollectionEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataRowEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataSetEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DataTableEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public DictionaryEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - public override string ToString() { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XAttributeEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XDocumentEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } - public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep - { - public XElementEquivalencyStep() { } - protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } - } -} -namespace FluentAssertions.Equivalency.Tracing -{ - public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class Tracer - { - public override string ToString() { } - public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } - } -} -namespace FluentAssertions.Events -{ - public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - { - protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } - protected override string Identifier { get; } - public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } - public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } - } - public class EventMetadata - { - public EventMetadata(string eventName, System.Type handlerType) { } - public string EventName { get; } - public System.Type HandlerType { get; } - } - public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); - FluentAssertions.Events.EventAssertions Should(); - } - public class OccurredEvent - { - public OccurredEvent() { } - public string EventName { get; set; } - public object[] Parameters { get; set; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - [System.Serializable] - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(System.Lazy context) { } - public AssertionScope(string context) { } - public string CallerIdentity { get; } - public System.Lazy Context { get; set; } - public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } - public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } - public static FluentAssertions.Execution.AssertionScope Current { get; } - public void AddNonReportable(string key, object value) { } - public void AddPreFormattedFailure(string formattedFailureMessage) { } - public void AddReportable(string key, System.Func valueFunc) { } - public void AddReportable(string key, string value) { } - public void AssumeSingleCaller() { } - public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } - public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } - public T Get(string key) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public bool HasFailures() { } - public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } - } - public class Continuation - { - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } - public FluentAssertions.Execution.Continuation ClearExpectation() { } - public string[] Discard() { } - public void Dispose() { } - public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } - public FluentAssertions.Execution.Continuation FailWith(string message) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } - public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } - public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } - } - public static class Execute - { - public static FluentAssertions.Execution.AssertionScope Assertion { get; } - } - public class FailReason - { - public FailReason(string message, params object[] args) { } - public object[] Args { get; } - public string Message { get; } - } - public class GivenSelector - { - public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } - public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } - public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } - public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } - } - public interface IAssertionScope : System.IDisposable - { - FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } - FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); - FluentAssertions.Execution.Continuation ClearExpectation(); - string[] Discard(); - FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); - FluentAssertions.Execution.Continuation FailWith(string message); - FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); - FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); - FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); - FluentAssertions.Execution.GivenSelector Given(System.Func selector); - FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); - FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); - } - public interface IAssertionStrategy - { - System.Collections.Generic.IEnumerable FailureMessages { get; } - System.Collections.Generic.IEnumerable DiscardFailures(); - void HandleFailure(string message); - void ThrowIfAny(System.Collections.Generic.IDictionary context); - } - public interface ICloneable2 - { - object Clone(); - } - public class Reason - { - public Reason(string formattedMessage, object[] arguments) { } - public object[] Arguments { get; set; } - public string FormattedMessage { get; set; } - } -} -namespace FluentAssertions.Extensions -{ - public static class FluentDateTimeExtensions - { - public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } - public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } - public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } - public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } - public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime April(this int day, int year) { } - public static System.DateTime AsLocal(this System.DateTime dateTime) { } - public static System.DateTime AsUtc(this System.DateTime dateTime) { } - public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } - public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } - public static System.DateTime August(this int day, int year) { } - public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } - public static System.DateTime December(this int day, int year) { } - public static System.DateTime February(this int day, int year) { } - public static System.DateTime January(this int day, int year) { } - public static System.DateTime July(this int day, int year) { } - public static System.DateTime June(this int day, int year) { } - public static System.DateTime March(this int day, int year) { } - public static System.DateTime May(this int day, int year) { } - public static int Microsecond(this System.DateTime self) { } - public static int Microsecond(this System.DateTimeOffset self) { } - public static int Nanosecond(this System.DateTime self) { } - public static int Nanosecond(this System.DateTimeOffset self) { } - public static System.DateTime November(this int day, int year) { } - public static System.DateTime October(this int day, int year) { } - public static System.DateTime September(this int day, int year) { } - public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } - } - public static class FluentTimeSpanExtensions - { - public const long TicksPerMicrosecond = 10; - public const double TicksPerNanosecond = 0.01D; - public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } - public static System.TimeSpan Days(this double days) { } - public static System.TimeSpan Days(this int days) { } - public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } - public static System.TimeSpan Hours(this double hours) { } - public static System.TimeSpan Hours(this int hours) { } - public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } - public static int Microseconds(this System.TimeSpan self) { } - public static System.TimeSpan Microseconds(this int microseconds) { } - public static System.TimeSpan Microseconds(this long microseconds) { } - public static System.TimeSpan Milliseconds(this double milliseconds) { } - public static System.TimeSpan Milliseconds(this int milliseconds) { } - public static System.TimeSpan Minutes(this double minutes) { } - public static System.TimeSpan Minutes(this int minutes) { } - public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } - public static int Nanoseconds(this System.TimeSpan self) { } - public static System.TimeSpan Nanoseconds(this int nanoseconds) { } - public static System.TimeSpan Nanoseconds(this long nanoseconds) { } - public static System.TimeSpan Seconds(this double seconds) { } - public static System.TimeSpan Seconds(this int seconds) { } - public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } - public static System.TimeSpan Ticks(this int ticks) { } - public static System.TimeSpan Ticks(this long ticks) { } - public static double TotalMicroseconds(this System.TimeSpan self) { } - public static double TotalNanoseconds(this System.TimeSpan self) { } - } -} -namespace FluentAssertions.Formatting -{ - public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AggregateExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DefaultValueFormatter() { } - protected virtual int SpacesPerIndentionLevel { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DictionaryValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumValueFormatter() { } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public EnumerableValueFormatter() { } - protected virtual int MaxItems { get; } - public virtual bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); - public class FormattedObjectGraph - { - public FormattedObjectGraph(int maxLines) { } - public int LineCount { get; } - public static int SpacesPerIndentation { get; } - public void AddFragment(string fragment) { } - public void AddFragmentOnNewLine(string fragment) { } - public void AddLine(string line) { } - public override string ToString() { } - public System.IDisposable WithIndentation() { } - } - public static class Formatter - { - public static System.Collections.Generic.IEnumerable Formatters { get; } - public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } - public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } - } - public class FormattingContext - { - public FormattingContext() { } - public bool UseLineBreaks { get; set; } - } - public class FormattingOptions - { - public FormattingOptions() { } - public int MaxDepth { get; set; } - public int MaxLines { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MaxLinesExceededException : System.Exception - { - public MaxLinesExceededException() { } - public MaxLinesExceededException(string message) { } - public MaxLinesExceededException(string message, System.Exception innerException) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PredicateLambdaExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class ValueFormatterAttribute : System.Attribute - { - public ValueFormatterAttribute() { } - } - public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XAttributeValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlReaderValueFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} -namespace FluentAssertions.Numeric -{ - public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> - { - public ComparableTypeAssertions(System.IComparable value) { } - } - public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> - where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions - { - public ComparableTypeAssertions(System.IComparable value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> - where T : struct, System.IComparable - { - public NullableNumericAssertions(T? value) { } - } - public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions - { - public NullableNumericAssertions(T? value) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> - where T : struct, System.IComparable - { - public NumericAssertions(T value) { } - } - public class NumericAssertions - where T : struct, System.IComparable - where TAssertions : FluentAssertions.Numeric.NumericAssertions - { - public NumericAssertions(T value) { } - public T? Subject { get; } - public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Primitives -{ - public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - } - public class BooleanAssertions - where TAssertions : FluentAssertions.Primitives.BooleanAssertions - { - public BooleanAssertions(bool? value) { } - public bool? Subject { get; } - public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - } - public class DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - public DateTimeAssertions(System.DateTime? value) { } - public System.DateTime? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - } - public class DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } - public System.DateTimeOffset? Subject { get; } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class DateTimeOffsetRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - { - protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } - } - public class DateTimeRangeAssertions - where TAssertions : FluentAssertions.Primitives.DateTimeAssertions - { - protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } - public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } - } - public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> - where TEnum : struct, System.Enum - { - public EnumAssertions(TEnum subject) { } - } - public class EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.EnumAssertions - { - public EnumAssertions(TEnum subject) { } - public TEnum? Subject { get; } - public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) - where T : struct, System.Enum { } - public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } - } - public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - } - public class GuidAssertions - where TAssertions : FluentAssertions.Primitives.GuidAssertions - { - public GuidAssertions(System.Guid? value) { } - public System.Guid? Subject { get; } - public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - } - public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - } - public class HttpResponseMessageAssertions - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions - { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } - public FluentAssertions.AndConstraint BeClientError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeServerError(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - } - public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions - where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions - { - public NullableBooleanAssertions(bool? value) { } - public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - } - public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions - { - public NullableDateTimeAssertions(System.DateTime? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - } - public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions - where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions - { - public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> - where TEnum : struct, System.Enum - { - public NullableEnumAssertions(TEnum? subject) { } - } - public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions - where TEnum : struct, System.Enum - where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions - { - public NullableEnumAssertions(TEnum? subject) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - } - public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions - where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions - { - public NullableGuidAssertions(System.Guid? value) { } - public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions - { - public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } - public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(object value) { } - } - public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ObjectAssertions - { - public ObjectAssertions(TSubject value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - } - public abstract class ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - protected ReferenceTypeAssertions(TSubject subject) { } - protected abstract string Identifier { get; } - public TSubject Subject { get; } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where T : TSubject { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } - } - public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - } - public class SimpleTimeSpanAssertions - where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions - { - public SimpleTimeSpanAssertions(System.TimeSpan? value) { } - public System.TimeSpan? Subject { get; } - public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - } - public class StringAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - } - public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TAssertions : FluentAssertions.Primitives.StringAssertions - { - public StringAssertions(string value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } - public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAll(params string[] values) { } - public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainAny(params string[] values) { } - public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } - public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } - } - public enum TimeSpanCondition - { - MoreThan = 0, - AtLeast = 1, - Exactly = 2, - Within = 3, - LessThan = 4, - } -} -namespace FluentAssertions.Reflection -{ - public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public AssemblyAssertions(System.Reflection.Assembly assembly) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Specialized -{ - public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions - { - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - } - public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> - where TTask : System.Threading.Tasks.Task - where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - { - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } - protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) - where TException : System.Exception { } - } - public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase - where TDelegate : System.Delegate - where TAssertions : FluentAssertions.Specialized.DelegateAssertions - { - protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } - protected abstract void InvokeSubject(); - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> - where TException : System.Exception - { - public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } - public TException And { get; } - protected override string Identifier { get; } - public TException Which { get; } - public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) - where TInnerException : System.Exception { } - public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class ExecutionTime - { - public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } - public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } - } - public class ExecutionTimeAssertions - { - public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } - public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - } - public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> - { - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - protected override string Identifier { get; } - protected override void InvokeSubject() { } - public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - } - public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> - { - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } - } - public interface IExtractExceptions - { - System.Collections.Generic.IEnumerable OfType(System.Exception actualException) - where T : System.Exception; - } - public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime - { - public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } - } - public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions - { - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } - public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } - } - public class TaskCompletionSourceAssertions - { - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } - public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } - public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Streams -{ - public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - } - public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions - where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions - { - public BufferedStreamAssertions(System.IO.BufferedStream stream) { } - public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class StreamAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(System.IO.Stream stream) { } - } - public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.IO.Stream - where TAssertions : FluentAssertions.Streams.StreamAssertions - { - public StreamAssertions(TSubject stream) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Types -{ - public static class AllTypes - { - public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } - } - public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } - protected override string Identifier { get; } - } - public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Reflection.MemberInfo - where TAssertions : FluentAssertions.Types.MemberInfoAssertions - { - protected MemberInfoAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - } - public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions - where TSubject : System.Reflection.MethodBase - where TAssertions : FluentAssertions.Types.MethodBaseAssertions - { - protected MethodBaseAssertions(TSubject subject) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - } - public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions - { - public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } - } - public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } - public MethodInfoSelector(System.Type type) { } - public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } - public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } - public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } - public System.Reflection.MethodInfo[] ToArray() { } - } - public class MethodInfoSelectorAssertions - { - public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectMethods { get; } - public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions - { - public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } - } - public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } - public PropertyInfoSelector(System.Type type) { } - public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } - public FluentAssertions.Types.PropertyInfoSelector OfType() { } - public FluentAssertions.Types.TypeSelector ReturnTypes() { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public System.Reflection.PropertyInfo[] ToArray() { } - } - public class PropertyInfoSelectorAssertions - { - public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } - protected string Context { get; } - public System.Collections.Generic.IEnumerable SubjectProperties { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } - } - public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public TypeAssertions(System.Type type) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) - where TBaseClass : class { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) - where TInterface : class { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) - where TInterface : class { } - } - public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public TypeSelector(System.Collections.Generic.IEnumerable types) { } - public TypeSelector(System.Type type) { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public FluentAssertions.Types.TypeSelector ThatAreClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStatic() { } - public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } - public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } - public FluentAssertions.Types.TypeSelector ThatImplement() { } - public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } - public System.Type[] ToArray() { } - public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } - public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } - } - public class TypeSelectorAssertions - { - public TypeSelectorAssertions(params System.Type[] types) { } - public System.Collections.Generic.IEnumerable Subject { get; } - public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) - where TAttribute : System.Attribute { } - public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } - } -} -namespace FluentAssertions.Xml -{ - public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } - } - public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XDocumentAssertions(System.Xml.Linq.XDocument document) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } - } - public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - { - public XElementAssertions(System.Xml.Linq.XElement xElement) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } - public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } - } - public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Xml.XmlNode - where TAssertions : FluentAssertions.Xml.XmlNodeAssertions - { - public XmlNodeAssertions(TSubject xmlNode) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index 51b5303649..b57242a37f 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -39,7 +39,7 @@ public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusC var testee = new HttpResponseMessage(statusCodeOfResponse); // Act / Assert - testee.Should().BeClientError(); + testee.Should().HaveClientError(); } [Theory] @@ -50,7 +50,7 @@ public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusC var testee = new HttpResponseMessage(statusCodeOfResponse); // Act / Assert - testee.Should().BeServerError(); + testee.Should().HaveServerError(); } [Theory] @@ -62,7 +62,7 @@ public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode sta var testee = new HttpResponseMessage(statusCodeOfResponse); // Act / Assert - testee.Should().BeError(); + testee.Should().HaveError(); } [Fact] @@ -124,7 +124,7 @@ public void Should_fail_when_asserting_statuscode_success_is_client_error() var testee = new HttpResponseMessage(HttpStatusCode.OK); // Act - Action action = () => testee.Should().BeClientError(); + Action action = () => testee.Should().HaveClientError(); // Assert action.Should().Throw(); @@ -135,7 +135,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe { // Act Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().BeClientError("because we want to test the failure {0}", "message"); + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveClientError("because we want to test the failure {0}", "message"); // Assert action @@ -150,7 +150,7 @@ public void Should_fail_when_asserting_statuscode_success_is_server_error() var testee = new HttpResponseMessage(HttpStatusCode.OK); // Act - Action action = () => testee.Should().BeServerError(); + Action action = () => testee.Should().HaveServerError(); // Assert action.Should().Throw(); @@ -161,7 +161,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe { // Act Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().BeServerError("because we want to test the failure {0}", "message"); + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveServerError("because we want to test the failure {0}", "message"); // Assert action From 4bf5fd71a2e99b1f086027ad66b7a16bd397c09f Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:27:32 +0100 Subject: [PATCH 04/19] Use inline data for testing instead of generating test data within dedicated method --- .../HttpResponseMessageAssertionSpecs.cs | 36 +++++-------------- 1 file changed, 8 insertions(+), 28 deletions(-) diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index b57242a37f..b27313fb86 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -1,5 +1,4 @@ using System; -using System.Collections.Generic; using System.Net; using System.Net.Http; using Xunit; @@ -10,7 +9,8 @@ namespace FluentAssertions.Specs.Primitives public class HttpResponseMessageAssertionSpecs { [Theory] - [MemberData(nameof(GetSuccessStatusCodes))] + [InlineData(HttpStatusCode.OK)] + [InlineData(HttpStatusCode.Accepted)] public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCode statusCodeOfResponse) { // Arrange @@ -21,7 +21,7 @@ public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCod } [Theory] - [MemberData(nameof(GetRedirectionStatusCodes))] + [InlineData(HttpStatusCode.Moved)] public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode statusCodeOfResponse) { // Arrange @@ -32,7 +32,8 @@ public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode } [Theory] - [MemberData(nameof(GetClientErrorStatusCodes))] + [InlineData(HttpStatusCode.Gone)] + [InlineData(HttpStatusCode.BadRequest)] public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusCode statusCodeOfResponse) { // Arrange @@ -43,7 +44,7 @@ public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusC } [Theory] - [MemberData(nameof(GetServerErrorStatusCodes))] + [InlineData(HttpStatusCode.InternalServerError)] public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusCode statusCodeOfResponse) { // Arrange @@ -54,8 +55,8 @@ public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusC } [Theory] - [MemberData(nameof(GetClientErrorStatusCodes))] - [MemberData(nameof(GetServerErrorStatusCodes))] + [InlineData(HttpStatusCode.BadRequest)] + [InlineData(HttpStatusCode.InternalServerError)] public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode statusCodeOfResponse) { // Arrange @@ -236,26 +237,5 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_value action.Should().Throw() .WithMessage("Expected HttpStatusCode not to be HttpStatusCode.OK {value: 200} because we want to test the failure message, but found HttpStatusCode.OK {value: 200}.*"); } - - public static IEnumerable GetSuccessStatusCodes() => GetStatusCodesWithinRange(200, 299); - - public static IEnumerable GetRedirectionStatusCodes() => GetStatusCodesWithinRange(300, 399); - - public static IEnumerable GetClientErrorStatusCodes() => GetStatusCodesWithinRange(400, 499); - - public static IEnumerable GetServerErrorStatusCodes() => GetStatusCodesWithinRange(500, 599); - - private static IEnumerable GetStatusCodesWithinRange(int lowerLimit, int upperLimit) - { - foreach (HttpStatusCode httpStatusCode in Enum.GetValues(typeof(HttpStatusCode))) - { - if ((int)httpStatusCode < lowerLimit || (int)httpStatusCode > upperLimit) - { - continue; - } - - yield return new object[] { httpStatusCode }; - } - } } } From 85ffec91557621b270cd7eef49c7e4c44767a49f Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:37:25 +0100 Subject: [PATCH 05/19] Group tests by method and add more tests --- .../HttpResponseMessageAssertions.cs | 2 +- .../HttpResponseMessageAssertionSpecs.cs | 118 +++++++++++------- 2 files changed, 73 insertions(+), 47 deletions(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index 7ffde2d160..29fdb6bbbb 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -87,7 +87,7 @@ public AndConstraint HaveError(string because = "", params object[] Execute.Assertion .ForCondition(IsClientError() || IsServerError()) .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be an error {reason}, but found {0}.", Subject.StatusCode); + .FailWith("Expected HttpStatusCode to be an error{reason}, but found {0}.", Subject.StatusCode); return new AndConstraint((TAssertions)this); } diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index b27313fb86..28341e2715 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -20,52 +20,6 @@ public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCod testee.Should().BeSuccessful(); } - [Theory] - [InlineData(HttpStatusCode.Moved)] - public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode statusCodeOfResponse) - { - // Arrange - var testee = new HttpResponseMessage(statusCodeOfResponse); - - // Act / Assert - testee.Should().BeRedirection(); - } - - [Theory] - [InlineData(HttpStatusCode.Gone)] - [InlineData(HttpStatusCode.BadRequest)] - public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusCode statusCodeOfResponse) - { - // Arrange - var testee = new HttpResponseMessage(statusCodeOfResponse); - - // Act / Assert - testee.Should().HaveClientError(); - } - - [Theory] - [InlineData(HttpStatusCode.InternalServerError)] - public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusCode statusCodeOfResponse) - { - // Arrange - var testee = new HttpResponseMessage(statusCodeOfResponse); - - // Act / Assert - testee.Should().HaveServerError(); - } - - [Theory] - [InlineData(HttpStatusCode.BadRequest)] - [InlineData(HttpStatusCode.InternalServerError)] - public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode statusCodeOfResponse) - { - // Arrange - var testee = new HttpResponseMessage(statusCodeOfResponse); - - // Act / Assert - testee.Should().HaveError(); - } - [Fact] public void Should_fail_when_asserting_statuscode_error_is_successful() { @@ -92,6 +46,17 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_error .WithMessage("Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but found HttpStatusCode.Gone {value: 410}."); } + [Theory] + [InlineData(HttpStatusCode.Moved)] + public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().BeRedirection(); + } + [Fact] public void Should_fail_when_asserting_statuscode_error_is_redirection() { @@ -118,6 +83,18 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_error .WithMessage("Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but found HttpStatusCode.Gone {value: 410}."); } + [Theory] + [InlineData(HttpStatusCode.Gone)] + [InlineData(HttpStatusCode.BadRequest)] + public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().HaveClientError(); + } + [Fact] public void Should_fail_when_asserting_statuscode_success_is_client_error() { @@ -144,6 +121,17 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe .WithMessage("Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but found HttpStatusCode.OK {value: 200}."); } + [Theory] + [InlineData(HttpStatusCode.InternalServerError)] + public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().HaveServerError(); + } + [Fact] public void Should_fail_when_asserting_statuscode_success_is_server_error() { @@ -170,6 +158,44 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe .WithMessage("Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but found HttpStatusCode.OK {value: 200}."); } + [Theory] + [InlineData(HttpStatusCode.BadRequest)] + [InlineData(HttpStatusCode.InternalServerError)] + public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode statusCodeOfResponse) + { + // Arrange + var testee = new HttpResponseMessage(statusCodeOfResponse); + + // Act / Assert + testee.Should().HaveError(); + } + + [Fact] + public void Should_fail_when_asserting_statuscode_success_is_error() + { + // Arrange + var testee = new HttpResponseMessage(HttpStatusCode.OK); + + // Act + Action action = () => testee.Should().HaveError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_error() + { + // Act + Action action = () => + new HttpResponseMessage(HttpStatusCode.OK).Should().HaveError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .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_succeed_when_asserting_statuscode_to_be_equal_to_the_same_value() { From f488b9b7756c113ea780a344b6b5e69154e50299 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:39:24 +0100 Subject: [PATCH 06/19] Make test names more concise --- .../HttpResponseMessageAssertionSpecs.cs | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index 28341e2715..451ada314f 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -11,7 +11,7 @@ public class HttpResponseMessageAssertionSpecs [Theory] [InlineData(HttpStatusCode.OK)] [InlineData(HttpStatusCode.Accepted)] - public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCode statusCodeOfResponse) + public void Should_succeed_when_status_code_is_successful(HttpStatusCode statusCodeOfResponse) { // Arrange var testee = new HttpResponseMessage(statusCodeOfResponse); @@ -21,7 +21,7 @@ public void Should_succeed_when_asserting_statuscode_is_successful(HttpStatusCod } [Fact] - public void Should_fail_when_asserting_statuscode_error_is_successful() + public void Should_fail_when_status_code_error_is_successful() { // Arrange var testee = new HttpResponseMessage(HttpStatusCode.Gone); @@ -34,7 +34,7 @@ public void Should_fail_when_asserting_statuscode_error_is_successful() } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_error_is_successful() + public void Should_fail_with_descriptive_message_when_status_code_error_is_successful() { // Act Action action = () => @@ -48,7 +48,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_error [Theory] [InlineData(HttpStatusCode.Moved)] - public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode statusCodeOfResponse) + public void Should_succeed_when_status_code_is_redirect(HttpStatusCode statusCodeOfResponse) { // Arrange var testee = new HttpResponseMessage(statusCodeOfResponse); @@ -58,7 +58,7 @@ public void Should_succeed_when_asserting_statuscode_is_redirect(HttpStatusCode } [Fact] - public void Should_fail_when_asserting_statuscode_error_is_redirection() + public void Should_fail_when_status_code_error_is_redirection() { // Arrange var testee = new HttpResponseMessage(HttpStatusCode.Gone); @@ -71,7 +71,7 @@ public void Should_fail_when_asserting_statuscode_error_is_redirection() } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_error_is_redirection() + public void Should_fail_with_descriptive_message_when_status_code_error_is_redirection() { // Act Action action = () => @@ -86,7 +86,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_error [Theory] [InlineData(HttpStatusCode.Gone)] [InlineData(HttpStatusCode.BadRequest)] - public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusCode statusCodeOfResponse) + public void Should_succeed_when_status_code_is_client_error(HttpStatusCode statusCodeOfResponse) { // Arrange var testee = new HttpResponseMessage(statusCodeOfResponse); @@ -96,7 +96,7 @@ public void Should_succeed_when_asserting_statuscode_is_client_error(HttpStatusC } [Fact] - public void Should_fail_when_asserting_statuscode_success_is_client_error() + public void Should_fail_when_status_code_success_is_client_error() { // Arrange var testee = new HttpResponseMessage(HttpStatusCode.OK); @@ -109,7 +109,7 @@ public void Should_fail_when_asserting_statuscode_success_is_client_error() } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_client_error() + public void Should_fail_with_descriptive_message_when_status_code_success_is_client_error() { // Act Action action = () => @@ -123,7 +123,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe [Theory] [InlineData(HttpStatusCode.InternalServerError)] - public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusCode statusCodeOfResponse) + public void Should_succeed_when_status_code_is_server_error(HttpStatusCode statusCodeOfResponse) { // Arrange var testee = new HttpResponseMessage(statusCodeOfResponse); @@ -133,7 +133,7 @@ public void Should_succeed_when_asserting_statuscode_is_server_error(HttpStatusC } [Fact] - public void Should_fail_when_asserting_statuscode_success_is_server_error() + public void Should_fail_when_status_code_success_is_server_error() { // Arrange var testee = new HttpResponseMessage(HttpStatusCode.OK); @@ -146,7 +146,7 @@ public void Should_fail_when_asserting_statuscode_success_is_server_error() } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_server_error() + public void Should_fail_with_descriptive_message_when_status_code_success_is_server_error() { // Act Action action = () => @@ -161,7 +161,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe [Theory] [InlineData(HttpStatusCode.BadRequest)] [InlineData(HttpStatusCode.InternalServerError)] - public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode statusCodeOfResponse) + public void Should_succeed_when_status_code_is_error(HttpStatusCode statusCodeOfResponse) { // Arrange var testee = new HttpResponseMessage(statusCodeOfResponse); @@ -171,7 +171,7 @@ public void Should_succeed_when_asserting_statuscode_is_error(HttpStatusCode sta } [Fact] - public void Should_fail_when_asserting_statuscode_success_is_error() + public void Should_fail_when_status_code_success_is_error() { // Arrange var testee = new HttpResponseMessage(HttpStatusCode.OK); @@ -184,7 +184,7 @@ public void Should_fail_when_asserting_statuscode_success_is_error() } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_success_is_error() + public void Should_fail_with_descriptive_message_when_status_code_success_is_error() { // Act Action action = () => @@ -197,7 +197,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_succe } [Fact] - public void Should_succeed_when_asserting_statuscode_to_be_equal_to_the_same_value() + public void Should_succeed_when_status_code_to_be_equal_to_the_same_value() { // Act Action action = () => @@ -208,7 +208,7 @@ public void Should_succeed_when_asserting_statuscode_to_be_equal_to_the_same_val } [Fact] - public void Should_fail_when_asserting_statuscode_to_be_equal_to_a_different_value() + public void Should_fail_when_status_code_to_be_equal_to_a_different_value() { // Act Action action = () => @@ -219,7 +219,7 @@ public void Should_fail_when_asserting_statuscode_to_be_equal_to_a_different_val } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_value_to_be_equal_to_a_different_value() + public void Should_fail_with_descriptive_message_when_status_code_value_to_be_equal_to_a_different_value() { // Act Action action = () => @@ -231,7 +231,7 @@ public void Should_fail_with_descriptive_message_when_asserting_statuscode_value } [Fact] - public void Should_succeed_when_asserting_statuscode_value_not_to_be_equal_to_the_same_value() + public void Should_succeed_when_status_code_value_not_to_be_equal_to_the_same_value() { // Act Action action = () => @@ -242,7 +242,7 @@ public void Should_succeed_when_asserting_statuscode_value_not_to_be_equal_to_th } [Fact] - public void Should_fail_when_asserting_statuscode_value_not_to_be_equal_to_a_different_value() + public void Should_fail_when_status_code_value_not_to_be_equal_to_a_different_value() { // Act Action action = () => @@ -253,7 +253,7 @@ public void Should_fail_when_asserting_statuscode_value_not_to_be_equal_to_a_dif } [Fact] - public void Should_fail_with_descriptive_message_when_asserting_statuscode_value_not_to_be_equal_to_a_different_value() + public void Should_fail_with_descriptive_message_when_status_code_value_not_to_be_equal_to_a_different_value() { // Act Action action = () => From d19c8123a5383af7aaf25d46d49003beba8fe796 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:47:00 +0100 Subject: [PATCH 07/19] Protect against null values --- .../Primitives/HttpResponseMessageAssertions.cs | 14 ++++++++++++-- .../HttpResponseMessageAssertionSpecs.cs | 13 +++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index 29fdb6bbbb..9d176d32ee 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -1,6 +1,8 @@ -using System.Diagnostics; +using System; +using System.Diagnostics; using System.Net; using System.Net.Http; +using FluentAssertions.Common; using FluentAssertions.Execution; namespace FluentAssertions.Primitives @@ -12,6 +14,8 @@ namespace FluentAssertions.Primitives public class HttpResponseMessageAssertions : HttpResponseMessageAssertions { + /// Initializes a new instance of the class. + /// Thrown if is null public HttpResponseMessageAssertions(HttpResponseMessage value) : base(value) { @@ -25,7 +29,13 @@ public HttpResponseMessageAssertions(HttpResponseMessage value) public class HttpResponseMessageAssertions where TAssertions : HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(HttpResponseMessage value) => Subject = value; + /// Initializes a new instance of the class. + /// Thrown if is null + public HttpResponseMessageAssertions(HttpResponseMessage value) + { + Guard.ThrowIfArgumentIsNull(value, nameof(value)); + Subject = value; + } /// /// Gets the object which value is being asserted. diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index 451ada314f..9a6cccaab9 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -8,6 +8,19 @@ namespace FluentAssertions.Specs.Primitives { public class HttpResponseMessageAssertionSpecs { + [Fact] + public void Should_fail_when_testee_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().BeSuccessful(); + + // Assert + action.Should().Throw(); + } + [Theory] [InlineData(HttpStatusCode.OK)] [InlineData(HttpStatusCode.Accepted)] From fa303231bf80d7eecccf866ec9ff3935ed7700b2 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 10:48:46 +0100 Subject: [PATCH 08/19] Update documentation --- .../Primitives/HttpResponseMessageAssertions.cs | 4 ++-- docs/_data/navigation.yml | 2 ++ docs/_pages/httpresponsemessages.md | 12 ++++++------ 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index 9d176d32ee..c8d3f6b5bc 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -43,7 +43,7 @@ public HttpResponseMessageAssertions(HttpResponseMessage value) public HttpResponseMessage Subject { get; } /// - /// Asserts that the is successful. + /// Asserts that the is successful (2xx). /// /// /// A formatted phrase as is supported by explaining why the assertion @@ -63,7 +63,7 @@ public AndConstraint BeSuccessful(string because = "", params objec } /// - /// Asserts that the is redirection. + /// Asserts that the is redirection (3xx). /// /// /// A formatted phrase as is supported by explaining why the assertion diff --git a/docs/_data/navigation.yml b/docs/_data/navigation.yml index 51c26a1224..7e877d1823 100644 --- a/docs/_data/navigation.yml +++ b/docs/_data/navigation.yml @@ -73,6 +73,8 @@ sidebar: url: /xml - title: Execution Time url: /executiontime + - title: HttpResponseMessage + url: /httpresponsemessages - title: Extensibility url: /extensibility diff --git a/docs/_pages/httpresponsemessages.md b/docs/_pages/httpresponsemessages.md index 74a8b1faf1..96575c1087 100644 --- a/docs/_pages/httpresponsemessages.md +++ b/docs/_pages/httpresponsemessages.md @@ -9,18 +9,18 @@ nav: "sidebar" ```csharp var successfulResponse = new HttpResponseMessage(HttpStatusCode.OK); -successfulResponse.Should().BeSuccessful("it's set to 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"); +redirectResponse.Should().BeRedirection("it's set to Moved"); // (HttpStatusCode = 3xx) var clientErrorResponse = new HttpResponseMessage(HttpStatusCode.BadRequest); -clientErrorResponse.Should().BeClientError("it's set to BadRequest"); -clientErrorResponse.Should().BeError("it's set to 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().BeServerError("it's set to InternalServerError"); -serverErrorResponse.Should().BeError("it's set to 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); From 3f4a3ed19f23dee6664a1f7278d9fb6080faf1ad Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 11:10:23 +0100 Subject: [PATCH 09/19] Add API files again --- .../FluentAssertions/net47.verified.txt | 2653 ++++++++++++++++ .../netcoreapp2.1.verified.txt | 2655 +++++++++++++++++ .../netcoreapp3.0.verified.txt | 2655 +++++++++++++++++ .../netstandard2.0.verified.txt | 2606 ++++++++++++++++ .../netstandard2.1.verified.txt | 2655 +++++++++++++++++ 5 files changed, 13224 insertions(+) create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt new file mode 100644 index 0000000000..5d9083b720 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt @@ -0,0 +1,2653 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETFramework,Version=v4.7", FrameworkDisplayName=".NET Framework 4.7")] +namespace FluentAssertions +{ + public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions + { + public AggregateExceptionExtractor() { } + public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception { } + } + public class AndConstraint + { + public AndConstraint(T parentConstraint) { } + public T And { get; } + } + public class AndWhichConstraint : FluentAssertions.AndConstraint + { + public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } + public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } + public TMatchedElement Subject { get; } + public TMatchedElement Which { get; } + } + public static class AssertionExtensions + { + public static TTo As(this object subject) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Action Enumerating(this System.Func enumerable) { } + public static System.Action Enumerating(this System.Func> enumerable) { } + public static System.Action Enumerating(this T subject, System.Func> enumerable) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static System.Action Invoking(this T subject, System.Action action) { } + public static System.Func Invoking(this T subject, System.Func action) { } + public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } + public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } + public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } + public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } + public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } + public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } + public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } + public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } + public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } + 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) { } + public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } + public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } + public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } + public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } + public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } + public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } + public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } + public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } + public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } + public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } + public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) + where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.GuidAssertions _) + where TAssertions : FluentAssertions.Primitives.GuidAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } + public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } + public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } + public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } + public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } + public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Numeric.NumericAssertions _) + where TSubject : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.EnumAssertions _) + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } + public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) + where TCollection : System.Collections.Generic.IEnumerable> { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } + public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + public static class AsyncAssertionsExtensions + { + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + } + public static class AtLeast + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class AtMost + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class CallerIdentifier + { + public static System.Action Logger { get; set; } + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public static class DataRowAssertionExtensions + { + public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) + where TDataRow : System.Data.DataRow { } + } + public static class DataSetAssertionExtensions + { + public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) + where TDataSet : System.Data.DataSet { } + } + public static class DataTableAssertionExtensions + { + public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) + where TDataTable : System.Data.DataTable { } + } + public static class EnumAssertionsExtensions + { + public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) + where TEnum : struct, System.Enum { } + public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) + where TEnum : struct, System.Enum { } + } + public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyPlan() { } + public void Add() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void AddAfter() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Clear() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void Insert() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void InsertBefore() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Remove() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } + public void Reset() { } + } + public static class EventRaisingExtensions + { + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } + } + public static class Exactly + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class ExceptionAssertionsExtensions + { + public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + } + public static class FluentActions + { + public static System.Func Awaiting(System.Func action) { } + public static System.Func> Awaiting(System.Func> func) { } + public static System.Action Enumerating(System.Func enumerable) { } + public static System.Action Enumerating(System.Func> enumerable) { } + public static System.Action Invoking(System.Action action) { } + public static System.Func Invoking(System.Func func) { } + } + public static class LessThan + { + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class MoreThan + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class NumericAssertionsExtensions + { + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + } + public static class ObjectAssertionsExtensions + { + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + } + public abstract class OccurrenceConstraint + { + protected OccurrenceConstraint(int expectedCount) { } + } + public static class TypeEnumerableExtensions + { + public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } + } + public static class TypeExtensions + { + public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } + } + public static class XmlAssertionExtensions + { + public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } + public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } + } +} +namespace FluentAssertions.Collections +{ + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> + { + public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public GenericCollectionAssertions(TCollection actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } + protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params T[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } + public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } + public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } + public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } + public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } + public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } + public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } + public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + { + public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public StringCollectionAssertions(TCollection actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Equal(params string[] expected) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> + { + public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + } + public class WhoseValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhoseValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public class Configuration + { + public Configuration(FluentAssertions.Common.IConfigurationStore store) { } + public string TestFrameworkName { get; set; } + public string ValueFormatterAssembly { get; set; } + public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } + public static FluentAssertions.Common.Configuration Current { get; } + } + public static class DateTimeExtensions + { + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } + } + public interface IClock + { + void Delay(System.TimeSpan timeToDelay); + System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); + FluentAssertions.Common.ITimer StartTimer(); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer : System.IDisposable + { + System.TimeSpan Elapsed { get; } + } + public static class Services + { + public static FluentAssertions.Common.Configuration Configuration { get; } + public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } + public static FluentAssertions.Common.IReflector Reflector { get; set; } + public static System.Action ThrowException { get; set; } + public static void ResetToDefaults() { } + } + public delegate FluentAssertions.Common.ITimer StartTimer(); + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Data +{ + public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public DataColumnAssertions(System.Data.DataColumn dataColumn) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataRow : System.Data.DataRow + { + public DataRowAssertions(TDataRow dataRow) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + } + public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataSet : System.Data.DataSet + { + public DataSetAssertions(TDataSet dataSet) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } + public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } + } + public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataTable : System.Data.DataTable + { + public DataTableAssertions(TDataTable dataTable) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } + } + public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + { + FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); + } + public enum RowMatchMode + { + Index = 0, + PrimaryKey = 1, + } +} +namespace FluentAssertions.Equivalency +{ + public class Comparands + { + public Comparands() { } + public Comparands(object subject, object expectation, System.Type compileTimeType) { } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public System.Type RuntimeType { get; } + public object Subject { get; set; } + public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public override string ToString() { } + } + public class ConversionSelector + { + public ConversionSelector() { } + public FluentAssertions.Equivalency.ConversionSelector Clone() { } + public void Exclude(System.Linq.Expressions.Expression> predicate) { } + public void Include(System.Linq.Expressions.Expression> predicate) { } + public void IncludeAll() { } + public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public enum EqualityStrategy + { + Equals = 0, + Members = 1, + ForceEquals = 2, + ForceMembers = 3, + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + public EquivalencyAssertionOptions() { } + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> + { + public EquivalencyAssertionOptions() { } + public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public enum EquivalencyResult + { + ContinueWithNext = 0, + AssertionCompleted = 1, + } + public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + protected EquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext + { + public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.INode CurrentNode { get; } + public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + public FluentAssertions.Execution.Reason Reason { get; set; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } + public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } + public bool IsCyclicReference(object expectation) { } + public override string ToString() { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator() { } + public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; set; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public delegate string GetSubjectId(); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + FluentAssertions.Equivalency.INode SelectedNode { get; } + TSubject Subject { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + bool CompareRecordsByValue { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public interface IEquivalencyValidationContext + { + FluentAssertions.Equivalency.INode CurrentNode { get; } + FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + FluentAssertions.Execution.Reason Reason { get; } + FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); + FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); + bool IsCyclicReference(object expectation); + } + public interface IEquivalencyValidator + { + void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMember : FluentAssertions.Equivalency.INode + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + System.Type ReflectedType { get; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + object GetValue(object obj); + } + public interface IMemberInfo + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + string Name { get; } + string Path { get; set; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + System.Type Type { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); + } + public interface INode + { + int Depth { get; } + string Description { get; } + FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } + bool IsRoot { get; } + string Name { get; } + string Path { get; } + string PathAndName { get; } + bool RootIsCollection { get; } + System.Type Type { get; } + } + public interface IObjectInfo + { + System.Type CompileTimeType { get; } + string Path { get; set; } + System.Type RuntimeType { get; } + System.Type Type { get; } + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); + } + public static class MemberFactory + { + public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } + } + public class MemberSelectionContext + { + public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + public System.Type Type { get; } + } + [System.Flags] + public enum MemberVisibility + { + None = 0, + Internal = 1, + Public = 2, + } + public class Node : FluentAssertions.Equivalency.INode + { + public Node() { } + public int Depth { get; } + public virtual string Description { get; } + public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } + public bool IsRoot { get; } + public string Name { get; set; } + public string Path { get; set; } + public string PathAndName { get; } + public bool RootIsCollection { get; set; } + public System.Type Type { get; set; } + public override bool Equals(object obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } + public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } + public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } + } + public enum OrderStrictness + { + Strict = 0, + NotStrict = 1, + Irrelevant = 2, + } + public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public OrderingRuleCollection() { } + public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } + public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } + } + public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public bool CompareRecordsByValue { get; } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers(System.Type type) { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue(System.Type type) { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + public TSelf ComparingRecordsByMembers() { } + public TSelf ComparingRecordsByValue() { } + public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } + public TSelf ExcludingFields() { } + public TSelf ExcludingMissingMembers() { } + public TSelf ExcludingNestedObjects() { } + public TSelf ExcludingProperties() { } + public TSelf IgnoringCyclicReferences() { } + public TSelf Including(System.Linq.Expressions.Expression> predicate) { } + public TSelf IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + public TSelf IncludingInternalFields() { } + public TSelf IncludingInternalProperties() { } + public TSelf IncludingNestedObjects() { } + public TSelf IncludingProperties() { } + public TSelf RespectingDeclaredTypes() { } + public TSelf RespectingRuntimeTypes() { } + public TSelf ThrowingOnMissingMembers() { } + public override string ToString() { } + public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } + public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } + public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } + public TSelf Using() + where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } + public TSelf WithAutoConversion() { } + public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithStrictOrdering() { } + public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } + public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public void WithoutMatchingRules() { } + public void WithoutSelectionRules() { } + public TSelf WithoutStrictOrdering() { } + public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public class Restriction + { + public Restriction(TSelf options, System.Action> action) { } + public TSelf When(System.Linq.Expressions.Expression> predicate) { } + public TSelf WhenTypeIs() + where TMemberType : TMember { } + } + } + public static class SubjectInfoExtensions + { + public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + } +} +namespace FluentAssertions.Equivalency.Steps +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataColumnEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRelationEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataSetEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataTableEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DictionaryEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XAttributeEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XDocumentEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XElementEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } +} +namespace FluentAssertions.Equivalency.Tracing +{ + public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class Tracer + { + public override string ToString() { } + public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + } +} +namespace FluentAssertions.Events +{ + public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + { + protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } + protected override string Identifier { get; } + public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } + public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + } + public class EventMetadata + { + public EventMetadata(string eventName, System.Type handlerType) { } + public string EventName { get; } + public System.Type HandlerType { get; } + } + public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); + FluentAssertions.Events.EventAssertions Should(); + } + public class OccurredEvent + { + public OccurredEvent() { } + public string EventName { get; set; } + public object[] Parameters { get; set; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + [System.Serializable] + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(System.Lazy context) { } + public AssertionScope(string context) { } + public string CallerIdentity { get; } + public System.Lazy Context { get; set; } + public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } + public static FluentAssertions.Execution.AssertionScope Current { get; } + public void AddNonReportable(string key, object value) { } + public void AddPreFormattedFailure(string formattedFailureMessage) { } + public void AddReportable(string key, System.Func valueFunc) { } + public void AddReportable(string key, string value) { } + public void AssumeSingleCaller() { } + public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } + public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } + public T Get(string key) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public bool HasFailures() { } + public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } + } + public class Continuation + { + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } + } + public static class Execute + { + public static FluentAssertions.Execution.AssertionScope Assertion { get; } + } + public class FailReason + { + public FailReason(string message, params object[] args) { } + public object[] Args { get; } + public string Message { get; } + } + public class GivenSelector + { + public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + } + public interface IAssertionScope : System.IDisposable + { + FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); + FluentAssertions.Execution.Continuation ClearExpectation(); + string[] Discard(); + FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); + FluentAssertions.Execution.Continuation FailWith(string message); + FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); + FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); + FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); + FluentAssertions.Execution.GivenSelector Given(System.Func selector); + FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); + FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); + } + public interface IAssertionStrategy + { + System.Collections.Generic.IEnumerable FailureMessages { get; } + System.Collections.Generic.IEnumerable DiscardFailures(); + void HandleFailure(string message); + void ThrowIfAny(System.Collections.Generic.IDictionary context); + } + public interface ICloneable2 + { + object Clone(); + } + public class Reason + { + public Reason(string formattedMessage, object[] arguments) { } + public object[] Arguments { get; set; } + public string FormattedMessage { get; set; } + } +} +namespace FluentAssertions.Extensions +{ + public static class FluentDateTimeExtensions + { + public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } + public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } + public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } + public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } + public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime April(this int day, int year) { } + public static System.DateTime AsLocal(this System.DateTime dateTime) { } + public static System.DateTime AsUtc(this System.DateTime dateTime) { } + public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } + public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTime August(this int day, int year) { } + public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime December(this int day, int year) { } + public static System.DateTime February(this int day, int year) { } + public static System.DateTime January(this int day, int year) { } + public static System.DateTime July(this int day, int year) { } + public static System.DateTime June(this int day, int year) { } + public static System.DateTime March(this int day, int year) { } + public static System.DateTime May(this int day, int year) { } + public static int Microsecond(this System.DateTime self) { } + public static int Microsecond(this System.DateTimeOffset self) { } + public static int Nanosecond(this System.DateTime self) { } + public static int Nanosecond(this System.DateTimeOffset self) { } + public static System.DateTime November(this int day, int year) { } + public static System.DateTime October(this int day, int year) { } + public static System.DateTime September(this int day, int year) { } + public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } + } + public static class FluentTimeSpanExtensions + { + public const long TicksPerMicrosecond = 10; + public const double TicksPerNanosecond = 0.01D; + public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } + public static System.TimeSpan Days(this double days) { } + public static System.TimeSpan Days(this int days) { } + public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } + public static System.TimeSpan Hours(this double hours) { } + public static System.TimeSpan Hours(this int hours) { } + public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } + public static int Microseconds(this System.TimeSpan self) { } + public static System.TimeSpan Microseconds(this int microseconds) { } + public static System.TimeSpan Microseconds(this long microseconds) { } + public static System.TimeSpan Milliseconds(this double milliseconds) { } + public static System.TimeSpan Milliseconds(this int milliseconds) { } + public static System.TimeSpan Minutes(this double minutes) { } + public static System.TimeSpan Minutes(this int minutes) { } + public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } + public static int Nanoseconds(this System.TimeSpan self) { } + public static System.TimeSpan Nanoseconds(this int nanoseconds) { } + public static System.TimeSpan Nanoseconds(this long nanoseconds) { } + public static System.TimeSpan Seconds(this double seconds) { } + public static System.TimeSpan Seconds(this int seconds) { } + public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } + public static System.TimeSpan Ticks(this int ticks) { } + public static System.TimeSpan Ticks(this long ticks) { } + public static double TotalMicroseconds(this System.TimeSpan self) { } + public static double TotalNanoseconds(this System.TimeSpan self) { } + } +} +namespace FluentAssertions.Formatting +{ + public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AggregateExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DefaultValueFormatter() { } + protected virtual int SpacesPerIndentionLevel { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DictionaryValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumValueFormatter() { } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumerableValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); + public class FormattedObjectGraph + { + public FormattedObjectGraph(int maxLines) { } + public int LineCount { get; } + public static int SpacesPerIndentation { get; } + public void AddFragment(string fragment) { } + public void AddFragmentOnNewLine(string fragment) { } + public void AddLine(string line) { } + public override string ToString() { } + public System.IDisposable WithIndentation() { } + } + public static class Formatter + { + public static System.Collections.Generic.IEnumerable Formatters { get; } + public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } + } + public class FormattingContext + { + public FormattingContext() { } + public bool UseLineBreaks { get; set; } + } + public class FormattingOptions + { + public FormattingOptions() { } + public int MaxDepth { get; set; } + public int MaxLines { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MaxLinesExceededException : System.Exception + { + public MaxLinesExceededException() { } + public MaxLinesExceededException(string message) { } + public MaxLinesExceededException(string message, System.Exception innerException) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PredicateLambdaExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class ValueFormatterAttribute : System.Attribute + { + public ValueFormatterAttribute() { } + } + public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XAttributeValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlReaderValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} +namespace FluentAssertions.Numeric +{ + public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> + { + public ComparableTypeAssertions(System.IComparable value) { } + } + public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> + where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions + { + public ComparableTypeAssertions(System.IComparable value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> + where T : struct, System.IComparable + { + public NullableNumericAssertions(T? value) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions + { + public NullableNumericAssertions(T? value) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> + where T : struct, System.IComparable + { + public NumericAssertions(T value) { } + } + public class NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions + { + public NumericAssertions(T value) { } + public T? Subject { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Primitives +{ + public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + } + public class BooleanAssertions + where TAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + public bool? Subject { get; } + public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + } + public class DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + public System.DateTime? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + } + public class DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + public System.DateTimeOffset? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + } + public class DateTimeRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } + } + public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> + where TEnum : struct, System.Enum + { + public EnumAssertions(TEnum subject) { } + } + public class EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions + { + public EnumAssertions(TEnum subject) { } + public TEnum? Subject { get; } + public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } + } + public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + } + public class GuidAssertions + where TAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + public System.Guid? Subject { get; } + public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> + where TEnum : struct, System.Enum + { + public NullableEnumAssertions(TEnum? subject) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions + { + public NullableEnumAssertions(TEnum? subject) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions + where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(object value) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(TSubject value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public abstract class ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + protected ReferenceTypeAssertions(TSubject subject) { } + protected abstract string Identifier { get; } + public TSubject Subject { get; } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where T : TSubject { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } + } + public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + public System.TimeSpan? Subject { get; } + public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + } + public class StringAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + } + public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAll(params string[] values) { } + public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAny(params string[] values) { } + public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + } + public enum TimeSpanCondition + { + MoreThan = 0, + AtLeast = 1, + Exactly = 2, + Within = 3, + LessThan = 4, + } +} +namespace FluentAssertions.Reflection +{ + public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public AssemblyAssertions(System.Reflection.Assembly assembly) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Specialized +{ + public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions + { + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + } + public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> + where TTask : System.Threading.Tasks.Task + where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + { + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertions + { + protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } + protected abstract void InvokeSubject(); + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> + where TException : System.Exception + { + public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } + public TException And { get; } + protected override string Identifier { get; } + public TException Which { get; } + public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class ExecutionTime + { + public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } + public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + } + public class ExecutionTimeAssertions + { + public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + } + public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> + { + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + } + public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> + { + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } + } + public interface IExtractExceptions + { + System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception; + } + public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime + { + public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } + } + public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + } + public class TaskCompletionSourceAssertions + { + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Streams +{ + public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions + where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class StreamAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(System.IO.Stream stream) { } + } + public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.IO.Stream + where TAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(TSubject stream) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Types +{ + public static class AllTypes + { + public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } + } + public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } + protected override string Identifier { get; } + } + public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Reflection.MemberInfo + where TAssertions : FluentAssertions.Types.MemberInfoAssertions + { + protected MemberInfoAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + } + public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions + where TSubject : System.Reflection.MethodBase + where TAssertions : FluentAssertions.Types.MethodBaseAssertions + { + protected MethodBaseAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + } + public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } + } + public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } + public MethodInfoSelector(System.Type type) { } + public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } + public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } + public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } + public System.Reflection.MethodInfo[] ToArray() { } + } + public class MethodInfoSelectorAssertions + { + public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectMethods { get; } + public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions + { + public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } + public PropertyInfoSelector(System.Type type) { } + public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } + public FluentAssertions.Types.PropertyInfoSelector OfType() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public System.Reflection.PropertyInfo[] ToArray() { } + } + public class PropertyInfoSelectorAssertions + { + public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectProperties { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + } + public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public TypeAssertions(System.Type type) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) + where TInterface : class { } + } + public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public TypeSelector(System.Collections.Generic.IEnumerable types) { } + public TypeSelector(System.Type type) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAreClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } + public FluentAssertions.Types.TypeSelector ThatImplement() { } + public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } + public System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } + } + public class TypeSelectorAssertions + { + public TypeSelectorAssertions(params System.Type[] types) { } + public System.Collections.Generic.IEnumerable Subject { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Xml +{ + public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } + } + public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XDocumentAssertions(System.Xml.Linq.XDocument document) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + } + public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XElementAssertions(System.Xml.Linq.XElement xElement) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } + } + public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Xml.XmlNode + where TAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(TSubject xmlNode) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt new file mode 100644 index 0000000000..8646b74f54 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt @@ -0,0 +1,2655 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v2.1", FrameworkDisplayName="")] +namespace FluentAssertions +{ + public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions + { + public AggregateExceptionExtractor() { } + public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception { } + } + public class AndConstraint + { + public AndConstraint(T parentConstraint) { } + public T And { get; } + } + public class AndWhichConstraint : FluentAssertions.AndConstraint + { + public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } + public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } + public TMatchedElement Subject { get; } + public TMatchedElement Which { get; } + } + public static class AssertionExtensions + { + public static TTo As(this object subject) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Action Enumerating(this System.Func enumerable) { } + public static System.Action Enumerating(this System.Func> enumerable) { } + public static System.Action Enumerating(this T subject, System.Func> enumerable) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static System.Action Invoking(this T subject, System.Action action) { } + public static System.Func Invoking(this T subject, System.Func action) { } + public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } + public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } + public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } + public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } + public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } + public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } + public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } + public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } + public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } + 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) { } + public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } + public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } + public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } + public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } + public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } + public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } + public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } + public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } + public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } + public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } + public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) + where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.GuidAssertions _) + where TAssertions : FluentAssertions.Primitives.GuidAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } + public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } + public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } + public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } + public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } + public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Numeric.NumericAssertions _) + where TSubject : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.EnumAssertions _) + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } + public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) + where TCollection : System.Collections.Generic.IEnumerable> { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } + public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + public static class AsyncAssertionsExtensions + { + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + } + public static class AtLeast + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class AtMost + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class CallerIdentifier + { + public static System.Action Logger { get; set; } + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public static class DataRowAssertionExtensions + { + public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) + where TDataRow : System.Data.DataRow { } + } + public static class DataSetAssertionExtensions + { + public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) + where TDataSet : System.Data.DataSet { } + } + public static class DataTableAssertionExtensions + { + public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) + where TDataTable : System.Data.DataTable { } + } + public static class EnumAssertionsExtensions + { + public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) + where TEnum : struct, System.Enum { } + public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) + where TEnum : struct, System.Enum { } + } + public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyPlan() { } + public void Add() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void AddAfter() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Clear() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void Insert() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void InsertBefore() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Remove() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } + public void Reset() { } + } + public static class EventRaisingExtensions + { + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } + } + public static class Exactly + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class ExceptionAssertionsExtensions + { + public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + } + public static class FluentActions + { + public static System.Func Awaiting(System.Func action) { } + public static System.Func> Awaiting(System.Func> func) { } + public static System.Action Enumerating(System.Func enumerable) { } + public static System.Action Enumerating(System.Func> enumerable) { } + public static System.Action Invoking(System.Action action) { } + public static System.Func Invoking(System.Func func) { } + } + public static class LessThan + { + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class MoreThan + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class NumericAssertionsExtensions + { + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + } + public static class ObjectAssertionsExtensions + { + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + } + public abstract class OccurrenceConstraint + { + protected OccurrenceConstraint(int expectedCount) { } + } + public static class TypeEnumerableExtensions + { + public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } + } + public static class TypeExtensions + { + public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } + } + public static class XmlAssertionExtensions + { + public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } + public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } + } +} +namespace FluentAssertions.Collections +{ + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> + { + public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public GenericCollectionAssertions(TCollection actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } + protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params T[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } + public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } + public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } + public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } + public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } + public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } + public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } + public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + { + public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public StringCollectionAssertions(TCollection actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Equal(params string[] expected) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> + { + public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + } + public class WhoseValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhoseValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public class Configuration + { + public Configuration(FluentAssertions.Common.IConfigurationStore store) { } + public string TestFrameworkName { get; set; } + public string ValueFormatterAssembly { get; set; } + public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } + public static FluentAssertions.Common.Configuration Current { get; } + } + public static class DateTimeExtensions + { + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } + } + public interface IClock + { + void Delay(System.TimeSpan timeToDelay); + System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); + FluentAssertions.Common.ITimer StartTimer(); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer : System.IDisposable + { + System.TimeSpan Elapsed { get; } + } + public static class Services + { + public static FluentAssertions.Common.Configuration Configuration { get; } + public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } + public static FluentAssertions.Common.IReflector Reflector { get; set; } + public static System.Action ThrowException { get; set; } + public static void ResetToDefaults() { } + } + public delegate FluentAssertions.Common.ITimer StartTimer(); + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Data +{ + public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public DataColumnAssertions(System.Data.DataColumn dataColumn) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataRow : System.Data.DataRow + { + public DataRowAssertions(TDataRow dataRow) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + } + public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataSet : System.Data.DataSet + { + public DataSetAssertions(TDataSet dataSet) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } + public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } + } + public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataTable : System.Data.DataTable + { + public DataTableAssertions(TDataTable dataTable) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } + } + public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + { + FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); + } + public enum RowMatchMode + { + Index = 0, + PrimaryKey = 1, + } +} +namespace FluentAssertions.Equivalency +{ + public class Comparands + { + public Comparands() { } + public Comparands(object subject, object expectation, System.Type compileTimeType) { } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public System.Type RuntimeType { get; } + public object Subject { get; set; } + public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public override string ToString() { } + } + public class ConversionSelector + { + public ConversionSelector() { } + public FluentAssertions.Equivalency.ConversionSelector Clone() { } + public void Exclude(System.Linq.Expressions.Expression> predicate) { } + public void Include(System.Linq.Expressions.Expression> predicate) { } + public void IncludeAll() { } + public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public enum EqualityStrategy + { + Equals = 0, + Members = 1, + ForceEquals = 2, + ForceMembers = 3, + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + public EquivalencyAssertionOptions() { } + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> + { + public EquivalencyAssertionOptions() { } + public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public enum EquivalencyResult + { + ContinueWithNext = 0, + AssertionCompleted = 1, + } + public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + protected EquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext + { + public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.INode CurrentNode { get; } + public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + public FluentAssertions.Execution.Reason Reason { get; set; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } + public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } + public bool IsCyclicReference(object expectation) { } + public override string ToString() { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator() { } + public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; set; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public delegate string GetSubjectId(); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + FluentAssertions.Equivalency.INode SelectedNode { get; } + TSubject Subject { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + bool CompareRecordsByValue { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public interface IEquivalencyValidationContext + { + FluentAssertions.Equivalency.INode CurrentNode { get; } + FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + FluentAssertions.Execution.Reason Reason { get; } + FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); + FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); + bool IsCyclicReference(object expectation); + } + public interface IEquivalencyValidator + { + void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMember : FluentAssertions.Equivalency.INode + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + System.Type ReflectedType { get; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + object GetValue(object obj); + } + public interface IMemberInfo + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + string Name { get; } + string Path { get; set; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + System.Type Type { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); + } + public interface INode + { + int Depth { get; } + string Description { get; } + FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } + bool IsRoot { get; } + string Name { get; } + string Path { get; } + string PathAndName { get; } + bool RootIsCollection { get; } + System.Type Type { get; } + } + public interface IObjectInfo + { + System.Type CompileTimeType { get; } + string Path { get; set; } + System.Type RuntimeType { get; } + System.Type Type { get; } + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); + } + public static class MemberFactory + { + public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } + } + public class MemberSelectionContext + { + public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + public System.Type Type { get; } + } + [System.Flags] + public enum MemberVisibility + { + None = 0, + Internal = 1, + Public = 2, + } + public class Node : FluentAssertions.Equivalency.INode + { + public Node() { } + public int Depth { get; } + public virtual string Description { get; } + public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } + public bool IsRoot { get; } + public string Name { get; set; } + public string Path { get; set; } + public string PathAndName { get; } + public bool RootIsCollection { get; set; } + public System.Type Type { get; set; } + public override bool Equals(object obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } + public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } + public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } + } + public enum OrderStrictness + { + Strict = 0, + NotStrict = 1, + Irrelevant = 2, + } + public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public OrderingRuleCollection() { } + public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } + public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } + } + public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public bool CompareRecordsByValue { get; } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers(System.Type type) { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue(System.Type type) { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + public TSelf ComparingRecordsByMembers() { } + public TSelf ComparingRecordsByValue() { } + public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } + public TSelf ExcludingFields() { } + public TSelf ExcludingMissingMembers() { } + public TSelf ExcludingNestedObjects() { } + public TSelf ExcludingProperties() { } + public TSelf IgnoringCyclicReferences() { } + public TSelf Including(System.Linq.Expressions.Expression> predicate) { } + public TSelf IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + public TSelf IncludingInternalFields() { } + public TSelf IncludingInternalProperties() { } + public TSelf IncludingNestedObjects() { } + public TSelf IncludingProperties() { } + public TSelf RespectingDeclaredTypes() { } + public TSelf RespectingRuntimeTypes() { } + public TSelf ThrowingOnMissingMembers() { } + public override string ToString() { } + public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } + public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } + public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } + public TSelf Using() + where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } + public TSelf WithAutoConversion() { } + public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithStrictOrdering() { } + public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } + public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public void WithoutMatchingRules() { } + public void WithoutSelectionRules() { } + public TSelf WithoutStrictOrdering() { } + public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public class Restriction + { + public Restriction(TSelf options, System.Action> action) { } + public TSelf When(System.Linq.Expressions.Expression> predicate) { } + public TSelf WhenTypeIs() + where TMemberType : TMember { } + } + } + public static class SubjectInfoExtensions + { + public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + } +} +namespace FluentAssertions.Equivalency.Steps +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataColumnEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRelationEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataSetEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataTableEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DictionaryEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XAttributeEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XDocumentEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XElementEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } +} +namespace FluentAssertions.Equivalency.Tracing +{ + public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class Tracer + { + public override string ToString() { } + public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + } +} +namespace FluentAssertions.Events +{ + public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + { + protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } + protected override string Identifier { get; } + public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } + public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + } + public class EventMetadata + { + public EventMetadata(string eventName, System.Type handlerType) { } + public string EventName { get; } + public System.Type HandlerType { get; } + } + public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); + FluentAssertions.Events.EventAssertions Should(); + } + public class OccurredEvent + { + public OccurredEvent() { } + public string EventName { get; set; } + public object[] Parameters { get; set; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + [System.Serializable] + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(System.Lazy context) { } + public AssertionScope(string context) { } + public string CallerIdentity { get; } + public System.Lazy Context { get; set; } + public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } + public static FluentAssertions.Execution.AssertionScope Current { get; } + public void AddNonReportable(string key, object value) { } + public void AddPreFormattedFailure(string formattedFailureMessage) { } + public void AddReportable(string key, System.Func valueFunc) { } + public void AddReportable(string key, string value) { } + public void AssumeSingleCaller() { } + public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } + public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } + public T Get(string key) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public bool HasFailures() { } + public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } + } + public class Continuation + { + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } + } + public static class Execute + { + public static FluentAssertions.Execution.AssertionScope Assertion { get; } + } + public class FailReason + { + public FailReason(string message, params object[] args) { } + public object[] Args { get; } + public string Message { get; } + } + public class GivenSelector + { + public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + } + public interface IAssertionScope : System.IDisposable + { + FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); + FluentAssertions.Execution.Continuation ClearExpectation(); + string[] Discard(); + FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); + FluentAssertions.Execution.Continuation FailWith(string message); + FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); + FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); + FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); + FluentAssertions.Execution.GivenSelector Given(System.Func selector); + FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); + FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); + } + public interface IAssertionStrategy + { + System.Collections.Generic.IEnumerable FailureMessages { get; } + System.Collections.Generic.IEnumerable DiscardFailures(); + void HandleFailure(string message); + void ThrowIfAny(System.Collections.Generic.IDictionary context); + } + public interface ICloneable2 + { + object Clone(); + } + public class Reason + { + public Reason(string formattedMessage, object[] arguments) { } + public object[] Arguments { get; set; } + public string FormattedMessage { get; set; } + } +} +namespace FluentAssertions.Extensions +{ + public static class FluentDateTimeExtensions + { + public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } + public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } + public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } + public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } + public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime April(this int day, int year) { } + public static System.DateTime AsLocal(this System.DateTime dateTime) { } + public static System.DateTime AsUtc(this System.DateTime dateTime) { } + public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } + public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTime August(this int day, int year) { } + public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime December(this int day, int year) { } + public static System.DateTime February(this int day, int year) { } + public static System.DateTime January(this int day, int year) { } + public static System.DateTime July(this int day, int year) { } + public static System.DateTime June(this int day, int year) { } + public static System.DateTime March(this int day, int year) { } + public static System.DateTime May(this int day, int year) { } + public static int Microsecond(this System.DateTime self) { } + public static int Microsecond(this System.DateTimeOffset self) { } + public static int Nanosecond(this System.DateTime self) { } + public static int Nanosecond(this System.DateTimeOffset self) { } + public static System.DateTime November(this int day, int year) { } + public static System.DateTime October(this int day, int year) { } + public static System.DateTime September(this int day, int year) { } + public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } + } + public static class FluentTimeSpanExtensions + { + public const long TicksPerMicrosecond = 10; + public const double TicksPerNanosecond = 0.01D; + public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } + public static System.TimeSpan Days(this double days) { } + public static System.TimeSpan Days(this int days) { } + public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } + public static System.TimeSpan Hours(this double hours) { } + public static System.TimeSpan Hours(this int hours) { } + public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } + public static int Microseconds(this System.TimeSpan self) { } + public static System.TimeSpan Microseconds(this int microseconds) { } + public static System.TimeSpan Microseconds(this long microseconds) { } + public static System.TimeSpan Milliseconds(this double milliseconds) { } + public static System.TimeSpan Milliseconds(this int milliseconds) { } + public static System.TimeSpan Minutes(this double minutes) { } + public static System.TimeSpan Minutes(this int minutes) { } + public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } + public static int Nanoseconds(this System.TimeSpan self) { } + public static System.TimeSpan Nanoseconds(this int nanoseconds) { } + public static System.TimeSpan Nanoseconds(this long nanoseconds) { } + public static System.TimeSpan Seconds(this double seconds) { } + public static System.TimeSpan Seconds(this int seconds) { } + public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } + public static System.TimeSpan Ticks(this int ticks) { } + public static System.TimeSpan Ticks(this long ticks) { } + public static double TotalMicroseconds(this System.TimeSpan self) { } + public static double TotalNanoseconds(this System.TimeSpan self) { } + } +} +namespace FluentAssertions.Formatting +{ + public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AggregateExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DefaultValueFormatter() { } + protected virtual int SpacesPerIndentionLevel { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DictionaryValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumValueFormatter() { } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumerableValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); + public class FormattedObjectGraph + { + public FormattedObjectGraph(int maxLines) { } + public int LineCount { get; } + public static int SpacesPerIndentation { get; } + public void AddFragment(string fragment) { } + public void AddFragmentOnNewLine(string fragment) { } + public void AddLine(string line) { } + public override string ToString() { } + public System.IDisposable WithIndentation() { } + } + public static class Formatter + { + public static System.Collections.Generic.IEnumerable Formatters { get; } + public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } + } + public class FormattingContext + { + public FormattingContext() { } + public bool UseLineBreaks { get; set; } + } + public class FormattingOptions + { + public FormattingOptions() { } + public int MaxDepth { get; set; } + public int MaxLines { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MaxLinesExceededException : System.Exception + { + public MaxLinesExceededException() { } + public MaxLinesExceededException(string message) { } + public MaxLinesExceededException(string message, System.Exception innerException) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PredicateLambdaExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class ValueFormatterAttribute : System.Attribute + { + public ValueFormatterAttribute() { } + } + public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XAttributeValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlReaderValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} +namespace FluentAssertions.Numeric +{ + public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> + { + public ComparableTypeAssertions(System.IComparable value) { } + } + public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> + where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions + { + public ComparableTypeAssertions(System.IComparable value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> + where T : struct, System.IComparable + { + public NullableNumericAssertions(T? value) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions + { + public NullableNumericAssertions(T? value) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> + where T : struct, System.IComparable + { + public NumericAssertions(T value) { } + } + public class NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions + { + public NumericAssertions(T value) { } + public T? Subject { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Primitives +{ + public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + } + public class BooleanAssertions + where TAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + public bool? Subject { get; } + public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + } + public class DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + public System.DateTime? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + } + public class DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + public System.DateTimeOffset? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + } + public class DateTimeRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } + } + public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> + where TEnum : struct, System.Enum + { + public EnumAssertions(TEnum subject) { } + } + public class EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions + { + public EnumAssertions(TEnum subject) { } + public TEnum? Subject { get; } + public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } + } + public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + } + public class GuidAssertions + where TAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + public System.Guid? Subject { get; } + public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> + where TEnum : struct, System.Enum + { + public NullableEnumAssertions(TEnum? subject) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions + { + public NullableEnumAssertions(TEnum? subject) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions + where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(object value) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(TSubject value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public abstract class ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + protected ReferenceTypeAssertions(TSubject subject) { } + protected abstract string Identifier { get; } + public TSubject Subject { get; } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where T : TSubject { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } + } + public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + public System.TimeSpan? Subject { get; } + public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + } + public class StringAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + } + public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAll(params string[] values) { } + public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAny(params string[] values) { } + public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + } + public enum TimeSpanCondition + { + MoreThan = 0, + AtLeast = 1, + Exactly = 2, + Within = 3, + LessThan = 4, + } +} +namespace FluentAssertions.Reflection +{ + public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public AssemblyAssertions(System.Reflection.Assembly assembly) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Specialized +{ + public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions + { + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + } + public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> + where TTask : System.Threading.Tasks.Task + where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + { + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertions + { + protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } + protected abstract void InvokeSubject(); + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> + where TException : System.Exception + { + public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } + public TException And { get; } + protected override string Identifier { get; } + public TException Which { get; } + public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class ExecutionTime + { + public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } + public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + } + public class ExecutionTimeAssertions + { + public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + } + public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> + { + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + } + public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> + { + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } + } + public interface IExtractExceptions + { + System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception; + } + public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime + { + public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } + } + public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + } + public class TaskCompletionSourceAssertions + { + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Streams +{ + public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions + where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class StreamAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(System.IO.Stream stream) { } + } + public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.IO.Stream + where TAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(TSubject stream) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Types +{ + public static class AllTypes + { + public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } + } + public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } + protected override string Identifier { get; } + } + public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Reflection.MemberInfo + where TAssertions : FluentAssertions.Types.MemberInfoAssertions + { + protected MemberInfoAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + } + public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions + where TSubject : System.Reflection.MethodBase + where TAssertions : FluentAssertions.Types.MethodBaseAssertions + { + protected MethodBaseAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + } + public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } + } + public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } + public MethodInfoSelector(System.Type type) { } + public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } + public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } + public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } + public System.Reflection.MethodInfo[] ToArray() { } + } + public class MethodInfoSelectorAssertions + { + public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectMethods { get; } + public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions + { + public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } + public PropertyInfoSelector(System.Type type) { } + public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } + public FluentAssertions.Types.PropertyInfoSelector OfType() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public System.Reflection.PropertyInfo[] ToArray() { } + } + public class PropertyInfoSelectorAssertions + { + public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectProperties { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + } + public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public TypeAssertions(System.Type type) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) + where TInterface : class { } + } + public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public TypeSelector(System.Collections.Generic.IEnumerable types) { } + public TypeSelector(System.Type type) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAreClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } + public FluentAssertions.Types.TypeSelector ThatImplement() { } + public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } + public System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } + } + public class TypeSelectorAssertions + { + public TypeSelectorAssertions(params System.Type[] types) { } + public System.Collections.Generic.IEnumerable Subject { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Xml +{ + public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } + } + public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XDocumentAssertions(System.Xml.Linq.XDocument document) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + } + public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XElementAssertions(System.Xml.Linq.XElement xElement) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } + } + public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Xml.XmlNode + where TAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(TSubject xmlNode) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt new file mode 100644 index 0000000000..631c9a5dad --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt @@ -0,0 +1,2655 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v3.0", FrameworkDisplayName="")] +namespace FluentAssertions +{ + public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions + { + public AggregateExceptionExtractor() { } + public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception { } + } + public class AndConstraint + { + public AndConstraint(T parentConstraint) { } + public T And { get; } + } + public class AndWhichConstraint : FluentAssertions.AndConstraint + { + public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } + public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } + public TMatchedElement Subject { get; } + public TMatchedElement Which { get; } + } + public static class AssertionExtensions + { + public static TTo As(this object subject) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Action Enumerating(this System.Func enumerable) { } + public static System.Action Enumerating(this System.Func> enumerable) { } + public static System.Action Enumerating(this T subject, System.Func> enumerable) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static System.Action Invoking(this T subject, System.Action action) { } + public static System.Func Invoking(this T subject, System.Func action) { } + public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } + public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } + public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } + public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } + public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } + public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } + public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } + public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } + public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } + 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) { } + public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } + public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } + public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } + public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } + public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } + public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } + public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } + public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } + public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } + public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } + public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) + where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.GuidAssertions _) + where TAssertions : FluentAssertions.Primitives.GuidAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } + public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } + public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } + public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } + public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } + public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Numeric.NumericAssertions _) + where TSubject : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.EnumAssertions _) + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } + public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) + where TCollection : System.Collections.Generic.IEnumerable> { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } + public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + public static class AsyncAssertionsExtensions + { + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + } + public static class AtLeast + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class AtMost + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class CallerIdentifier + { + public static System.Action Logger { get; set; } + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public static class DataRowAssertionExtensions + { + public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) + where TDataRow : System.Data.DataRow { } + } + public static class DataSetAssertionExtensions + { + public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) + where TDataSet : System.Data.DataSet { } + } + public static class DataTableAssertionExtensions + { + public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) + where TDataTable : System.Data.DataTable { } + } + public static class EnumAssertionsExtensions + { + public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) + where TEnum : struct, System.Enum { } + public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) + where TEnum : struct, System.Enum { } + } + public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyPlan() { } + public void Add() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void AddAfter() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Clear() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void Insert() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void InsertBefore() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Remove() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } + public void Reset() { } + } + public static class EventRaisingExtensions + { + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } + } + public static class Exactly + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class ExceptionAssertionsExtensions + { + public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + } + public static class FluentActions + { + public static System.Func Awaiting(System.Func action) { } + public static System.Func> Awaiting(System.Func> func) { } + public static System.Action Enumerating(System.Func enumerable) { } + public static System.Action Enumerating(System.Func> enumerable) { } + public static System.Action Invoking(System.Action action) { } + public static System.Func Invoking(System.Func func) { } + } + public static class LessThan + { + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class MoreThan + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class NumericAssertionsExtensions + { + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + } + public static class ObjectAssertionsExtensions + { + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + } + public abstract class OccurrenceConstraint + { + protected OccurrenceConstraint(int expectedCount) { } + } + public static class TypeEnumerableExtensions + { + public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } + } + public static class TypeExtensions + { + public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } + } + public static class XmlAssertionExtensions + { + public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } + public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } + } +} +namespace FluentAssertions.Collections +{ + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> + { + public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public GenericCollectionAssertions(TCollection actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } + protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params T[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } + public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } + public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } + public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } + public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } + public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } + public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } + public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + { + public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public StringCollectionAssertions(TCollection actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Equal(params string[] expected) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> + { + public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + } + public class WhoseValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhoseValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public class Configuration + { + public Configuration(FluentAssertions.Common.IConfigurationStore store) { } + public string TestFrameworkName { get; set; } + public string ValueFormatterAssembly { get; set; } + public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } + public static FluentAssertions.Common.Configuration Current { get; } + } + public static class DateTimeExtensions + { + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } + } + public interface IClock + { + void Delay(System.TimeSpan timeToDelay); + System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); + FluentAssertions.Common.ITimer StartTimer(); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer : System.IDisposable + { + System.TimeSpan Elapsed { get; } + } + public static class Services + { + public static FluentAssertions.Common.Configuration Configuration { get; } + public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } + public static FluentAssertions.Common.IReflector Reflector { get; set; } + public static System.Action ThrowException { get; set; } + public static void ResetToDefaults() { } + } + public delegate FluentAssertions.Common.ITimer StartTimer(); + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Data +{ + public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public DataColumnAssertions(System.Data.DataColumn dataColumn) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataRow : System.Data.DataRow + { + public DataRowAssertions(TDataRow dataRow) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + } + public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataSet : System.Data.DataSet + { + public DataSetAssertions(TDataSet dataSet) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } + public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } + } + public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataTable : System.Data.DataTable + { + public DataTableAssertions(TDataTable dataTable) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } + } + public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + { + FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); + } + public enum RowMatchMode + { + Index = 0, + PrimaryKey = 1, + } +} +namespace FluentAssertions.Equivalency +{ + public class Comparands + { + public Comparands() { } + public Comparands(object subject, object expectation, System.Type compileTimeType) { } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public System.Type RuntimeType { get; } + public object Subject { get; set; } + public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public override string ToString() { } + } + public class ConversionSelector + { + public ConversionSelector() { } + public FluentAssertions.Equivalency.ConversionSelector Clone() { } + public void Exclude(System.Linq.Expressions.Expression> predicate) { } + public void Include(System.Linq.Expressions.Expression> predicate) { } + public void IncludeAll() { } + public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public enum EqualityStrategy + { + Equals = 0, + Members = 1, + ForceEquals = 2, + ForceMembers = 3, + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + public EquivalencyAssertionOptions() { } + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> + { + public EquivalencyAssertionOptions() { } + public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public enum EquivalencyResult + { + ContinueWithNext = 0, + AssertionCompleted = 1, + } + public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + protected EquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext + { + public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.INode CurrentNode { get; } + public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + public FluentAssertions.Execution.Reason Reason { get; set; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } + public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } + public bool IsCyclicReference(object expectation) { } + public override string ToString() { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator() { } + public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; set; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public delegate string GetSubjectId(); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + FluentAssertions.Equivalency.INode SelectedNode { get; } + TSubject Subject { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + bool CompareRecordsByValue { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public interface IEquivalencyValidationContext + { + FluentAssertions.Equivalency.INode CurrentNode { get; } + FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + FluentAssertions.Execution.Reason Reason { get; } + FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); + FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); + bool IsCyclicReference(object expectation); + } + public interface IEquivalencyValidator + { + void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMember : FluentAssertions.Equivalency.INode + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + System.Type ReflectedType { get; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + object GetValue(object obj); + } + public interface IMemberInfo + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + string Name { get; } + string Path { get; set; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + System.Type Type { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); + } + public interface INode + { + int Depth { get; } + string Description { get; } + FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } + bool IsRoot { get; } + string Name { get; } + string Path { get; } + string PathAndName { get; } + bool RootIsCollection { get; } + System.Type Type { get; } + } + public interface IObjectInfo + { + System.Type CompileTimeType { get; } + string Path { get; set; } + System.Type RuntimeType { get; } + System.Type Type { get; } + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); + } + public static class MemberFactory + { + public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } + } + public class MemberSelectionContext + { + public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + public System.Type Type { get; } + } + [System.Flags] + public enum MemberVisibility + { + None = 0, + Internal = 1, + Public = 2, + } + public class Node : FluentAssertions.Equivalency.INode + { + public Node() { } + public int Depth { get; } + public virtual string Description { get; } + public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } + public bool IsRoot { get; } + public string Name { get; set; } + public string Path { get; set; } + public string PathAndName { get; } + public bool RootIsCollection { get; set; } + public System.Type Type { get; set; } + public override bool Equals(object obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } + public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } + public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } + } + public enum OrderStrictness + { + Strict = 0, + NotStrict = 1, + Irrelevant = 2, + } + public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public OrderingRuleCollection() { } + public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } + public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } + } + public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public bool CompareRecordsByValue { get; } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers(System.Type type) { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue(System.Type type) { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + public TSelf ComparingRecordsByMembers() { } + public TSelf ComparingRecordsByValue() { } + public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } + public TSelf ExcludingFields() { } + public TSelf ExcludingMissingMembers() { } + public TSelf ExcludingNestedObjects() { } + public TSelf ExcludingProperties() { } + public TSelf IgnoringCyclicReferences() { } + public TSelf Including(System.Linq.Expressions.Expression> predicate) { } + public TSelf IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + public TSelf IncludingInternalFields() { } + public TSelf IncludingInternalProperties() { } + public TSelf IncludingNestedObjects() { } + public TSelf IncludingProperties() { } + public TSelf RespectingDeclaredTypes() { } + public TSelf RespectingRuntimeTypes() { } + public TSelf ThrowingOnMissingMembers() { } + public override string ToString() { } + public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } + public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } + public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } + public TSelf Using() + where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } + public TSelf WithAutoConversion() { } + public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithStrictOrdering() { } + public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } + public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public void WithoutMatchingRules() { } + public void WithoutSelectionRules() { } + public TSelf WithoutStrictOrdering() { } + public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public class Restriction + { + public Restriction(TSelf options, System.Action> action) { } + public TSelf When(System.Linq.Expressions.Expression> predicate) { } + public TSelf WhenTypeIs() + where TMemberType : TMember { } + } + } + public static class SubjectInfoExtensions + { + public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + } +} +namespace FluentAssertions.Equivalency.Steps +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataColumnEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRelationEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataSetEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataTableEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DictionaryEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XAttributeEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XDocumentEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XElementEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } +} +namespace FluentAssertions.Equivalency.Tracing +{ + public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class Tracer + { + public override string ToString() { } + public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + } +} +namespace FluentAssertions.Events +{ + public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + { + protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } + protected override string Identifier { get; } + public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } + public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + } + public class EventMetadata + { + public EventMetadata(string eventName, System.Type handlerType) { } + public string EventName { get; } + public System.Type HandlerType { get; } + } + public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); + FluentAssertions.Events.EventAssertions Should(); + } + public class OccurredEvent + { + public OccurredEvent() { } + public string EventName { get; set; } + public object[] Parameters { get; set; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + [System.Serializable] + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(System.Lazy context) { } + public AssertionScope(string context) { } + public string CallerIdentity { get; } + public System.Lazy Context { get; set; } + public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } + public static FluentAssertions.Execution.AssertionScope Current { get; } + public void AddNonReportable(string key, object value) { } + public void AddPreFormattedFailure(string formattedFailureMessage) { } + public void AddReportable(string key, System.Func valueFunc) { } + public void AddReportable(string key, string value) { } + public void AssumeSingleCaller() { } + public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } + public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } + public T Get(string key) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public bool HasFailures() { } + public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } + } + public class Continuation + { + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } + } + public static class Execute + { + public static FluentAssertions.Execution.AssertionScope Assertion { get; } + } + public class FailReason + { + public FailReason(string message, params object[] args) { } + public object[] Args { get; } + public string Message { get; } + } + public class GivenSelector + { + public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + } + public interface IAssertionScope : System.IDisposable + { + FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); + FluentAssertions.Execution.Continuation ClearExpectation(); + string[] Discard(); + FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); + FluentAssertions.Execution.Continuation FailWith(string message); + FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); + FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); + FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); + FluentAssertions.Execution.GivenSelector Given(System.Func selector); + FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); + FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); + } + public interface IAssertionStrategy + { + System.Collections.Generic.IEnumerable FailureMessages { get; } + System.Collections.Generic.IEnumerable DiscardFailures(); + void HandleFailure(string message); + void ThrowIfAny(System.Collections.Generic.IDictionary context); + } + public interface ICloneable2 + { + object Clone(); + } + public class Reason + { + public Reason(string formattedMessage, object[] arguments) { } + public object[] Arguments { get; set; } + public string FormattedMessage { get; set; } + } +} +namespace FluentAssertions.Extensions +{ + public static class FluentDateTimeExtensions + { + public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } + public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } + public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } + public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } + public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime April(this int day, int year) { } + public static System.DateTime AsLocal(this System.DateTime dateTime) { } + public static System.DateTime AsUtc(this System.DateTime dateTime) { } + public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } + public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTime August(this int day, int year) { } + public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime December(this int day, int year) { } + public static System.DateTime February(this int day, int year) { } + public static System.DateTime January(this int day, int year) { } + public static System.DateTime July(this int day, int year) { } + public static System.DateTime June(this int day, int year) { } + public static System.DateTime March(this int day, int year) { } + public static System.DateTime May(this int day, int year) { } + public static int Microsecond(this System.DateTime self) { } + public static int Microsecond(this System.DateTimeOffset self) { } + public static int Nanosecond(this System.DateTime self) { } + public static int Nanosecond(this System.DateTimeOffset self) { } + public static System.DateTime November(this int day, int year) { } + public static System.DateTime October(this int day, int year) { } + public static System.DateTime September(this int day, int year) { } + public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } + } + public static class FluentTimeSpanExtensions + { + public const long TicksPerMicrosecond = 10; + public const double TicksPerNanosecond = 0.01D; + public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } + public static System.TimeSpan Days(this double days) { } + public static System.TimeSpan Days(this int days) { } + public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } + public static System.TimeSpan Hours(this double hours) { } + public static System.TimeSpan Hours(this int hours) { } + public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } + public static int Microseconds(this System.TimeSpan self) { } + public static System.TimeSpan Microseconds(this int microseconds) { } + public static System.TimeSpan Microseconds(this long microseconds) { } + public static System.TimeSpan Milliseconds(this double milliseconds) { } + public static System.TimeSpan Milliseconds(this int milliseconds) { } + public static System.TimeSpan Minutes(this double minutes) { } + public static System.TimeSpan Minutes(this int minutes) { } + public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } + public static int Nanoseconds(this System.TimeSpan self) { } + public static System.TimeSpan Nanoseconds(this int nanoseconds) { } + public static System.TimeSpan Nanoseconds(this long nanoseconds) { } + public static System.TimeSpan Seconds(this double seconds) { } + public static System.TimeSpan Seconds(this int seconds) { } + public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } + public static System.TimeSpan Ticks(this int ticks) { } + public static System.TimeSpan Ticks(this long ticks) { } + public static double TotalMicroseconds(this System.TimeSpan self) { } + public static double TotalNanoseconds(this System.TimeSpan self) { } + } +} +namespace FluentAssertions.Formatting +{ + public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AggregateExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DefaultValueFormatter() { } + protected virtual int SpacesPerIndentionLevel { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DictionaryValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumValueFormatter() { } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumerableValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); + public class FormattedObjectGraph + { + public FormattedObjectGraph(int maxLines) { } + public int LineCount { get; } + public static int SpacesPerIndentation { get; } + public void AddFragment(string fragment) { } + public void AddFragmentOnNewLine(string fragment) { } + public void AddLine(string line) { } + public override string ToString() { } + public System.IDisposable WithIndentation() { } + } + public static class Formatter + { + public static System.Collections.Generic.IEnumerable Formatters { get; } + public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } + } + public class FormattingContext + { + public FormattingContext() { } + public bool UseLineBreaks { get; set; } + } + public class FormattingOptions + { + public FormattingOptions() { } + public int MaxDepth { get; set; } + public int MaxLines { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MaxLinesExceededException : System.Exception + { + public MaxLinesExceededException() { } + public MaxLinesExceededException(string message) { } + public MaxLinesExceededException(string message, System.Exception innerException) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PredicateLambdaExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class ValueFormatterAttribute : System.Attribute + { + public ValueFormatterAttribute() { } + } + public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XAttributeValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlReaderValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} +namespace FluentAssertions.Numeric +{ + public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> + { + public ComparableTypeAssertions(System.IComparable value) { } + } + public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> + where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions + { + public ComparableTypeAssertions(System.IComparable value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> + where T : struct, System.IComparable + { + public NullableNumericAssertions(T? value) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions + { + public NullableNumericAssertions(T? value) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> + where T : struct, System.IComparable + { + public NumericAssertions(T value) { } + } + public class NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions + { + public NumericAssertions(T value) { } + public T? Subject { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Primitives +{ + public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + } + public class BooleanAssertions + where TAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + public bool? Subject { get; } + public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + } + public class DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + public System.DateTime? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + } + public class DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + public System.DateTimeOffset? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + } + public class DateTimeRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } + } + public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> + where TEnum : struct, System.Enum + { + public EnumAssertions(TEnum subject) { } + } + public class EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions + { + public EnumAssertions(TEnum subject) { } + public TEnum? Subject { get; } + public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } + } + public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + } + public class GuidAssertions + where TAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + public System.Guid? Subject { get; } + public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> + where TEnum : struct, System.Enum + { + public NullableEnumAssertions(TEnum? subject) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions + { + public NullableEnumAssertions(TEnum? subject) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions + where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(object value) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(TSubject value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public abstract class ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + protected ReferenceTypeAssertions(TSubject subject) { } + protected abstract string Identifier { get; } + public TSubject Subject { get; } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where T : TSubject { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } + } + public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + public System.TimeSpan? Subject { get; } + public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + } + public class StringAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + } + public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAll(params string[] values) { } + public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAny(params string[] values) { } + public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + } + public enum TimeSpanCondition + { + MoreThan = 0, + AtLeast = 1, + Exactly = 2, + Within = 3, + LessThan = 4, + } +} +namespace FluentAssertions.Reflection +{ + public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public AssemblyAssertions(System.Reflection.Assembly assembly) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Specialized +{ + public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions + { + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + } + public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> + where TTask : System.Threading.Tasks.Task + where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + { + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertions + { + protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } + protected abstract void InvokeSubject(); + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> + where TException : System.Exception + { + public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } + public TException And { get; } + protected override string Identifier { get; } + public TException Which { get; } + public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class ExecutionTime + { + public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } + public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + } + public class ExecutionTimeAssertions + { + public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + } + public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> + { + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + } + public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> + { + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } + } + public interface IExtractExceptions + { + System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception; + } + public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime + { + public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } + } + public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + } + public class TaskCompletionSourceAssertions + { + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Streams +{ + public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions + where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class StreamAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(System.IO.Stream stream) { } + } + public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.IO.Stream + where TAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(TSubject stream) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Types +{ + public static class AllTypes + { + public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } + } + public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } + protected override string Identifier { get; } + } + public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Reflection.MemberInfo + where TAssertions : FluentAssertions.Types.MemberInfoAssertions + { + protected MemberInfoAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + } + public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions + where TSubject : System.Reflection.MethodBase + where TAssertions : FluentAssertions.Types.MethodBaseAssertions + { + protected MethodBaseAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + } + public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } + } + public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } + public MethodInfoSelector(System.Type type) { } + public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } + public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } + public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } + public System.Reflection.MethodInfo[] ToArray() { } + } + public class MethodInfoSelectorAssertions + { + public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectMethods { get; } + public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions + { + public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } + public PropertyInfoSelector(System.Type type) { } + public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } + public FluentAssertions.Types.PropertyInfoSelector OfType() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public System.Reflection.PropertyInfo[] ToArray() { } + } + public class PropertyInfoSelectorAssertions + { + public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectProperties { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + } + public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public TypeAssertions(System.Type type) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) + where TInterface : class { } + } + public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public TypeSelector(System.Collections.Generic.IEnumerable types) { } + public TypeSelector(System.Type type) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAreClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } + public FluentAssertions.Types.TypeSelector ThatImplement() { } + public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } + public System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } + } + public class TypeSelectorAssertions + { + public TypeSelectorAssertions(params System.Type[] types) { } + public System.Collections.Generic.IEnumerable Subject { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Xml +{ + public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } + } + public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XDocumentAssertions(System.Xml.Linq.XDocument document) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + } + public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XElementAssertions(System.Xml.Linq.XElement xElement) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } + } + public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Xml.XmlNode + where TAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(TSubject xmlNode) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt new file mode 100644 index 0000000000..6da96507de --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt @@ -0,0 +1,2606 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName="")] +namespace FluentAssertions +{ + public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions + { + public AggregateExceptionExtractor() { } + public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception { } + } + public class AndConstraint + { + public AndConstraint(T parentConstraint) { } + public T And { get; } + } + public class AndWhichConstraint : FluentAssertions.AndConstraint + { + public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } + public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } + public TMatchedElement Subject { get; } + public TMatchedElement Which { get; } + } + public static class AssertionExtensions + { + public static TTo As(this object subject) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Action Enumerating(this System.Func enumerable) { } + public static System.Action Enumerating(this System.Func> enumerable) { } + public static System.Action Enumerating(this T subject, System.Func> enumerable) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static System.Action Invoking(this T subject, System.Action action) { } + public static System.Func Invoking(this T subject, System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } + public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } + public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } + public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } + public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } + public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } + public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } + public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } + 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) { } + public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } + public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } + public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } + public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } + public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } + public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } + public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } + public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } + public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } + public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } + public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) + where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.GuidAssertions _) + where TAssertions : FluentAssertions.Primitives.GuidAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } + public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } + public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } + public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } + public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } + public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Numeric.NumericAssertions _) + where TSubject : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.EnumAssertions _) + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } + public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) + where TCollection : System.Collections.Generic.IEnumerable> { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } + public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + public static class AsyncAssertionsExtensions + { + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + } + public static class AtLeast + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class AtMost + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class CallerIdentifier + { + public static System.Action Logger { get; set; } + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public static class DataRowAssertionExtensions + { + public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) + where TDataRow : System.Data.DataRow { } + } + public static class DataSetAssertionExtensions + { + public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) + where TDataSet : System.Data.DataSet { } + } + public static class DataTableAssertionExtensions + { + public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) + where TDataTable : System.Data.DataTable { } + } + public static class EnumAssertionsExtensions + { + public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) + where TEnum : struct, System.Enum { } + public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) + where TEnum : struct, System.Enum { } + } + public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyPlan() { } + public void Add() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void AddAfter() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Clear() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void Insert() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void InsertBefore() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Remove() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } + public void Reset() { } + } + public static class Exactly + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class ExceptionAssertionsExtensions + { + public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + } + public static class FluentActions + { + public static System.Func Awaiting(System.Func action) { } + public static System.Func> Awaiting(System.Func> func) { } + public static System.Action Enumerating(System.Func enumerable) { } + public static System.Action Enumerating(System.Func> enumerable) { } + public static System.Action Invoking(System.Action action) { } + public static System.Func Invoking(System.Func func) { } + } + public static class LessThan + { + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class MoreThan + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class NumericAssertionsExtensions + { + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + } + public static class ObjectAssertionsExtensions + { + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + } + public abstract class OccurrenceConstraint + { + protected OccurrenceConstraint(int expectedCount) { } + } + public static class TypeEnumerableExtensions + { + public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } + } + public static class TypeExtensions + { + public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } + } + public static class XmlAssertionExtensions + { + public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } + public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } + } +} +namespace FluentAssertions.Collections +{ + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> + { + public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public GenericCollectionAssertions(TCollection actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } + protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params T[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } + public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } + public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } + public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } + public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } + public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } + public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } + public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + { + public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public StringCollectionAssertions(TCollection actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Equal(params string[] expected) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> + { + public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + } + public class WhoseValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhoseValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public class Configuration + { + public Configuration(FluentAssertions.Common.IConfigurationStore store) { } + public string TestFrameworkName { get; set; } + public string ValueFormatterAssembly { get; set; } + public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } + public static FluentAssertions.Common.Configuration Current { get; } + } + public static class DateTimeExtensions + { + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } + } + public interface IClock + { + void Delay(System.TimeSpan timeToDelay); + System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); + FluentAssertions.Common.ITimer StartTimer(); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer : System.IDisposable + { + System.TimeSpan Elapsed { get; } + } + public static class Services + { + public static FluentAssertions.Common.Configuration Configuration { get; } + public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } + public static FluentAssertions.Common.IReflector Reflector { get; set; } + public static System.Action ThrowException { get; set; } + public static void ResetToDefaults() { } + } + public delegate FluentAssertions.Common.ITimer StartTimer(); + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Data +{ + public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public DataColumnAssertions(System.Data.DataColumn dataColumn) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataRow : System.Data.DataRow + { + public DataRowAssertions(TDataRow dataRow) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + } + public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataSet : System.Data.DataSet + { + public DataSetAssertions(TDataSet dataSet) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } + public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } + } + public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataTable : System.Data.DataTable + { + public DataTableAssertions(TDataTable dataTable) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } + } + public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + { + FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); + } + public enum RowMatchMode + { + Index = 0, + PrimaryKey = 1, + } +} +namespace FluentAssertions.Equivalency +{ + public class Comparands + { + public Comparands() { } + public Comparands(object subject, object expectation, System.Type compileTimeType) { } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public System.Type RuntimeType { get; } + public object Subject { get; set; } + public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public override string ToString() { } + } + public class ConversionSelector + { + public ConversionSelector() { } + public FluentAssertions.Equivalency.ConversionSelector Clone() { } + public void Exclude(System.Linq.Expressions.Expression> predicate) { } + public void Include(System.Linq.Expressions.Expression> predicate) { } + public void IncludeAll() { } + public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public enum EqualityStrategy + { + Equals = 0, + Members = 1, + ForceEquals = 2, + ForceMembers = 3, + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + public EquivalencyAssertionOptions() { } + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> + { + public EquivalencyAssertionOptions() { } + public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public enum EquivalencyResult + { + ContinueWithNext = 0, + AssertionCompleted = 1, + } + public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + protected EquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext + { + public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.INode CurrentNode { get; } + public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + public FluentAssertions.Execution.Reason Reason { get; set; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } + public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } + public bool IsCyclicReference(object expectation) { } + public override string ToString() { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator() { } + public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; set; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public delegate string GetSubjectId(); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + FluentAssertions.Equivalency.INode SelectedNode { get; } + TSubject Subject { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + bool CompareRecordsByValue { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public interface IEquivalencyValidationContext + { + FluentAssertions.Equivalency.INode CurrentNode { get; } + FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + FluentAssertions.Execution.Reason Reason { get; } + FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); + FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); + bool IsCyclicReference(object expectation); + } + public interface IEquivalencyValidator + { + void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMember : FluentAssertions.Equivalency.INode + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + System.Type ReflectedType { get; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + object GetValue(object obj); + } + public interface IMemberInfo + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + string Name { get; } + string Path { get; set; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + System.Type Type { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); + } + public interface INode + { + int Depth { get; } + string Description { get; } + FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } + bool IsRoot { get; } + string Name { get; } + string Path { get; } + string PathAndName { get; } + bool RootIsCollection { get; } + System.Type Type { get; } + } + public interface IObjectInfo + { + System.Type CompileTimeType { get; } + string Path { get; set; } + System.Type RuntimeType { get; } + System.Type Type { get; } + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); + } + public static class MemberFactory + { + public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } + } + public class MemberSelectionContext + { + public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + public System.Type Type { get; } + } + [System.Flags] + public enum MemberVisibility + { + None = 0, + Internal = 1, + Public = 2, + } + public class Node : FluentAssertions.Equivalency.INode + { + public Node() { } + public int Depth { get; } + public virtual string Description { get; } + public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } + public bool IsRoot { get; } + public string Name { get; set; } + public string Path { get; set; } + public string PathAndName { get; } + public bool RootIsCollection { get; set; } + public System.Type Type { get; set; } + public override bool Equals(object obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } + public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } + public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } + } + public enum OrderStrictness + { + Strict = 0, + NotStrict = 1, + Irrelevant = 2, + } + public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public OrderingRuleCollection() { } + public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } + public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } + } + public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public bool CompareRecordsByValue { get; } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers(System.Type type) { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue(System.Type type) { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + public TSelf ComparingRecordsByMembers() { } + public TSelf ComparingRecordsByValue() { } + public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } + public TSelf ExcludingFields() { } + public TSelf ExcludingMissingMembers() { } + public TSelf ExcludingNestedObjects() { } + public TSelf ExcludingProperties() { } + public TSelf IgnoringCyclicReferences() { } + public TSelf Including(System.Linq.Expressions.Expression> predicate) { } + public TSelf IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + public TSelf IncludingInternalFields() { } + public TSelf IncludingInternalProperties() { } + public TSelf IncludingNestedObjects() { } + public TSelf IncludingProperties() { } + public TSelf RespectingDeclaredTypes() { } + public TSelf RespectingRuntimeTypes() { } + public TSelf ThrowingOnMissingMembers() { } + public override string ToString() { } + public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } + public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } + public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } + public TSelf Using() + where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } + public TSelf WithAutoConversion() { } + public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithStrictOrdering() { } + public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } + public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public void WithoutMatchingRules() { } + public void WithoutSelectionRules() { } + public TSelf WithoutStrictOrdering() { } + public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public class Restriction + { + public Restriction(TSelf options, System.Action> action) { } + public TSelf When(System.Linq.Expressions.Expression> predicate) { } + public TSelf WhenTypeIs() + where TMemberType : TMember { } + } + } + public static class SubjectInfoExtensions + { + public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + } +} +namespace FluentAssertions.Equivalency.Steps +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataColumnEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRelationEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataSetEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataTableEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DictionaryEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XAttributeEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XDocumentEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XElementEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } +} +namespace FluentAssertions.Equivalency.Tracing +{ + public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class Tracer + { + public override string ToString() { } + public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + } +} +namespace FluentAssertions.Execution +{ + [System.Serializable] + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(System.Lazy context) { } + public AssertionScope(string context) { } + public string CallerIdentity { get; } + public System.Lazy Context { get; set; } + public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } + public static FluentAssertions.Execution.AssertionScope Current { get; } + public void AddNonReportable(string key, object value) { } + public void AddPreFormattedFailure(string formattedFailureMessage) { } + public void AddReportable(string key, System.Func valueFunc) { } + public void AddReportable(string key, string value) { } + public void AssumeSingleCaller() { } + public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } + public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } + public T Get(string key) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public bool HasFailures() { } + public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } + } + public class Continuation + { + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } + } + public static class Execute + { + public static FluentAssertions.Execution.AssertionScope Assertion { get; } + } + public class FailReason + { + public FailReason(string message, params object[] args) { } + public object[] Args { get; } + public string Message { get; } + } + public class GivenSelector + { + public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + } + public interface IAssertionScope : System.IDisposable + { + FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); + FluentAssertions.Execution.Continuation ClearExpectation(); + string[] Discard(); + FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); + FluentAssertions.Execution.Continuation FailWith(string message); + FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); + FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); + FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); + FluentAssertions.Execution.GivenSelector Given(System.Func selector); + FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); + FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); + } + public interface IAssertionStrategy + { + System.Collections.Generic.IEnumerable FailureMessages { get; } + System.Collections.Generic.IEnumerable DiscardFailures(); + void HandleFailure(string message); + void ThrowIfAny(System.Collections.Generic.IDictionary context); + } + public interface ICloneable2 + { + object Clone(); + } + public class Reason + { + public Reason(string formattedMessage, object[] arguments) { } + public object[] Arguments { get; set; } + public string FormattedMessage { get; set; } + } +} +namespace FluentAssertions.Extensions +{ + public static class FluentDateTimeExtensions + { + public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } + public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } + public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } + public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } + public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime April(this int day, int year) { } + public static System.DateTime AsLocal(this System.DateTime dateTime) { } + public static System.DateTime AsUtc(this System.DateTime dateTime) { } + public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } + public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTime August(this int day, int year) { } + public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime December(this int day, int year) { } + public static System.DateTime February(this int day, int year) { } + public static System.DateTime January(this int day, int year) { } + public static System.DateTime July(this int day, int year) { } + public static System.DateTime June(this int day, int year) { } + public static System.DateTime March(this int day, int year) { } + public static System.DateTime May(this int day, int year) { } + public static int Microsecond(this System.DateTime self) { } + public static int Microsecond(this System.DateTimeOffset self) { } + public static int Nanosecond(this System.DateTime self) { } + public static int Nanosecond(this System.DateTimeOffset self) { } + public static System.DateTime November(this int day, int year) { } + public static System.DateTime October(this int day, int year) { } + public static System.DateTime September(this int day, int year) { } + public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } + } + public static class FluentTimeSpanExtensions + { + public const long TicksPerMicrosecond = 10; + public const double TicksPerNanosecond = 0.01D; + public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } + public static System.TimeSpan Days(this double days) { } + public static System.TimeSpan Days(this int days) { } + public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } + public static System.TimeSpan Hours(this double hours) { } + public static System.TimeSpan Hours(this int hours) { } + public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } + public static int Microseconds(this System.TimeSpan self) { } + public static System.TimeSpan Microseconds(this int microseconds) { } + public static System.TimeSpan Microseconds(this long microseconds) { } + public static System.TimeSpan Milliseconds(this double milliseconds) { } + public static System.TimeSpan Milliseconds(this int milliseconds) { } + public static System.TimeSpan Minutes(this double minutes) { } + public static System.TimeSpan Minutes(this int minutes) { } + public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } + public static int Nanoseconds(this System.TimeSpan self) { } + public static System.TimeSpan Nanoseconds(this int nanoseconds) { } + public static System.TimeSpan Nanoseconds(this long nanoseconds) { } + public static System.TimeSpan Seconds(this double seconds) { } + public static System.TimeSpan Seconds(this int seconds) { } + public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } + public static System.TimeSpan Ticks(this int ticks) { } + public static System.TimeSpan Ticks(this long ticks) { } + public static double TotalMicroseconds(this System.TimeSpan self) { } + public static double TotalNanoseconds(this System.TimeSpan self) { } + } +} +namespace FluentAssertions.Formatting +{ + public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AggregateExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DefaultValueFormatter() { } + protected virtual int SpacesPerIndentionLevel { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DictionaryValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumValueFormatter() { } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumerableValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); + public class FormattedObjectGraph + { + public FormattedObjectGraph(int maxLines) { } + public int LineCount { get; } + public static int SpacesPerIndentation { get; } + public void AddFragment(string fragment) { } + public void AddFragmentOnNewLine(string fragment) { } + public void AddLine(string line) { } + public override string ToString() { } + public System.IDisposable WithIndentation() { } + } + public static class Formatter + { + public static System.Collections.Generic.IEnumerable Formatters { get; } + public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } + } + public class FormattingContext + { + public FormattingContext() { } + public bool UseLineBreaks { get; set; } + } + public class FormattingOptions + { + public FormattingOptions() { } + public int MaxDepth { get; set; } + public int MaxLines { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MaxLinesExceededException : System.Exception + { + public MaxLinesExceededException() { } + public MaxLinesExceededException(string message) { } + public MaxLinesExceededException(string message, System.Exception innerException) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PredicateLambdaExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class ValueFormatterAttribute : System.Attribute + { + public ValueFormatterAttribute() { } + } + public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XAttributeValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlReaderValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} +namespace FluentAssertions.Numeric +{ + public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> + { + public ComparableTypeAssertions(System.IComparable value) { } + } + public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> + where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions + { + public ComparableTypeAssertions(System.IComparable value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> + where T : struct, System.IComparable + { + public NullableNumericAssertions(T? value) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions + { + public NullableNumericAssertions(T? value) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> + where T : struct, System.IComparable + { + public NumericAssertions(T value) { } + } + public class NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions + { + public NumericAssertions(T value) { } + public T? Subject { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Primitives +{ + public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + } + public class BooleanAssertions + where TAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + public bool? Subject { get; } + public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + } + public class DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + public System.DateTime? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + } + public class DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + public System.DateTimeOffset? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + } + public class DateTimeRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } + } + public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> + where TEnum : struct, System.Enum + { + public EnumAssertions(TEnum subject) { } + } + public class EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions + { + public EnumAssertions(TEnum subject) { } + public TEnum? Subject { get; } + public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } + } + public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + } + public class GuidAssertions + where TAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + public System.Guid? Subject { get; } + public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> + where TEnum : struct, System.Enum + { + public NullableEnumAssertions(TEnum? subject) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions + { + public NullableEnumAssertions(TEnum? subject) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions + where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(object value) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(TSubject value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public abstract class ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + protected ReferenceTypeAssertions(TSubject subject) { } + protected abstract string Identifier { get; } + public TSubject Subject { get; } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where T : TSubject { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } + } + public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + public System.TimeSpan? Subject { get; } + public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + } + public class StringAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + } + public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAll(params string[] values) { } + public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAny(params string[] values) { } + public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + } + public enum TimeSpanCondition + { + MoreThan = 0, + AtLeast = 1, + Exactly = 2, + Within = 3, + LessThan = 4, + } +} +namespace FluentAssertions.Reflection +{ + public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public AssemblyAssertions(System.Reflection.Assembly assembly) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Specialized +{ + public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions + { + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + } + public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> + where TTask : System.Threading.Tasks.Task + where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + { + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertions + { + protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } + protected abstract void InvokeSubject(); + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> + where TException : System.Exception + { + public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } + public TException And { get; } + protected override string Identifier { get; } + public TException Which { get; } + public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class ExecutionTime + { + public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } + public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + } + public class ExecutionTimeAssertions + { + public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + } + public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> + { + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + } + public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> + { + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } + } + public interface IExtractExceptions + { + System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception; + } + public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime + { + public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } + } + public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + } + public class TaskCompletionSourceAssertions + { + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Streams +{ + public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions + where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class StreamAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(System.IO.Stream stream) { } + } + public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.IO.Stream + where TAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(TSubject stream) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Types +{ + public static class AllTypes + { + public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } + } + public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } + protected override string Identifier { get; } + } + public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Reflection.MemberInfo + where TAssertions : FluentAssertions.Types.MemberInfoAssertions + { + protected MemberInfoAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + } + public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions + where TSubject : System.Reflection.MethodBase + where TAssertions : FluentAssertions.Types.MethodBaseAssertions + { + protected MethodBaseAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + } + public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } + } + public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } + public MethodInfoSelector(System.Type type) { } + public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } + public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } + public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } + public System.Reflection.MethodInfo[] ToArray() { } + } + public class MethodInfoSelectorAssertions + { + public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectMethods { get; } + public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions + { + public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } + public PropertyInfoSelector(System.Type type) { } + public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } + public FluentAssertions.Types.PropertyInfoSelector OfType() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public System.Reflection.PropertyInfo[] ToArray() { } + } + public class PropertyInfoSelectorAssertions + { + public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectProperties { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + } + public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public TypeAssertions(System.Type type) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) + where TInterface : class { } + } + public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public TypeSelector(System.Collections.Generic.IEnumerable types) { } + public TypeSelector(System.Type type) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAreClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } + public FluentAssertions.Types.TypeSelector ThatImplement() { } + public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } + public System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } + } + public class TypeSelectorAssertions + { + public TypeSelectorAssertions(params System.Type[] types) { } + public System.Collections.Generic.IEnumerable Subject { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Xml +{ + public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } + } + public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XDocumentAssertions(System.Xml.Linq.XDocument document) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + } + public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XElementAssertions(System.Xml.Linq.XElement xElement) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } + } + public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Xml.XmlNode + where TAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(TSubject xmlNode) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt new file mode 100644 index 0000000000..67bfa6db19 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt @@ -0,0 +1,2655 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/fluentassertions/fluentassertions")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"FluentAssertions.Specs, PublicKey=00240000048000009400000006020000002400005253413100040000010001002d25ff515c85b13ba08f61d466cff5d80a7f28ba197bbf8796085213e7a3406f970d2a4874932fed35db546e89af2da88c194bf1b7f7ac70de7988c78406f7629c547283061282a825616eb7eb48a9514a7570942936020a9bb37dca9ff60b778309900851575614491c6d25018fadb75828f4c7a17bf2d7dc86e7b6eafc5d8f")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName="")] +namespace FluentAssertions +{ + public class AggregateExceptionExtractor : FluentAssertions.Specialized.IExtractExceptions + { + public AggregateExceptionExtractor() { } + public System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception { } + } + public class AndConstraint + { + public AndConstraint(T parentConstraint) { } + public T And { get; } + } + public class AndWhichConstraint : FluentAssertions.AndConstraint + { + public AndWhichConstraint(TParentConstraint parentConstraint, System.Collections.Generic.IEnumerable matchedConstraint) { } + public AndWhichConstraint(TParentConstraint parentConstraint, TMatchedElement matchedConstraint) { } + public TMatchedElement Subject { get; } + public TMatchedElement Which { get; } + } + public static class AssertionExtensions + { + public static TTo As(this object subject) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func Awaiting(this T subject, System.Func action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Func> Awaiting(this T subject, System.Func> action) { } + public static System.Action Enumerating(this System.Func enumerable) { } + public static System.Action Enumerating(this System.Func> enumerable) { } + public static System.Action Enumerating(this T subject, System.Func> enumerable) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer = null) { } + public static System.Action Invoking(this T subject, System.Action action) { } + public static System.Func Invoking(this T subject, System.Func action) { } + public static FluentAssertions.Events.IMonitor Monitor(this T eventSource, System.Func utcNow = null) { } + public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.ExecutionTimeAssertions _) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.MethodInfoSelectorAssertions _) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.PropertyInfoSelectorAssertions _) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Types.TypeSelectorAssertions _) { } + public static FluentAssertions.Specialized.ActionAssertions Should(this System.Action action) { } + public static FluentAssertions.Collections.StringCollectionAssertions Should(this System.Collections.Generic.IEnumerable @this) { } + public static FluentAssertions.Data.DataColumnAssertions Should(this System.Data.DataColumn actualValue) { } + public static FluentAssertions.Primitives.DateTimeAssertions Should(this System.DateTime actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeAssertions Should(this System.DateTime? actualValue) { } + public static FluentAssertions.Primitives.DateTimeOffsetAssertions Should(this System.DateTimeOffset actualValue) { } + public static FluentAssertions.Primitives.NullableDateTimeOffsetAssertions Should(this System.DateTimeOffset? actualValue) { } + public static FluentAssertions.Specialized.NonGenericAsyncFunctionAssertions Should(this System.Func action) { } + public static FluentAssertions.Primitives.GuidAssertions Should(this System.Guid actualValue) { } + 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) { } + public static FluentAssertions.Types.PropertyInfoAssertions Should(this System.Reflection.PropertyInfo propertyInfo) { } + public static FluentAssertions.Primitives.SimpleTimeSpanAssertions Should(this System.TimeSpan actualValue) { } + public static FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions Should(this System.TimeSpan? actualValue) { } + public static FluentAssertions.Types.TypeAssertions Should(this System.Type subject) { } + public static FluentAssertions.Xml.XAttributeAssertions Should(this System.Xml.Linq.XAttribute actualValue) { } + public static FluentAssertions.Xml.XDocumentAssertions Should(this System.Xml.Linq.XDocument actualValue) { } + public static FluentAssertions.Xml.XElementAssertions Should(this System.Xml.Linq.XElement actualValue) { } + public static FluentAssertions.Primitives.BooleanAssertions Should(this bool actualValue) { } + public static FluentAssertions.Primitives.NullableBooleanAssertions Should(this bool? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this byte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this byte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this decimal actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this decimal? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this double actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this double? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this float actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this float? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this int actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this int? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this long actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this long? actualValue) { } + public static FluentAssertions.Primitives.ObjectAssertions Should(this object actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this sbyte actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this sbyte? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this short actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this short? actualValue) { } + public static FluentAssertions.Primitives.StringAssertions Should(this string actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this uint actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this uint? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ulong actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ulong? actualValue) { } + public static FluentAssertions.Numeric.NumericAssertions Should(this ushort actualValue) { } + public static FluentAssertions.Numeric.NullableNumericAssertions Should(this ushort? actualValue) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.BooleanAssertions _) + where TAssertions : FluentAssertions.Primitives.BooleanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.DateTimeOffsetAssertions _) + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.GuidAssertions _) + where TAssertions : FluentAssertions.Primitives.GuidAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Specialized.TaskCompletionSourceAssertions _) { } + public static FluentAssertions.Collections.GenericCollectionAssertions Should(this System.Collections.Generic.IEnumerable actualValue) { } + public static FluentAssertions.Specialized.GenericAsyncFunctionAssertions Should(this System.Func> action) { } + public static FluentAssertions.Specialized.FunctionAssertions Should(this System.Func func) { } + public static FluentAssertions.Numeric.ComparableTypeAssertions Should(this System.IComparable comparableValue) { } + public static FluentAssertions.Specialized.TaskCompletionSourceAssertions Should(this System.Threading.Tasks.TaskCompletionSource tcs) { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Numeric.NumericAssertions _) + where TSubject : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.EnumAssertions _) + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions { } + [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + + "ly following \'And\'", true)] + public static void Should(this FluentAssertions.Primitives.ReferenceTypeAssertions _) + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions { } + public static FluentAssertions.Collections.GenericDictionaryAssertions, TKey, TValue> Should(this System.Collections.Generic.IDictionary actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions>, TKey, TValue> Should(this System.Collections.Generic.IEnumerable> actualValue) { } + public static FluentAssertions.Collections.GenericDictionaryAssertions Should(this TCollection actualValue) + where TCollection : System.Collections.Generic.IEnumerable> { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyPlan EquivalencyPlan { get; } + public static FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + public static class AsyncAssertionsExtensions + { + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + public static System.Threading.Tasks.Task, T>> WithResult(this System.Threading.Tasks.Task, T>> task, T expected, string because = "", params object[] becauseArgs) { } + } + public static class AtLeast + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class AtMost + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class CallerIdentifier + { + public static System.Action Logger { get; set; } + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public static class DataRowAssertionExtensions + { + public static FluentAssertions.Data.DataRowAssertions Should(this TDataRow actualValue) + where TDataRow : System.Data.DataRow { } + } + public static class DataSetAssertionExtensions + { + public static FluentAssertions.Data.DataSetAssertions Should(this TDataSet actualValue) + where TDataSet : System.Data.DataSet { } + } + public static class DataTableAssertionExtensions + { + public static FluentAssertions.Data.DataTableAssertions Should(this TDataTable actualValue) + where TDataTable : System.Data.DataTable { } + } + public static class EnumAssertionsExtensions + { + public static FluentAssertions.Primitives.EnumAssertions Should(this TEnum @enum) + where TEnum : struct, System.Enum { } + public static FluentAssertions.Primitives.NullableEnumAssertions Should(this TEnum? @enum) + where TEnum : struct, System.Enum { } + } + public class EquivalencyPlan : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyPlan() { } + public void Add() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void AddAfter() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Clear() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void Insert() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void InsertBefore() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep, new () { } + public void Remove() + where TStep : FluentAssertions.Equivalency.IEquivalencyStep { } + public void Reset() { } + } + public static class EventRaisingExtensions + { + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecording WithArgs(this FluentAssertions.Events.IEventRecording eventRecording, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecording WithSender(this FluentAssertions.Events.IEventRecording eventRecording, object expectedSender) { } + } + public static class Exactly + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class ExceptionAssertionsExtensions + { + public static System.Threading.Tasks.Task> Where(this System.Threading.Tasks.Task> task, System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerException(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithInnerExceptionExactly(this System.Threading.Tasks.Task> task, string because = "", params object[] becauseArgs) + where TException : System.Exception + where TInnerException : System.Exception { } + public static System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public static FluentAssertions.Specialized.ExceptionAssertions WithParameterName(this FluentAssertions.Specialized.ExceptionAssertions parent, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + public static System.Threading.Tasks.Task> WithParameterName(this System.Threading.Tasks.Task> task, string paramName, string because = "", params object[] becauseArgs) + where TException : System.ArgumentException { } + } + public static class FluentActions + { + public static System.Func Awaiting(System.Func action) { } + public static System.Func> Awaiting(System.Func> func) { } + public static System.Action Enumerating(System.Func enumerable) { } + public static System.Action Enumerating(System.Func> enumerable) { } + public static System.Action Invoking(System.Action action) { } + public static System.Func Invoking(System.Func func) { } + } + public static class LessThan + { + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class MoreThan + { + public static FluentAssertions.OccurrenceConstraint Once() { } + public static FluentAssertions.OccurrenceConstraint Thrice() { } + public static FluentAssertions.OccurrenceConstraint Times(int expected) { } + public static FluentAssertions.OccurrenceConstraint Twice() { } + } + public static class NumericAssertionsExtensions + { + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal expectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double expectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float expectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte nearbyValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort nearbyValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint nearbyValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> BeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong nearbyValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, decimal? unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, double? unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NullableNumericAssertions parent, float? unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, decimal unexpectedValue, decimal precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, double unexpectedValue, double precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeApproximately(this FluentAssertions.Numeric.NumericAssertions parent, float unexpectedValue, float precision, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, byte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, short distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, int distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, long distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, sbyte distantValue, byte delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ushort distantValue, ushort delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, uint distantValue, uint delta, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint> NotBeCloseTo(this FluentAssertions.Numeric.NumericAssertions parent, ulong distantValue, ulong delta, string because = "", params object[] becauseArgs) { } + } + public static class ObjectAssertionsExtensions + { + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeBinarySerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeDataContractSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> options, string because = "", params object[] becauseArgs) { } + public static FluentAssertions.AndConstraint BeXmlSerializable(this FluentAssertions.Primitives.ObjectAssertions assertions, string because = "", params object[] becauseArgs) { } + } + public abstract class OccurrenceConstraint + { + protected OccurrenceConstraint(int expectedCount) { } + } + public static class TypeEnumerableExtensions + { + public static System.Collections.Generic.IEnumerable ThatAreClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreInNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatAreNotClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWith(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotDecoratedWithOrInherit(this System.Collections.Generic.IEnumerable types) + where TAttribute : System.Attribute { } + public static System.Collections.Generic.IEnumerable ThatAreNotStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStatic(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreUnderNamespace(this System.Collections.Generic.IEnumerable types, string @namespace) { } + public static System.Collections.Generic.IEnumerable ThatDeriveFrom(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatImplement(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatSatisfy(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + public static System.Collections.Generic.IEnumerable UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } + } + public static class TypeExtensions + { + public static FluentAssertions.Types.MethodInfoSelector Methods(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.MethodInfoSelector Methods(this System.Type type) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this FluentAssertions.Types.TypeSelector typeSelector) { } + public static FluentAssertions.Types.PropertyInfoSelector Properties(this System.Type type) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Collections.Generic.IEnumerable types) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Reflection.Assembly assembly) { } + public static FluentAssertions.Types.TypeSelector Types(this System.Type type) { } + } + public static class XmlAssertionExtensions + { + public static FluentAssertions.Xml.XmlElementAssertions Should(this System.Xml.XmlElement actualValue) { } + public static FluentAssertions.Xml.XmlNodeAssertions Should(this System.Xml.XmlNode actualValue) { } + } +} +namespace FluentAssertions.Collections +{ + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions, T, FluentAssertions.Collections.GenericCollectionAssertions> + { + public GenericCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public GenericCollectionAssertions(TCollection actualValue) { } + } + public class GenericCollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint AllBeAssignableTo(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint> AllBeOfType(string because = "", params object[] becauseArgs) { } + protected void AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, System.Collections.Generic.ICollection expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSubsetOf(System.Collections.Generic.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint Contain(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params T[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainSingle(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params T[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCount(System.Linq.Expressions.Expression> countPredicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountGreaterThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThanOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(T successor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(T predecessor, T expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.Generic.IEnumerable unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Func comparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSubsetOf(System.Collections.Generic.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotContain(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainInOrder(params T[] unexpected) { } + public FluentAssertions.AndConstraint NotContainInOrder(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.Generic.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Satisfy(params System.Linq.Expressions.Expression<>[] predicates) { } + public FluentAssertions.AndConstraint Satisfy(System.Collections.Generic.IEnumerable>> predicates, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint SatisfyRespectively(params System.Action<>[] elementInspectors) { } + public FluentAssertions.AndConstraint SatisfyRespectively(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(T element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected static System.Collections.Generic.IEnumerable RepeatAsManyAs(TExpectation value, System.Collections.Generic.IEnumerable enumerable) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericDictionaryAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + } + public class GenericDictionaryAssertions : FluentAssertions.Collections.GenericCollectionAssertions, TAssertions> + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public GenericDictionaryAssertions(TCollection keyValuePairs) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(params System.Collections.Generic.KeyValuePair<, >[] expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable> expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.KeyValuePair expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Collections.WhoseValueConstraint ContainKey(TKey expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainKeys(params TKey[] expected) { } + public FluentAssertions.AndConstraint ContainKeys(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainValue(TValue expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainValues(params TValue[] expected) { } + public FluentAssertions.AndConstraint ContainValues(System.Collections.Generic.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(T expected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + public FluentAssertions.AndConstraint NotContain(params System.Collections.Generic.KeyValuePair<, >[] items) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable> items, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.KeyValuePair item, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(TKey key, TValue value, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKey(TKey unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainKeys(params TKey[] unexpected) { } + public FluentAssertions.AndConstraint NotContainKeys(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValue(TValue unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainValues(params TValue[] unexpected) { } + public FluentAssertions.AndConstraint NotContainValues(System.Collections.Generic.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(T unexpected, string because = "", params object[] becauseArgs) + where T : System.Collections.Generic.IEnumerable> { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + { + public StringCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.StringCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public StringCollectionAssertions(TCollection actualValue) { } + } + public class StringCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint AllBe(string expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint AllBe(string expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params string[] expectation) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.Generic.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint ContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Equal(params string[] expected) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class SubsequentOrderingAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions, T, FluentAssertions.Collections.SubsequentOrderingAssertions> + { + public SubsequentOrderingAssertions(System.Collections.Generic.IEnumerable actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions> + where TCollection : System.Collections.Generic.IEnumerable + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + } + public class SubsequentOrderingGenericCollectionAssertions : FluentAssertions.Collections.GenericCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SubsequentOrderingGenericCollectionAssertions + { + public SubsequentOrderingGenericCollectionAssertions(TCollection actualValue, System.Linq.IOrderedEnumerable previousOrderedEnumerable) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ThenBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] becauseArgs) { } + } + public class WhoseValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhoseValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhoseValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public class Configuration + { + public Configuration(FluentAssertions.Common.IConfigurationStore store) { } + public string TestFrameworkName { get; set; } + public string ValueFormatterAssembly { get; set; } + public FluentAssertions.Common.ValueFormatterDetectionMode ValueFormatterDetectionMode { get; set; } + public static FluentAssertions.Common.Configuration Current { get; } + } + public static class DateTimeExtensions + { + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime) { } + public static System.DateTimeOffset ToDateTimeOffset(this System.DateTime dateTime, System.TimeSpan offset) { } + } + public interface IClock + { + void Delay(System.TimeSpan timeToDelay); + System.Threading.Tasks.Task DelayAsync(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken); + FluentAssertions.Common.ITimer StartTimer(); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer : System.IDisposable + { + System.TimeSpan Elapsed { get; } + } + public static class Services + { + public static FluentAssertions.Common.Configuration Configuration { get; } + public static FluentAssertions.Common.IConfigurationStore ConfigurationStore { get; set; } + public static FluentAssertions.Common.IReflector Reflector { get; set; } + public static System.Action ThrowException { get; set; } + public static void ResetToDefaults() { } + } + public delegate FluentAssertions.Common.ITimer StartTimer(); + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Data +{ + public class DataColumnAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public DataColumnAssertions(System.Data.DataColumn dataColumn) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Data.DataColumn expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public class DataRowAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataRow : System.Data.DataRow + { + public DataRowAssertions(TDataRow dataRow) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataRow expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + } + public class DataSetAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataSet : System.Data.DataSet + { + public DataSetAssertions(TDataSet dataSet) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataSet expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataTable> HaveTable(string expectedTableName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTableCount(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveTables(params string[] expectedTableNames) { } + public FluentAssertions.AndConstraint> HaveTables(System.Collections.Generic.IEnumerable expectedTableNames, string because = "", params object[] becauseArgs) { } + } + public class DataTableAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDataTable : System.Data.DataTable + { + public DataTableAssertions(TDataTable dataTable) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> BeEquivalentTo(System.Data.DataTable expectation, System.Func, FluentAssertions.Data.IDataEquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, System.Data.DataColumn> HaveColumn(string expectedColumnName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveColumns(params string[] expectedColumnNames) { } + public FluentAssertions.AndConstraint> HaveColumns(System.Collections.Generic.IEnumerable expectedColumnNames, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> HaveRowCount(int expected, string because = "", params object[] becauseArgs) { } + } + public interface IDataEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + { + FluentAssertions.Data.IDataEquivalencyAssertionOptions AllowingMismatchedTypes(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> predicate); + FluentAssertions.Data.IDataEquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(System.Data.DataColumn column); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumn(string tableName, string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnInAllTables(string columnName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(System.Collections.Generic.IEnumerable columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(params System.Data.DataColumn[] columns); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumns(string tableName, params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(System.Collections.Generic.IEnumerable columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingColumnsInAllTables(params string[] columnNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingOriginalData(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingRelated(System.Linq.Expressions.Expression> expression); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTable(string tableName); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(System.Collections.Generic.IEnumerable tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions ExcludingTables(params string[] tableNames); + FluentAssertions.Data.IDataEquivalencyAssertionOptions IgnoringUnmatchedColumns(); + FluentAssertions.Data.IDataEquivalencyAssertionOptions UsingRowMatchMode(FluentAssertions.Data.RowMatchMode rowMatchMode); + } + public enum RowMatchMode + { + Index = 0, + PrimaryKey = 1, + } +} +namespace FluentAssertions.Equivalency +{ + public class Comparands + { + public Comparands() { } + public Comparands(object subject, object expectation, System.Type compileTimeType) { } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public System.Type RuntimeType { get; } + public object Subject { get; set; } + public System.Type GetExpectedType(FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public override string ToString() { } + } + public class ConversionSelector + { + public ConversionSelector() { } + public FluentAssertions.Equivalency.ConversionSelector Clone() { } + public void Exclude(System.Linq.Expressions.Expression> predicate) { } + public void Include(System.Linq.Expressions.Expression> predicate) { } + public void IncludeAll() { } + public bool RequiresConversion(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.INode currentNode) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public enum EqualityStrategy + { + Equals = 0, + Members = 1, + ForceEquals = 2, + ForceMembers = 3, + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + public EquivalencyAssertionOptions() { } + } + public class EquivalencyAssertionOptions : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions> + { + public EquivalencyAssertionOptions() { } + public EquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public enum EquivalencyResult + { + ContinueWithNext = 0, + AssertionCompleted = 1, + } + public abstract class EquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + protected EquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + protected abstract FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext + { + public EquivalencyValidationContext(FluentAssertions.Equivalency.INode root, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.INode CurrentNode { get; } + public FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + public FluentAssertions.Execution.Reason Reason { get; set; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; set; } + public FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember) { } + public FluentAssertions.Equivalency.IEquivalencyValidationContext Clone() { } + public bool IsCyclicReference(object expectation) { } + public override string ToString() { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator() { } + public void AssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class Field : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Field(System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public Field(System.Type reflectedType, System.Reflection.FieldInfo fieldInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; set; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public delegate string GetSubjectId(); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + FluentAssertions.Equivalency.INode SelectedNode { get; } + TSubject Subject { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + bool CompareRecordsByValue { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator); + } + public interface IEquivalencyValidationContext + { + FluentAssertions.Equivalency.INode CurrentNode { get; } + FluentAssertions.Equivalency.IEquivalencyAssertionOptions Options { get; } + FluentAssertions.Execution.Reason Reason { get; } + FluentAssertions.Equivalency.Tracing.Tracer Tracer { get; } + FluentAssertions.Equivalency.IEquivalencyValidationContext AsCollectionItem(string index); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsDictionaryItem(TKey key); + FluentAssertions.Equivalency.IEquivalencyValidationContext AsNestedMember(FluentAssertions.Equivalency.IMember expectationMember); + FluentAssertions.Equivalency.IEquivalencyValidationContext Clone(); + bool IsCyclicReference(object expectation); + } + public interface IEquivalencyValidator + { + void RecursivelyAssertEquality(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMember : FluentAssertions.Equivalency.INode + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + System.Type ReflectedType { get; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + object GetValue(object obj); + } + public interface IMemberInfo + { + System.Type DeclaringType { get; } + FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + string Name { get; } + string Path { get; set; } + FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + System.Type Type { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.IMember Match(FluentAssertions.Equivalency.IMember expectedMember, object subject, FluentAssertions.Equivalency.INode parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(FluentAssertions.Equivalency.INode currentNode, System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.MemberSelectionContext context); + } + public interface INode + { + int Depth { get; } + string Description { get; } + FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; } + bool IsRoot { get; } + string Name { get; } + string Path { get; } + string PathAndName { get; } + bool RootIsCollection { get; } + System.Type Type { get; } + } + public interface IObjectInfo + { + System.Type CompileTimeType { get; } + string Path { get; set; } + System.Type RuntimeType { get; } + System.Type Type { get; } + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IObjectInfo objectInfo); + } + public static class MemberFactory + { + public static FluentAssertions.Equivalency.IMember Create(System.Reflection.MemberInfo memberInfo, FluentAssertions.Equivalency.INode parent) { } + } + public class MemberSelectionContext + { + public MemberSelectionContext(System.Type compileTimeType, System.Type runtimeType, FluentAssertions.Equivalency.IEquivalencyAssertionOptions options) { } + public FluentAssertions.Equivalency.MemberVisibility IncludedFields { get; } + public FluentAssertions.Equivalency.MemberVisibility IncludedProperties { get; } + public System.Type Type { get; } + } + [System.Flags] + public enum MemberVisibility + { + None = 0, + Internal = 1, + Public = 2, + } + public class Node : FluentAssertions.Equivalency.INode + { + public Node() { } + public int Depth { get; } + public virtual string Description { get; } + public FluentAssertions.Equivalency.GetSubjectId GetSubjectId { get; set; } + public bool IsRoot { get; } + public string Name { get; set; } + public string Path { get; set; } + public string PathAndName { get; } + public bool RootIsCollection { get; set; } + public System.Type Type { get; set; } + public override bool Equals(object obj) { } + public override int GetHashCode() { } + public override string ToString() { } + public static FluentAssertions.Equivalency.INode From(FluentAssertions.Equivalency.GetSubjectId getSubjectId) { } + public static FluentAssertions.Equivalency.INode FromCollectionItem(string index, FluentAssertions.Equivalency.INode parent) { } + public static FluentAssertions.Equivalency.INode FromDictionaryItem(object key, FluentAssertions.Equivalency.INode parent) { } + } + public enum OrderStrictness + { + Strict = 0, + NotStrict = 1, + Irrelevant = 2, + } + public class OrderingRuleCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public OrderingRuleCollection() { } + public OrderingRuleCollection(System.Collections.Generic.IEnumerable orderingRules) { } + public void Add(FluentAssertions.Equivalency.IOrderingRule rule) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public bool IsOrderingStrictFor(FluentAssertions.Equivalency.IObjectInfo objectInfo) { } + } + public class Property : FluentAssertions.Equivalency.Node, FluentAssertions.Equivalency.IMember, FluentAssertions.Equivalency.INode + { + public Property(System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public Property(System.Type reflectedType, System.Reflection.PropertyInfo propertyInfo, FluentAssertions.Equivalency.INode parent) { } + public System.Type DeclaringType { get; } + public override string Description { get; } + public FluentAssertions.Common.CSharpAccessModifier GetterAccessibility { get; } + public System.Type ReflectedType { get; } + public FluentAssertions.Common.CSharpAccessModifier SetterAccessibility { get; } + public object GetValue(object obj) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public bool CompareRecordsByValue { get; } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + public FluentAssertions.Equivalency.Tracing.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers(System.Type type) { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue(System.Type type) { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + public TSelf ComparingRecordsByMembers() { } + public TSelf ComparingRecordsByValue() { } + public TSelf Excluding(System.Linq.Expressions.Expression> predicate) { } + public TSelf ExcludingFields() { } + public TSelf ExcludingMissingMembers() { } + public TSelf ExcludingNestedObjects() { } + public TSelf ExcludingProperties() { } + public TSelf IgnoringCyclicReferences() { } + public TSelf Including(System.Linq.Expressions.Expression> predicate) { } + public TSelf IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + public TSelf IncludingInternalFields() { } + public TSelf IncludingInternalProperties() { } + public TSelf IncludingNestedObjects() { } + public TSelf IncludingProperties() { } + public TSelf RespectingDeclaredTypes() { } + public TSelf RespectingRuntimeTypes() { } + public TSelf ThrowingOnMissingMembers() { } + public override string ToString() { } + public TSelf Using(FluentAssertions.Equivalency.IEquivalencyStep equivalencyStep) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberMatchingRule matchingRule) { } + public TSelf Using(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf Using(FluentAssertions.Equivalency.IOrderingRule orderingRule) { } + public FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions.Restriction Using(System.Action> action) { } + public TSelf Using(System.Collections.Generic.IEqualityComparer comparer) { } + public TSelf Using() + where TEqualityComparer : System.Collections.Generic.IEqualityComparer, new () { } + public TSelf WithAutoConversion() { } + public TSelf WithAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithStrictOrdering() { } + public TSelf WithStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public TSelf WithTracing(FluentAssertions.Equivalency.Tracing.ITraceWriter writer = null) { } + public TSelf WithoutAutoConversionFor(System.Linq.Expressions.Expression> predicate) { } + public void WithoutMatchingRules() { } + public void WithoutSelectionRules() { } + public TSelf WithoutStrictOrdering() { } + public TSelf WithoutStrictOrderingFor(System.Linq.Expressions.Expression> predicate) { } + public class Restriction + { + public Restriction(TSelf options, System.Action> action) { } + public TSelf When(System.Linq.Expressions.Expression> predicate) { } + public TSelf WhenTypeIs() + where TMemberType : TMember { } + } + } + public static class SubjectInfoExtensions + { + public static bool WhichGetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichGetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterDoesNotHave(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + public static bool WhichSetterHas(this FluentAssertions.Equivalency.IMemberInfo memberInfo, FluentAssertions.Common.CSharpAccessModifier accessModifier) { } + } +} +namespace FluentAssertions.Equivalency.Steps +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class ConstraintCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ConstraintEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public ConstraintEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataColumnEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataColumnEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRelationEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRelationEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowCollectionEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowCollectionEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataRowEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataRowEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataSetEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataSetEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DataTableEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DataTableEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public DictionaryEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + public override string ToString() { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public FluentAssertions.Equivalency.EquivalencyResult Handle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XAttributeEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XAttributeEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XDocumentEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XDocumentEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } + public class XElementEquivalencyStep : FluentAssertions.Equivalency.EquivalencyStep + { + public XElementEquivalencyStep() { } + protected override FluentAssertions.Equivalency.EquivalencyResult OnHandle(FluentAssertions.Equivalency.Comparands comparands, FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator nestedValidator) { } + } +} +namespace FluentAssertions.Equivalency.Tracing +{ + public delegate string GetTraceMessage(FluentAssertions.Equivalency.INode node); + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.Tracing.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class Tracer + { + public override string ToString() { } + public System.IDisposable WriteBlock(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + public void WriteLine(FluentAssertions.Equivalency.Tracing.GetTraceMessage getTraceMessage) { } + } +} +namespace FluentAssertions.Events +{ + public class EventAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + { + protected EventAssertions(FluentAssertions.Events.IMonitor monitor) { } + protected override string Identifier { get; } + public void NotRaise(string eventName, string because = "", params object[] becauseArgs) { } + public void NotRaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecording RaisePropertyChangeFor(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] becauseArgs) { } + } + public class EventMetadata + { + public EventMetadata(string eventName, System.Type handlerType) { } + public string EventName { get; } + public System.Type HandlerType { get; } + } + public interface IEventRecording : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecording GetRecordingFor(string eventName); + FluentAssertions.Events.EventAssertions Should(); + } + public class OccurredEvent + { + public OccurredEvent() { } + public string EventName { get; set; } + public object[] Parameters { get; set; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + [System.Serializable] + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public sealed class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(System.Lazy context) { } + public AssertionScope(string context) { } + public string CallerIdentity { get; } + public System.Lazy Context { get; set; } + public FluentAssertions.Formatting.FormattingOptions FormattingOptions { get; } + public FluentAssertions.Execution.AssertionScope UsingLineBreaks { get; } + public static FluentAssertions.Execution.AssertionScope Current { get; } + public void AddNonReportable(string key, object value) { } + public void AddPreFormattedFailure(string formattedFailureMessage) { } + public void AddReportable(string key, System.Func valueFunc) { } + public void AddReportable(string key, string value) { } + public void AssumeSingleCaller() { } + public FluentAssertions.Execution.AssertionScope BecauseOf(FluentAssertions.Execution.Reason reason) { } + public FluentAssertions.Execution.AssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.AssertionScope ForConstraint(FluentAssertions.OccurrenceConstraint constraint, int actualOccurrences) { } + public T Get(string key) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public bool HasFailures() { } + public FluentAssertions.Execution.AssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.AssertionScope WithExpectation(string message, params object[] args) { } + } + public class Continuation + { + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public sealed class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + public FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs) { } + public FluentAssertions.Execution.Continuation ClearExpectation() { } + public string[] Discard() { } + public void Dispose() { } + public FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc) { } + public FluentAssertions.Execution.Continuation FailWith(string message) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders) { } + public FluentAssertions.Execution.Continuation FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.IAssertionScope ForCondition(bool condition) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + public FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier) { } + public FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args) { } + } + public static class Execute + { + public static FluentAssertions.Execution.AssertionScope Assertion { get; } + } + public class FailReason + { + public FailReason(string message, params object[] args) { } + public object[] Args { get; } + public string Message { get; } + } + public class GivenSelector + { + public FluentAssertions.Execution.ContinuationOfGiven ClearExpectation() { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params System.Func<, >[] args) { } + public FluentAssertions.Execution.ContinuationOfGiven FailWith(string message, params object[] args) { } + public FluentAssertions.Execution.GivenSelector ForCondition(System.Func predicate) { } + public FluentAssertions.Execution.GivenSelector Given(System.Func selector) { } + } + public interface IAssertionScope : System.IDisposable + { + FluentAssertions.Execution.IAssertionScope UsingLineBreaks { get; } + FluentAssertions.Execution.IAssertionScope BecauseOf(string because, params object[] becauseArgs); + FluentAssertions.Execution.Continuation ClearExpectation(); + string[] Discard(); + FluentAssertions.Execution.Continuation FailWith(System.Func failReasonFunc); + FluentAssertions.Execution.Continuation FailWith(string message); + FluentAssertions.Execution.Continuation FailWith(string message, params System.Func<>[] argProviders); + FluentAssertions.Execution.Continuation FailWith(string message, params object[] args); + FluentAssertions.Execution.IAssertionScope ForCondition(bool condition); + FluentAssertions.Execution.GivenSelector Given(System.Func selector); + FluentAssertions.Execution.IAssertionScope WithDefaultIdentifier(string identifier); + FluentAssertions.Execution.IAssertionScope WithExpectation(string message, params object[] args); + } + public interface IAssertionStrategy + { + System.Collections.Generic.IEnumerable FailureMessages { get; } + System.Collections.Generic.IEnumerable DiscardFailures(); + void HandleFailure(string message); + void ThrowIfAny(System.Collections.Generic.IDictionary context); + } + public interface ICloneable2 + { + object Clone(); + } + public class Reason + { + public Reason(string formattedMessage, object[] arguments) { } + public object[] Arguments { get; set; } + public string FormattedMessage { get; set; } + } +} +namespace FluentAssertions.Extensions +{ + public static class FluentDateTimeExtensions + { + public static System.DateTime AddMicroseconds(this System.DateTime self, long microseconds) { } + public static System.DateTimeOffset AddMicroseconds(this System.DateTimeOffset self, long microseconds) { } + public static System.DateTime AddNanoseconds(this System.DateTime self, long nanoseconds) { } + public static System.DateTimeOffset AddNanoseconds(this System.DateTimeOffset self, long nanoseconds) { } + public static System.DateTime After(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime April(this int day, int year) { } + public static System.DateTime AsLocal(this System.DateTime dateTime) { } + public static System.DateTime AsUtc(this System.DateTime dateTime) { } + public static System.DateTime At(this System.DateTime date, System.TimeSpan time) { } + public static System.DateTime At(this System.DateTime date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTimeOffset At(this System.DateTimeOffset date, int hours, int minutes, int seconds = 0, int milliseconds = 0, int microseconds = 0, int nanoseconds = 0) { } + public static System.DateTime August(this int day, int year) { } + public static System.DateTime Before(this System.TimeSpan timeDifference, System.DateTime sourceDateTime) { } + public static System.DateTime December(this int day, int year) { } + public static System.DateTime February(this int day, int year) { } + public static System.DateTime January(this int day, int year) { } + public static System.DateTime July(this int day, int year) { } + public static System.DateTime June(this int day, int year) { } + public static System.DateTime March(this int day, int year) { } + public static System.DateTime May(this int day, int year) { } + public static int Microsecond(this System.DateTime self) { } + public static int Microsecond(this System.DateTimeOffset self) { } + public static int Nanosecond(this System.DateTime self) { } + public static int Nanosecond(this System.DateTimeOffset self) { } + public static System.DateTime November(this int day, int year) { } + public static System.DateTime October(this int day, int year) { } + public static System.DateTime September(this int day, int year) { } + public static System.DateTimeOffset WithOffset(this System.DateTime self, System.TimeSpan offset) { } + } + public static class FluentTimeSpanExtensions + { + public const long TicksPerMicrosecond = 10; + public const double TicksPerNanosecond = 0.01D; + public static System.TimeSpan And(this System.TimeSpan sourceTime, System.TimeSpan offset) { } + public static System.TimeSpan Days(this double days) { } + public static System.TimeSpan Days(this int days) { } + public static System.TimeSpan Days(this int days, System.TimeSpan offset) { } + public static System.TimeSpan Hours(this double hours) { } + public static System.TimeSpan Hours(this int hours) { } + public static System.TimeSpan Hours(this int hours, System.TimeSpan offset) { } + public static int Microseconds(this System.TimeSpan self) { } + public static System.TimeSpan Microseconds(this int microseconds) { } + public static System.TimeSpan Microseconds(this long microseconds) { } + public static System.TimeSpan Milliseconds(this double milliseconds) { } + public static System.TimeSpan Milliseconds(this int milliseconds) { } + public static System.TimeSpan Minutes(this double minutes) { } + public static System.TimeSpan Minutes(this int minutes) { } + public static System.TimeSpan Minutes(this int minutes, System.TimeSpan offset) { } + public static int Nanoseconds(this System.TimeSpan self) { } + public static System.TimeSpan Nanoseconds(this int nanoseconds) { } + public static System.TimeSpan Nanoseconds(this long nanoseconds) { } + public static System.TimeSpan Seconds(this double seconds) { } + public static System.TimeSpan Seconds(this int seconds) { } + public static System.TimeSpan Seconds(this int seconds, System.TimeSpan offset) { } + public static System.TimeSpan Ticks(this int ticks) { } + public static System.TimeSpan Ticks(this long ticks) { } + public static double TotalMicroseconds(this System.TimeSpan self) { } + public static double TotalNanoseconds(this System.TimeSpan self) { } + } +} +namespace FluentAssertions.Formatting +{ + public class AggregateExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AggregateExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DefaultValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DefaultValueFormatter() { } + protected virtual int SpacesPerIndentionLevel { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Reflection.MemberInfo[] GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DictionaryValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DictionaryValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumValueFormatter() { } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class EnumerableValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public EnumerableValueFormatter() { } + protected virtual int MaxItems { get; } + public virtual bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate void FormatChild(string childPath, object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph); + public class FormattedObjectGraph + { + public FormattedObjectGraph(int maxLines) { } + public int LineCount { get; } + public static int SpacesPerIndentation { get; } + public void AddFragment(string fragment) { } + public void AddFragmentOnNewLine(string fragment) { } + public void AddLine(string line) { } + public override string ToString() { } + public System.IDisposable WithIndentation() { } + } + public static class Formatter + { + public static System.Collections.Generic.IEnumerable Formatters { get; } + public static void AddFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static void RemoveFormatter(FluentAssertions.Formatting.IValueFormatter formatter) { } + public static string ToString(object value, FluentAssertions.Formatting.FormattingOptions options = null) { } + } + public class FormattingContext + { + public FormattingContext() { } + public bool UseLineBreaks { get; set; } + } + public class FormattingOptions + { + public FormattingOptions() { } + public int MaxDepth { get; set; } + public int MaxLines { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MaxLinesExceededException : System.Exception + { + public MaxLinesExceededException() { } + public MaxLinesExceededException(string message) { } + public MaxLinesExceededException(string message, System.Exception innerException) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PredicateLambdaExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PredicateLambdaExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class ValueFormatterAttribute : System.Attribute + { + public ValueFormatterAttribute() { } + } + public class XAttributeValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XAttributeValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XmlReaderValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlReaderValueFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} +namespace FluentAssertions.Numeric +{ + public class ComparableTypeAssertions : FluentAssertions.Numeric.ComparableTypeAssertions> + { + public ComparableTypeAssertions(System.IComparable value) { } + } + public class ComparableTypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, TAssertions> + where TAssertions : FluentAssertions.Numeric.ComparableTypeAssertions + { + public ComparableTypeAssertions(System.IComparable value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeRankedEquallyTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeRankedEquallyTo(T unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NullableNumericAssertions> + where T : struct, System.IComparable + { + public NullableNumericAssertions(T? value) { } + } + public class NullableNumericAssertions : FluentAssertions.Numeric.NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NullableNumericAssertions + { + public NullableNumericAssertions(T? value) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NumericAssertions : FluentAssertions.Numeric.NumericAssertions> + where T : struct, System.IComparable + { + public NumericAssertions(T value) { } + } + public class NumericAssertions + where T : struct, System.IComparable + where TAssertions : FluentAssertions.Numeric.NumericAssertions + { + public NumericAssertions(T value) { } + public T? Subject { get; } + public FluentAssertions.AndConstraint Be(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(T? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(T expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params T[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(T? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInRange(T minimumValue, T maximumValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Primitives +{ + public class BooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + } + public class BooleanAssertions + where TAssertions : FluentAssertions.Primitives.BooleanAssertions + { + public BooleanAssertions(bool? value) { } + public bool? Subject { get; } + public FluentAssertions.AndConstraint Be(bool expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(bool unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + } + public class DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + public DateTimeAssertions(System.DateTime? value) { } + public System.DateTime? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTime? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTime nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeIn(System.DateTimeKind expectedKind, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTime[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTime expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTime? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTime distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTime unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + } + public class DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + public DateTimeOffsetAssertions(System.DateTimeOffset? value) { } + public System.DateTimeOffset? Subject { get; } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeAtLeast(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.DateTimeOffset nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeExactly(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeExactly(System.DateTimeOffset? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeLessThan(System.TimeSpan timeSpan) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeMoreThan(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint BeOnOrAfter(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOnOrBefore(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params System.DateTimeOffset[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(params System.Nullable<>[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameDateAs(System.DateTimeOffset expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Primitives.DateTimeOffsetRangeAssertions BeWithin(System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint HaveDay(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveHour(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMinute(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveMonth(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveOffset(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSecond(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveYear(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.DateTimeOffset distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeExactly(System.DateTimeOffset? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrAfter(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOnOrBefore(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameDateAs(System.DateTimeOffset unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveDay(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveHour(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMinute(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMonth(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveOffset(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSecond(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveYear(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class DateTimeOffsetRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + { + protected DateTimeOffsetRangeAssertions(TAssertions parentAssertions, System.DateTimeOffset? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTimeOffset target, string because = "", params object[] becauseArgs) { } + } + public class DateTimeRangeAssertions + where TAssertions : FluentAssertions.Primitives.DateTimeAssertions + { + protected DateTimeRangeAssertions(TAssertions parentAssertions, System.DateTime? subject, FluentAssertions.Primitives.TimeSpanCondition condition, System.TimeSpan timeSpan) { } + public FluentAssertions.AndConstraint After(System.DateTime target, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Before(System.DateTime target, string because = "", params object[] becauseArgs) { } + } + public class EnumAssertions : FluentAssertions.Primitives.EnumAssertions> + where TEnum : struct, System.Enum + { + public EnumAssertions(TEnum subject) { } + } + public class EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.EnumAssertions + { + public EnumAssertions(TEnum subject) { } + public TEnum? Subject { get; } + public FluentAssertions.AndConstraint Be(TEnum expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(TEnum? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params TEnum[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveFlag(TEnum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameNameAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveSameValueAs(T expected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint HaveValue(decimal expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TEnum? unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveFlag(TEnum unexpectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameNameAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveSameValueAs(T unexpected, string because = "", params object[] becauseArgs) + where T : struct, System.Enum { } + public FluentAssertions.AndConstraint NotHaveValue(decimal unexpected, string because = "", params object[] becauseArgs) { } + } + public class GuidAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + } + public class GuidAssertions + where TAssertions : FluentAssertions.Primitives.GuidAssertions + { + public GuidAssertions(System.Guid? value) { } + public System.Guid? Subject { get; } + public FluentAssertions.AndConstraint Be(System.Guid expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Guid unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + } + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + } + public class HttpResponseMessageAssertions + where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions + { + public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } + public System.Net.Http.HttpResponseMessage Subject { get; } + public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveStatusCode(System.Net.HttpStatusCode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveStatusCode(System.Net.HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + } + public class NullableBooleanAssertions : FluentAssertions.Primitives.BooleanAssertions + where TAssertions : FluentAssertions.Primitives.NullableBooleanAssertions + { + public NullableBooleanAssertions(bool? value) { } + public FluentAssertions.AndConstraint Be(bool? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeFalse(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeTrue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + } + public class NullableDateTimeAssertions : FluentAssertions.Primitives.DateTimeAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeAssertions + { + public NullableDateTimeAssertions(System.DateTime? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + } + public class NullableDateTimeOffsetAssertions : FluentAssertions.Primitives.DateTimeOffsetAssertions + where TAssertions : FluentAssertions.Primitives.NullableDateTimeOffsetAssertions + { + public NullableDateTimeOffsetAssertions(System.DateTimeOffset? expected) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.NullableEnumAssertions> + where TEnum : struct, System.Enum + { + public NullableEnumAssertions(TEnum? subject) { } + } + public class NullableEnumAssertions : FluentAssertions.Primitives.EnumAssertions + where TEnum : struct, System.Enum + where TAssertions : FluentAssertions.Primitives.NullableEnumAssertions + { + public NullableEnumAssertions(TEnum? subject) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + } + public class NullableGuidAssertions : FluentAssertions.Primitives.GuidAssertions + where TAssertions : FluentAssertions.Primitives.NullableGuidAssertions + { + public NullableGuidAssertions(System.Guid? value) { } + public FluentAssertions.AndConstraint Be(System.Guid? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class NullableSimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.NullableSimpleTimeSpanAssertions + { + public NullableSimpleTimeSpanAssertions(System.TimeSpan? value) { } + public FluentAssertions.AndConstraint Be(System.TimeSpan? expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveValue(string because = "", params object[] becauseArgs) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(object value) { } + } + public class ObjectAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ObjectAssertions + { + public ObjectAssertions(TSubject value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(TSubject unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(TExpectation unexpected, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + } + public abstract class ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + protected ReferenceTypeAssertions(TSubject subject) { } + protected abstract string Identifier { get; } + public TSubject Subject { get; } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOfType(System.Type expectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSameAs(TSubject expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where T : TSubject { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNull(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(System.Type unexpectedType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeOfType(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSameAs(TSubject unexpected, string because = "", params object[] becauseArgs) { } + } + public class SimpleTimeSpanAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + } + public class SimpleTimeSpanAssertions + where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions + { + public SimpleTimeSpanAssertions(System.TimeSpan? value) { } + public System.TimeSpan? Subject { get; } + public FluentAssertions.AndConstraint Be(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan nearbyTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNegative(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BePositive(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.TimeSpan unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeCloseTo(System.TimeSpan distantTime, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + } + public class StringAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + } + public class StringAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TAssertions : FluentAssertions.Primitives.StringAssertions + { + public StringAssertions(string value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeOneOf(params string[] validValues) { } + public FluentAssertions.AndConstraint BeOneOf(System.Collections.Generic.IEnumerable validValues, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAll(params string[] values) { } + public FluentAssertions.AndConstraint ContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainAny(params string[] values) { } + public FluentAssertions.AndConstraint ContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(string expected, FluentAssertions.OccurrenceConstraint occurrenceConstraint, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Match(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint MatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeLowerCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUpperCased(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAll(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAll(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainAny(params string[] values) { } + public FluentAssertions.AndConstraint NotContainAny(System.Collections.Generic.IEnumerable values, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEndWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchEquivalentOf(string wildcardPattern, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotMatchRegex(System.Text.RegularExpressions.Regex regularExpression, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWith(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotStartWithEquivalentOf(string unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWithEquivalentOf(string expected, string because = "", params object[] becauseArgs) { } + } + public enum TimeSpanCondition + { + MoreThan = 0, + AtLeast = 1, + Exactly = 2, + Within = 3, + LessThan = 4, + } +} +namespace FluentAssertions.Reflection +{ + public class AssemblyAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public AssemblyAssertions(System.Reflection.Assembly assembly) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint DefineType(string @namespace, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Specialized +{ + public class ActionAssertions : FluentAssertions.Specialized.DelegateAssertions + { + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + } + public class AsyncFunctionAssertions : FluentAssertions.Specialized.DelegateAssertionsBase, TAssertions> + where TTask : System.Threading.Tasks.Task + where TAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public AsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> NotThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public System.Threading.Tasks.Task> ThrowExactlyAsync(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertionsBase : FluentAssertions.Primitives.ReferenceTypeAssertions> + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + { + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) { } + protected FluentAssertions.AndConstraint NotThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.Specialized.ExceptionAssertions ThrowInternal(System.Exception exception, string because, object[] becauseArgs) + where TException : System.Exception { } + } + public abstract class DelegateAssertions : FluentAssertions.Specialized.DelegateAssertionsBase + where TDelegate : System.Delegate + where TAssertions : FluentAssertions.Specialized.DelegateAssertions + { + protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { } + protected abstract void InvokeSubject(); + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.AndConstraint NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Specialized.ExceptionAssertions Throw(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + public FluentAssertions.Specialized.ExceptionAssertions ThrowExactly(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public class ExceptionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions, FluentAssertions.Specialized.ExceptionAssertions> + where TException : System.Exception + { + public ExceptionAssertions(System.Collections.Generic.IEnumerable exceptions) { } + public TException And { get; } + protected override string Identifier { get; } + public TException Which { get; } + public FluentAssertions.Specialized.ExceptionAssertions Where(System.Linq.Expressions.Expression> exceptionExpression, string because = "", params object[] becauseArgs) { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerException(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithInnerExceptionExactly(string because = null, params object[] becauseArgs) + where TInnerException : System.Exception { } + public virtual FluentAssertions.Specialized.ExceptionAssertions WithMessage(string expectedWildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class ExecutionTime + { + public ExecutionTime(System.Action action, FluentAssertions.Common.StartTimer createTimer) { } + public ExecutionTime(System.Func action, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Action action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + protected ExecutionTime(System.Func action, string actionDescription, FluentAssertions.Common.StartTimer createTimer) { } + } + public class ExecutionTimeAssertions + { + public ExecutionTimeAssertions(FluentAssertions.Specialized.ExecutionTime executionTime) { } + public FluentAssertions.AndConstraint BeCloseTo(System.TimeSpan expectedDuration, System.TimeSpan precision, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThan(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeGreaterThanOrEqualTo(System.TimeSpan minDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThanOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + } + public class FunctionAssertions : FluentAssertions.Specialized.DelegateAssertions, FluentAssertions.Specialized.FunctionAssertions> + { + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public FunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + protected override string Identifier { get; } + protected override void InvokeSubject() { } + public FluentAssertions.AndWhichConstraint, T> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, T> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + } + public class GenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions, FluentAssertions.Specialized.GenericAsyncFunctionAssertions> + { + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public GenericAsyncFunctionAssertions(System.Func> subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAfterAsync(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> NotThrowAsync(string because = "", params object[] becauseArgs) { } + } + public interface IExtractExceptions + { + System.Collections.Generic.IEnumerable OfType(System.Exception actualException) + where T : System.Exception; + } + public class MemberExecutionTime : FluentAssertions.Specialized.ExecutionTime + { + public MemberExecutionTime(T subject, System.Linq.Expressions.Expression> action, FluentAssertions.Common.StartTimer createTimer) { } + } + public class NonGenericAsyncFunctionAssertions : FluentAssertions.Specialized.AsyncFunctionAssertions + { + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor) { } + public NonGenericAsyncFunctionAssertions(System.Func subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { } + } + public class TaskCompletionSourceAssertions + { + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs) { } + public TaskCompletionSourceAssertions(System.Threading.Tasks.TaskCompletionSource tcs, FluentAssertions.Common.IClock clock) { } + public System.Threading.Tasks.Task, T>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task NotCompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Streams +{ + public class BufferedStreamAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + } + public class BufferedStreamAssertions : FluentAssertions.Streams.StreamAssertions + where TAssertions : FluentAssertions.Streams.BufferedStreamAssertions + { + public BufferedStreamAssertions(System.IO.BufferedStream stream) { } + public FluentAssertions.AndConstraint HaveBufferSize(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveBufferSize(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class StreamAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(System.IO.Stream stream) { } + } + public class StreamAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.IO.Stream + where TAssertions : FluentAssertions.Streams.StreamAssertions + { + public StreamAssertions(TSubject stream) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveLength(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HavePosition(long expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSeekable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWriteOnly(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveLength(long unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHavePosition(long unexpected, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Types +{ + public static class AllTypes + { + public static FluentAssertions.Types.TypeSelector From(System.Reflection.Assembly assembly) { } + } + public class ConstructorInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public ConstructorInfoAssertions(System.Reflection.ConstructorInfo constructorInfo) { } + protected override string Identifier { get; } + } + public abstract class MemberInfoAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Reflection.MemberInfo + where TAssertions : FluentAssertions.Types.MemberInfoAssertions + { + protected MemberInfoAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint, TAttribute> BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + } + public abstract class MethodBaseAssertions : FluentAssertions.Types.MemberInfoAssertions + where TSubject : System.Reflection.MethodBase + where TAssertions : FluentAssertions.Types.MethodBaseAssertions + { + protected MethodBaseAssertions(TSubject subject) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + } + public class MethodInfoAssertions : FluentAssertions.Types.MethodBaseAssertions + { + public MethodInfoAssertions(System.Reflection.MethodInfo methodInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> NotReturnVoid(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(System.Type returnType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> Return(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint> ReturnVoid(string because = "", params object[] becauseArgs) { } + } + public class MethodInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public MethodInfoSelector(System.Collections.Generic.IEnumerable types) { } + public MethodInfoSelector(System.Type type) { } + public FluentAssertions.Types.MethodInfoSelector ThatArePublicOrInternal { get; } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturnVoid { get; } + public FluentAssertions.Types.MethodInfoSelector ThatReturnVoid { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotAsync() { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatDoNotReturn() { } + public FluentAssertions.Types.MethodInfoSelector ThatReturn() { } + public System.Reflection.MethodInfo[] ToArray() { } + } + public class MethodInfoSelectorAssertions + { + public MethodInfoSelectorAssertions(params System.Reflection.MethodInfo[] methods) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectMethods { get; } + public FluentAssertions.AndConstraint Be(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAsync(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoAssertions : FluentAssertions.Types.MemberInfoAssertions + { + public PropertyInfoAssertions(System.Reflection.PropertyInfo propertyInfo) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeReadable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeReadable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotReturn(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(System.Type propertyType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Return(string because = "", params object[] becauseArgs) { } + } + public class PropertyInfoSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public PropertyInfoSelector(System.Collections.Generic.IEnumerable types) { } + public PropertyInfoSelector(System.Type type) { } + public FluentAssertions.Types.PropertyInfoSelector ThatArePublicOrInternal { get; } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.PropertyInfoSelector NotOfType() { } + public FluentAssertions.Types.PropertyInfoSelector OfType() { } + public FluentAssertions.Types.TypeSelector ReturnTypes() { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.PropertyInfoSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public System.Reflection.PropertyInfo[] ToArray() { } + } + public class PropertyInfoSelectorAssertions + { + public PropertyInfoSelectorAssertions(params System.Reflection.PropertyInfo[] properties) { } + protected string Context { get; } + public System.Collections.Generic.IEnumerable SubjectProperties { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeWritable(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeVirtual(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeWritable(string because = "", params object[] becauseArgs) { } + } + public class TypeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public TypeAssertions(System.Type type) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Type expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Be(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndWhichConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint HaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveIndexer(System.Type indexerType, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(System.Type propertyType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Implement(string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotBe(System.Type unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAbstract(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(System.Type type, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(System.Type baseType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDerivedFrom(string because = "", params object[] becauseArgs) + where TBaseClass : class { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeStatic(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveAccessModifier(FluentAssertions.Common.CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveConstructor(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint NotHaveDefaultConstructor(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(System.Type interfaceType, string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(System.Type interfaceType, string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveExplicitProperty(string name, string because = "", params object[] becauseArgs) + where TInterface : class { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(System.Type sourceType, System.Type targetType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveImplicitConversionOperator(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveIndexer(System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveMethod(string name, System.Collections.Generic.IEnumerable parameterTypes, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveProperty(string name, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(System.Type interfaceType, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotImplement(string because = "", params object[] becauseArgs) + where TInterface : class { } + } + public class TypeSelector : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public TypeSelector(System.Collections.Generic.IEnumerable types) { } + public TypeSelector(System.Type type) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAreClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } + public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } + public FluentAssertions.Types.TypeSelector ThatDoNotImplement() { } + public FluentAssertions.Types.TypeSelector ThatImplement() { } + public FluentAssertions.Types.TypeSelector ThatSatisfy(System.Func predicate) { } + public System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } + } + public class TypeSelectorAssertions + { + public TypeSelectorAssertions(params System.Type[] types) { } + public System.Collections.Generic.IEnumerable Subject { get; } + public FluentAssertions.AndConstraint BeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint BeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeDecoratedWithOrInherit(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) + where TAttribute : System.Attribute { } + public FluentAssertions.AndConstraint NotBeInNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeUnderNamespace(string @namespace, string because = "", params object[] becauseArgs) { } + } +} +namespace FluentAssertions.Xml +{ + public class XAttributeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XAttributeAssertions(System.Xml.Linq.XAttribute attribute) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XAttribute expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XAttribute unexpected, string because = "", params object[] becauseArgs) { } + } + public class XDocumentAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XDocumentAssertions(System.Xml.Linq.XDocument document) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XDocument expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveRoot(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XDocument unexpected, string because = "", params object[] becauseArgs) { } + } + public class XElementAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + { + public XElementAssertions(System.Xml.Linq.XElement xElement) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.Linq.XElement expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttribute(System.Xml.Linq.XName expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(System.Xml.Linq.XName expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveValue(string expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.Linq.XElement unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlElementAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlElementAssertions(System.Xml.XmlElement xmlElement) { } + public FluentAssertions.AndConstraint HaveAttribute(string expectedName, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveAttributeWithNamespace(string expectedName, string expectedNamespace, string expectedValue, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElement(string expectedName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementWithNamespace(string expectedName, string expectedNamespace, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveInnerText(string expected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(System.Xml.XmlNode xmlNode) { } + } + public class XmlNodeAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Xml.XmlNode + where TAssertions : FluentAssertions.Xml.XmlNodeAssertions + { + public XmlNodeAssertions(TSubject xmlNode) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Xml.XmlNode expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] becauseArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public void Format(object value, FluentAssertions.Formatting.FormattedObjectGraph formattedGraph, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file From f4e223a147848ed0780809ae4a3d477b85e1d1e4 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 16:59:28 +0100 Subject: [PATCH 10/19] Improve null handling --- .../HttpResponseMessageAssertions.cs | 67 +++++-- .../HttpResponseMessageAssertionSpecs.cs | 188 ++++++++++++++++-- 2 files changed, 224 insertions(+), 31 deletions(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index c8d3f6b5bc..f947405ce7 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -1,8 +1,6 @@ -using System; -using System.Diagnostics; +using System.Diagnostics; using System.Net; using System.Net.Http; -using FluentAssertions.Common; using FluentAssertions.Execution; namespace FluentAssertions.Primitives @@ -14,8 +12,6 @@ namespace FluentAssertions.Primitives public class HttpResponseMessageAssertions : HttpResponseMessageAssertions { - /// Initializes a new instance of the class. - /// Thrown if is null public HttpResponseMessageAssertions(HttpResponseMessage value) : base(value) { @@ -29,13 +25,7 @@ public HttpResponseMessageAssertions(HttpResponseMessage value) public class HttpResponseMessageAssertions where TAssertions : HttpResponseMessageAssertions { - /// Initializes a new instance of the class. - /// Thrown if is null - public HttpResponseMessageAssertions(HttpResponseMessage value) - { - Guard.ThrowIfArgumentIsNull(value, nameof(value)); - Subject = value; - } + public HttpResponseMessageAssertions(HttpResponseMessage value) => Subject = value; /// /// Gets the object which value is being asserted. @@ -54,6 +44,11 @@ public HttpResponseMessageAssertions(HttpResponseMessage value) /// public AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { + Execute.Assertion + .ForCondition(Subject is not null) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but HttpResponseMessage was ."); + Execute.Assertion .ForCondition(Subject.IsSuccessStatusCode) .BecauseOf(because, becauseArgs) @@ -74,6 +69,11 @@ public AndConstraint BeSuccessful(string because = "", params objec /// public AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { + Execute.Assertion + .ForCondition(Subject is not null) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but HttpResponseMessage was ."); + Execute.Assertion .ForCondition((int)Subject.StatusCode >= 300 && (int)Subject.StatusCode <= 399) .BecauseOf(because, becauseArgs) @@ -94,6 +94,11 @@ public AndConstraint BeRedirection(string because = "", params obje /// public AndConstraint HaveError(string because = "", params object[] becauseArgs) { + Execute.Assertion + .ForCondition(Subject is not null) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be an error{reason}, but HttpResponseMessage was ."); + Execute.Assertion .ForCondition(IsClientError() || IsServerError()) .BecauseOf(because, becauseArgs) @@ -114,6 +119,11 @@ public AndConstraint HaveError(string because = "", params object[] /// public AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { + Execute.Assertion + .ForCondition(Subject is not null) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but HttpResponseMessage was ."); + Execute.Assertion .ForCondition(IsClientError()) .BecauseOf(because, becauseArgs) @@ -134,6 +144,11 @@ public AndConstraint HaveClientError(string because = "", params ob /// public AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { + Execute.Assertion + .ForCondition(Subject is not null) + .BecauseOf(because, becauseArgs) + .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but HttpResponseMessage was ."); + Execute.Assertion .ForCondition(IsServerError()) .BecauseOf(because, becauseArgs) @@ -155,10 +170,18 @@ public AndConstraint HaveServerError(string because = "", params ob /// public AndConstraint HaveStatusCode(HttpStatusCode expected, string because = "", params object[] becauseArgs) { - Execute.Assertion - .ForCondition(Subject.StatusCode == expected) + var success = Execute.Assertion + .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be {0}{reason}, but found {1}.", expected, Subject.StatusCode); + .FailWith("Expected HttpStatusCode to be {0}{reason}, but HttpResponseMessage was .", 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)this); } @@ -176,10 +199,18 @@ public AndConstraint HaveStatusCode(HttpStatusCode expected, string /// public AndConstraint NotHaveStatusCode(HttpStatusCode unexpected, string because = "", params object[] becauseArgs) { - Execute.Assertion - .ForCondition(Subject.StatusCode != unexpected) + var success = Execute.Assertion + .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode not to be {0}{reason}, but found {1}.", unexpected, Subject.StatusCode); + .FailWith("Expected HttpStatusCode not to be {0}{reason}, but HttpResponseMessage was .", 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)this); } diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index 9a6cccaab9..846eb677a8 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -8,19 +8,6 @@ namespace FluentAssertions.Specs.Primitives { public class HttpResponseMessageAssertionSpecs { - [Fact] - public void Should_fail_when_testee_is_null() - { - // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().BeSuccessful(); - - // Assert - action.Should().Throw(); - } - [Theory] [InlineData(HttpStatusCode.OK)] [InlineData(HttpStatusCode.Accepted)] @@ -59,6 +46,31 @@ public void Should_fail_with_descriptive_message_when_status_code_error_is_succe .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_when_asserting_success_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().BeSuccessful(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_success_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().BeSuccessful("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but HttpResponseMessage was ."); + } + [Theory] [InlineData(HttpStatusCode.Moved)] public void Should_succeed_when_status_code_is_redirect(HttpStatusCode statusCodeOfResponse) @@ -96,6 +108,31 @@ public void Should_fail_with_descriptive_message_when_status_code_error_is_redir .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_when_asserting_redirect_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().BeRedirection(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_redirect_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().BeRedirection("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but HttpResponseMessage was ."); + } + [Theory] [InlineData(HttpStatusCode.Gone)] [InlineData(HttpStatusCode.BadRequest)] @@ -134,6 +171,31 @@ public void Should_fail_with_descriptive_message_when_status_code_success_is_cli .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_when_asserting_client_error_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().HaveClientError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_client_error_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().HaveClientError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but HttpResponseMessage was ."); + } + [Theory] [InlineData(HttpStatusCode.InternalServerError)] public void Should_succeed_when_status_code_is_server_error(HttpStatusCode statusCodeOfResponse) @@ -171,6 +233,31 @@ public void Should_fail_with_descriptive_message_when_status_code_success_is_ser .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_when_asserting_server_error_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().HaveServerError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_server_error_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().HaveServerError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but HttpResponseMessage was ."); + } + [Theory] [InlineData(HttpStatusCode.BadRequest)] [InlineData(HttpStatusCode.InternalServerError)] @@ -209,6 +296,31 @@ public void Should_fail_with_descriptive_message_when_status_code_success_is_err .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_when_asserting_error_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().HaveError(); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_error_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().HaveError("because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be an error because we want to test the failure message, but HttpResponseMessage was ."); + } + [Fact] public void Should_succeed_when_status_code_to_be_equal_to_the_same_value() { @@ -243,6 +355,31 @@ public void Should_fail_with_descriptive_message_when_status_code_value_to_be_eq .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_when_asserting_certain_status_code_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().HaveStatusCode(HttpStatusCode.Gone); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_certain_status_code_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); + } + [Fact] public void Should_succeed_when_status_code_value_not_to_be_equal_to_the_same_value() { @@ -276,5 +413,30 @@ public void Should_fail_with_descriptive_message_when_status_code_value_not_to_b action.Should().Throw() .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_when_asserting_against_certain_status_code_but_response_is_null() + { + // Arrange + HttpResponseMessage testee = null; + + // Act + Action action = () => testee.Should().NotHaveStatusCode(HttpStatusCode.Gone); + + // Assert + action.Should().Throw(); + } + + [Fact] + public void Should_fail_with_descriptive_message_when_asserting_against_certain_status_code_but_response_is_null() + { + // Act + Action action = () => ((HttpResponseMessage)null).Should().NotHaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); + + // Assert + action + .Should().Throw() + .WithMessage("Expected HttpStatusCode not to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); + } } } From 75f36d2bb473a0b63f33919402f6aa85b921602d Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Thu, 11 Nov 2021 17:01:47 +0100 Subject: [PATCH 11/19] Fix minor issues in docu and release notes --- docs/_data/navigation.yml | 2 +- docs/_pages/releases.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/_data/navigation.yml b/docs/_data/navigation.yml index 7e877d1823..0ec09d306d 100644 --- a/docs/_data/navigation.yml +++ b/docs/_data/navigation.yml @@ -73,7 +73,7 @@ sidebar: url: /xml - title: Execution Time url: /executiontime - - title: HttpResponseMessage + - title: HTTP response messages url: /httpresponsemessages - title: Extensibility diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index 4f329af2ef..e1df970d9b 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -11,7 +11,7 @@ sidebar: ### What's New * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725) -* Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1698](https://github.com/fluentassertions/fluentassertions/discussions/1698) +* Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737) ### Fixes @@ -28,7 +28,7 @@ sidebar: * `At` now retains the `DateTimeKind` and keeps sub-second precision when using a `TimeSpan` - [#1687](https://github.com/fluentassertions/fluentassertions/pull/1687). * Removed iteration over enumerable when generating the `BeEmpty` assertion failure message - [#1692](https://github.com/fluentassertions/fluentassertions/pull/1692). * Prevent `ArgumentNullException` when formatting a lambda expression containing an extension method - [#1696](https://github.com/fluentassertions/fluentassertions/pull/1696) -* `IgnoringCyclicReferences` in `BeEquivalentTo` now works while comparing value types using `ComparingByMembers` - [#1708](https://github.com/fluentassertions/fluentassertions/pull/1708) +* `IgnoringCyclicReferences` in `BeEquivalentTo` now works while comparing value types using `ComparingByMembers` - [#1708](https://github.com/fluentassertions/fluentassertions/pull/1708) * Using `BeEquivalentTo` on a collection with nested collections would complain about missing members - [#1713](https://github.com/fluentassertions/fluentassertions/pull/1713) * Formatting a lambda expression containing lifted operators - [#1714](https://github.com/fluentassertions/fluentassertions/pull/1714). * Performance improvements in `BeEquivalentTo` by caching expensive Reflection operations - [#1719](https://github.com/fluentassertions/fluentassertions/pull/1719) From 33c0b887d9a96d8fd73130a33bd8da0645462356 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 15 Nov 2021 10:12:14 +0100 Subject: [PATCH 12/19] Improve some details like inheritance and null checks --- Src/FluentAssertions/AssertionExtensions.cs | 8 -- .../HttpResponseMessageAssertions.cs | 90 +++++++++++-------- .../FluentAssertions/net47.verified.txt | 9 +- .../netcoreapp2.1.verified.txt | 9 +- .../netcoreapp3.0.verified.txt | 9 +- .../netstandard2.0.verified.txt | 9 +- .../netstandard2.1.verified.txt | 9 +- 7 files changed, 61 insertions(+), 82 deletions(-) diff --git a/Src/FluentAssertions/AssertionExtensions.cs b/Src/FluentAssertions/AssertionExtensions.cs index 4d1d4e6093..4940cffe48 100644 --- a/Src/FluentAssertions/AssertionExtensions.cs +++ b/Src/FluentAssertions/AssertionExtensions.cs @@ -876,14 +876,6 @@ public static void Should(this BooleanAssertions _) InvalidShouldCall(); } - /// - [Obsolete("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'", error: true)] - public static void Should(this HttpResponseMessageAssertions _) - where TAssertions : HttpResponseMessageAssertions - { - InvalidShouldCall(); - } - /// [Obsolete("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'", error: true)] public static void Should(this DateTimeAssertions _) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index f947405ce7..e8af420a2b 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -9,8 +9,7 @@ namespace FluentAssertions.Primitives /// Contains a number of methods to assert that a is in the expected state. /// [DebuggerNonUserCode] - public class HttpResponseMessageAssertions - : HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : HttpResponseMessageAssertions { public HttpResponseMessageAssertions(HttpResponseMessage value) : base(value) @@ -19,18 +18,16 @@ public HttpResponseMessageAssertions(HttpResponseMessage value) } /// - /// Contains a number of methods to assert that a is in the expected state. + /// Contains a number of methods to assert that a is in the expected state. /// [DebuggerNonUserCode] - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : ObjectAssertions where TAssertions : HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(HttpResponseMessage value) => Subject = value; - - /// - /// Gets the object which value is being asserted. - /// - public HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(HttpResponseMessage value) + : base(value) + { + } /// /// Asserts that the is successful (2xx). @@ -44,15 +41,18 @@ public class HttpResponseMessageAssertions /// public AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { - Execute.Assertion + var success = Execute.Assertion .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but HttpResponseMessage was ."); - Execute.Assertion - .ForCondition(Subject.IsSuccessStatusCode) - .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be successful (2xx){reason}, but found {0}.", Subject.StatusCode); + 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)this); } @@ -69,15 +69,18 @@ public AndConstraint BeSuccessful(string because = "", params objec /// public AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { - Execute.Assertion + var success = Execute.Assertion .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but HttpResponseMessage was ."); - Execute.Assertion - .ForCondition((int)Subject.StatusCode >= 300 && (int)Subject.StatusCode <= 399) - .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be redirection (3xx){reason}, but found {0}.", Subject.StatusCode); + 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)this); } @@ -94,15 +97,18 @@ public AndConstraint BeRedirection(string because = "", params obje /// public AndConstraint HaveError(string because = "", params object[] becauseArgs) { - Execute.Assertion + var success = Execute.Assertion .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be an error{reason}, but HttpResponseMessage was ."); - Execute.Assertion - .ForCondition(IsClientError() || IsServerError()) - .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be an error{reason}, but found {0}.", Subject.StatusCode); + 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)this); } @@ -119,15 +125,18 @@ public AndConstraint HaveError(string because = "", params object[] /// public AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { - Execute.Assertion + var success = Execute.Assertion .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but HttpResponseMessage was ."); - Execute.Assertion - .ForCondition(IsClientError()) - .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be client error (4xx){reason}, but found {0}.", Subject.StatusCode); + 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)this); } @@ -144,15 +153,18 @@ public AndConstraint HaveClientError(string because = "", params ob /// public AndConstraint HaveServerError(string because = "", params object[] becauseArgs) { - Execute.Assertion + var success = Execute.Assertion .ForCondition(Subject is not null) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but HttpResponseMessage was ."); - Execute.Assertion - .ForCondition(IsServerError()) - .BecauseOf(because, becauseArgs) - .FailWith("Expected HttpStatusCode to be server error (5xx){reason}, but found {0}.", Subject.StatusCode); + 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)this); } @@ -178,7 +190,7 @@ public AndConstraint HaveStatusCode(HttpStatusCode expected, string if (success) { Execute.Assertion - .ForCondition(Subject.StatusCode == expected) + .ForCondition(Subject!.StatusCode == expected) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode to be {0}{reason}, but found {1}.", expected, Subject.StatusCode); } @@ -207,7 +219,7 @@ public AndConstraint NotHaveStatusCode(HttpStatusCode unexpected, s if (success) { Execute.Assertion - .ForCondition(Subject.StatusCode != unexpected) + .ForCondition(Subject!.StatusCode != unexpected) .BecauseOf(because, becauseArgs) .FailWith("Expected HttpStatusCode not to be {0}{reason}, but found {1}.", unexpected, Subject.StatusCode); } @@ -215,8 +227,8 @@ public AndConstraint NotHaveStatusCode(HttpStatusCode unexpected, s return new AndConstraint((TAssertions)this); } - private bool IsServerError() => (int)Subject.StatusCode >= 500 && (int)Subject.StatusCode <= 599; + private bool IsServerError() => (int)Subject.StatusCode is >= 500 and <= 599; - private bool IsClientError() => (int)Subject.StatusCode >= 400 && (int)Subject.StatusCode <= 499; + private bool IsClientError() => (int)Subject.StatusCode is >= 400 and <= 499; } } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt index 5d9083b720..ec961fe636 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt @@ -121,10 +121,6 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1910,11 +1906,10 @@ namespace FluentAssertions.Primitives { public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } } - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.ObjectAssertions where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint HaveClientError(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 8646b74f54..aeed997d12 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt @@ -121,10 +121,6 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1910,11 +1906,10 @@ namespace FluentAssertions.Primitives { public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } } - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.ObjectAssertions where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint HaveClientError(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 631c9a5dad..bb6134ae5f 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt @@ -121,10 +121,6 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1910,11 +1906,10 @@ namespace FluentAssertions.Primitives { public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } } - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.ObjectAssertions where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint HaveClientError(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 6da96507de..9517aa1350 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt @@ -120,10 +120,6 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1863,11 +1859,10 @@ namespace FluentAssertions.Primitives { public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } } - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.ObjectAssertions where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint HaveClientError(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 67bfa6db19..7d01b16c0f 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt @@ -121,10 +121,6 @@ namespace FluentAssertions where TAssertions : FluentAssertions.Primitives.GuidAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + "ly following \'And\'", true)] - public static void Should(this FluentAssertions.Primitives.HttpResponseMessageAssertions _) - where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { } - [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + - "ly following \'And\'", true)] public static void Should(this FluentAssertions.Primitives.SimpleTimeSpanAssertions _) where TAssertions : FluentAssertions.Primitives.SimpleTimeSpanAssertions { } [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" + @@ -1910,11 +1906,10 @@ namespace FluentAssertions.Primitives { public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } } - public class HttpResponseMessageAssertions + public class HttpResponseMessageAssertions : FluentAssertions.Primitives.ObjectAssertions where TAssertions : FluentAssertions.Primitives.HttpResponseMessageAssertions { - public HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } - public System.Net.Http.HttpResponseMessage Subject { get; } + protected HttpResponseMessageAssertions(System.Net.Http.HttpResponseMessage value) { } public FluentAssertions.AndConstraint BeRedirection(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint BeSuccessful(string because = "", params object[] becauseArgs) { } public FluentAssertions.AndConstraint HaveClientError(string because = "", params object[] becauseArgs) { } From 328a9378ecade6b71129deab6ae971c29e4e8a7e Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 3 Jan 2022 08:43:37 +0100 Subject: [PATCH 13/19] Make System.Net.Http a conditional dependency for .NET 4.7 --- Src/FluentAssertions/FluentAssertions.csproj | 1 + Tests/Benchmarks/Benchmarks.csproj | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Src/FluentAssertions/FluentAssertions.csproj b/Src/FluentAssertions/FluentAssertions.csproj index 2204810ff1..330b2da149 100644 --- a/Src/FluentAssertions/FluentAssertions.csproj +++ b/Src/FluentAssertions/FluentAssertions.csproj @@ -75,6 +75,7 @@ + diff --git a/Tests/Benchmarks/Benchmarks.csproj b/Tests/Benchmarks/Benchmarks.csproj index 29d901653b..3e61198905 100644 --- a/Tests/Benchmarks/Benchmarks.csproj +++ b/Tests/Benchmarks/Benchmarks.csproj @@ -16,6 +16,5 @@ - - \ No newline at end of file + From f181d8fd4d15fdf600a54c79c15f57ba166e7fbd Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 3 Jan 2022 08:47:56 +0100 Subject: [PATCH 14/19] Fix merge conflicts --- docs/_pages/releases.md | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index e1df970d9b..924339eb1f 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -4,16 +4,27 @@ permalink: /releases/ layout: single classes: wide sidebar: - nav: "sidebar" +nav: "sidebar" --- ## Unreleased +### What's New + +### Fixes + +## 6.3.0 + ### What's New * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725) * Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737) +* Adding `ThatAreVirtual()` and `ThatAreNotVirtual()` for filtering in method assertions - [#1744](https://github.com/fluentassertions/fluentassertions/pull/1744) +* Adding collection content to assertion messages for `HaveCountGreaterThan()`, `HaveCountGreaterThanOrEqualTo()`, `HaveCountLessThan()` and `HaveCountLessThanOrEqualTo()` - [#1760](https://github.com/fluentassertions/fluentassertions/pull/1760) ### Fixes +* Prevent multiple enumeration of `IEnumerable`s in parameter-less `ContainSingle()` - [#1753](https://github.com/fluentassertions/fluentassertions/pull/1753) +* Change `HaveCount()` assertion message order to state expected and actual collection count before dumping its content` - [#1760](https://github.com/fluentassertions/fluentassertions/pull/1760) +* `CompleteWithinAsync` did not take initial sync computation into account when measuring execution time - [1762](https://github.com/fluentassertions/fluentassertions/pull/1762). ## 6.2.0 @@ -145,20 +156,20 @@ sidebar: * Dropped support for .NET Framework 4.5, .NET Standard 1.3 and 1.6 - [#1227](https://github.com/fluentassertions/fluentassertions/pull/1227). * Dropped support for older test frameworks such as MSTest v1, NSpec v1 and v2, XUnit v1, Gallio and MBUnit - [#1227](https://github.com/fluentassertions/fluentassertions/pull/1227). * Removed `[Not]Have{Im,Ex}plictConversionOperator` (they had typos) - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use the equivalent assertions without the typo "plict" instead. + * Use the equivalent assertions without the typo "plict" instead. * Removed `NotBeAscendingInOrder`/`NotBeDescendingInOrder` - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use `NotBeInAscendingOrder`/`NotBeInDescendingOrder` instead. + * Use `NotBeInAscendingOrder`/`NotBeInDescendingOrder` instead. * Removed `HasAttribute`, `HasMatchingAttribute` and `IsDecoratedWith(Type, bool)` `Type` extensions - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use `IsDecoratedWith`/`IsDecoratedWithOrInherits` instead. + * Use `IsDecoratedWith`/`IsDecoratedWithOrInherits` instead. * Made `EquivalencyAssertionOptionsExtentions` `internal` (and fixed a typo in the type name) - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). * Changed `ReferenceTypeAssertions.Subject` to be `readonly` - [#1229](https://github.com/fluentassertions/fluentassertions/pull/1229). - * Set the `Subject` through the constructor instead. + * Set the `Subject` through the constructor instead. * Changed `TypeAssertions.HaveAccessModifier` return type from `AndConstraint` to `AndConstraint` - [#1159](https://github.com/fluentassertions/fluentassertions/pull/1159). * Changed `TypeAssertions.NotHaveAccessModifier` return type from `AndConstraint` to `AndConstraint` - [#1159](https://github.com/fluentassertions/fluentassertions/pull/1159). * Changed `AllBeAssignableTo` and `AllBeOfType` return type from `AndConstraint` to `AndWhichConstraint>` - [#1265](https://github.com/fluentassertions/fluentassertions/pull/1265). * The new extension on `TaskCompletionSource` overlays the previously used assertions based on `ObjectAssertions`. * Removed `[Not]BeCloseTo` for `DateTime[Offset]` and `TimeSpan` that took an `int precision` - [#1278](https://github.com/fluentassertions/fluentassertions/pull/1278). - * Use the overloads that take a `TimeSpan precision` instead. + * Use the overloads that take a `TimeSpan precision` instead. * Aligned strings to be compared using `Ordinal[Ignorecase]` - [#1283](https://github.com/fluentassertions/fluentassertions/pull/1283). * Changed `AutoConversion` to convert using `CultureInfo.InvariantCulture` instead of `CultureInfo.CurrentCulture` - [#1283](https://github.com/fluentassertions/fluentassertions/pull/1283). * Renamed `StartWithEquivalent` and `EndWithEquivalent` to `StartWithEquivalentOf` and `EndWithEquivalentOf` to make the API for Equivalent methods consistent - [#1292](https://github.com/fluentassertions/fluentassertions/pull/1292). @@ -186,7 +197,7 @@ sidebar: ### Breaking Changes (Extensibility) * Removed parameterless constructors from: `CollectionAssertions`, `ReferenceTypeAssertions`, `MemberInfoAssertions`, `MethodBaseAssertions` and `MethodInfoAssertions` - [#1229](https://github.com/fluentassertions/fluentassertions/pull/1229). - * Use the constructors taking a `subject` instead. + * Use the constructors taking a `subject` instead. * Restrict generic constraints on `[Nullable]NumericAssertions` to `IComparable` - [#1266](https://github.com/fluentassertions/fluentassertions/pull/1266). * Changed return type of `[Nullable]NumericAssertions.Subject` from `IComparable` to `T?` and `T`, respectively - [#1266](https://github.com/fluentassertions/fluentassertions/pull/1266). * Removed `Succeeded` and `SourceSucceeded` from `Continuation` and `IAssertionScope` - [#1325](https://github.com/fluentassertions/fluentassertions/pull/1325) From 8e693b84b880663e3745e71417e23fe344b0a6a5 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Tue, 4 Jan 2022 07:51:00 +0100 Subject: [PATCH 15/19] Revert "Fix merge conflicts" This reverts commit f181d8fd4d15fdf600a54c79c15f57ba166e7fbd. --- docs/_pages/releases.md | 25 +++++++------------------ 1 file changed, 7 insertions(+), 18 deletions(-) diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index 924339eb1f..e1df970d9b 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -4,27 +4,16 @@ permalink: /releases/ layout: single classes: wide sidebar: -nav: "sidebar" + nav: "sidebar" --- ## Unreleased -### What's New - -### Fixes - -## 6.3.0 - ### What's New * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725) * Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737) -* Adding `ThatAreVirtual()` and `ThatAreNotVirtual()` for filtering in method assertions - [#1744](https://github.com/fluentassertions/fluentassertions/pull/1744) -* Adding collection content to assertion messages for `HaveCountGreaterThan()`, `HaveCountGreaterThanOrEqualTo()`, `HaveCountLessThan()` and `HaveCountLessThanOrEqualTo()` - [#1760](https://github.com/fluentassertions/fluentassertions/pull/1760) ### Fixes -* Prevent multiple enumeration of `IEnumerable`s in parameter-less `ContainSingle()` - [#1753](https://github.com/fluentassertions/fluentassertions/pull/1753) -* Change `HaveCount()` assertion message order to state expected and actual collection count before dumping its content` - [#1760](https://github.com/fluentassertions/fluentassertions/pull/1760) -* `CompleteWithinAsync` did not take initial sync computation into account when measuring execution time - [1762](https://github.com/fluentassertions/fluentassertions/pull/1762). ## 6.2.0 @@ -156,20 +145,20 @@ nav: "sidebar" * Dropped support for .NET Framework 4.5, .NET Standard 1.3 and 1.6 - [#1227](https://github.com/fluentassertions/fluentassertions/pull/1227). * Dropped support for older test frameworks such as MSTest v1, NSpec v1 and v2, XUnit v1, Gallio and MBUnit - [#1227](https://github.com/fluentassertions/fluentassertions/pull/1227). * Removed `[Not]Have{Im,Ex}plictConversionOperator` (they had typos) - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use the equivalent assertions without the typo "plict" instead. + * Use the equivalent assertions without the typo "plict" instead. * Removed `NotBeAscendingInOrder`/`NotBeDescendingInOrder` - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use `NotBeInAscendingOrder`/`NotBeInDescendingOrder` instead. + * Use `NotBeInAscendingOrder`/`NotBeInDescendingOrder` instead. * Removed `HasAttribute`, `HasMatchingAttribute` and `IsDecoratedWith(Type, bool)` `Type` extensions - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). - * Use `IsDecoratedWith`/`IsDecoratedWithOrInherits` instead. + * Use `IsDecoratedWith`/`IsDecoratedWithOrInherits` instead. * Made `EquivalencyAssertionOptionsExtentions` `internal` (and fixed a typo in the type name) - [#1221](https://github.com/fluentassertions/fluentassertions/pull/1221). * Changed `ReferenceTypeAssertions.Subject` to be `readonly` - [#1229](https://github.com/fluentassertions/fluentassertions/pull/1229). - * Set the `Subject` through the constructor instead. + * Set the `Subject` through the constructor instead. * Changed `TypeAssertions.HaveAccessModifier` return type from `AndConstraint` to `AndConstraint` - [#1159](https://github.com/fluentassertions/fluentassertions/pull/1159). * Changed `TypeAssertions.NotHaveAccessModifier` return type from `AndConstraint` to `AndConstraint` - [#1159](https://github.com/fluentassertions/fluentassertions/pull/1159). * Changed `AllBeAssignableTo` and `AllBeOfType` return type from `AndConstraint` to `AndWhichConstraint>` - [#1265](https://github.com/fluentassertions/fluentassertions/pull/1265). * The new extension on `TaskCompletionSource` overlays the previously used assertions based on `ObjectAssertions`. * Removed `[Not]BeCloseTo` for `DateTime[Offset]` and `TimeSpan` that took an `int precision` - [#1278](https://github.com/fluentassertions/fluentassertions/pull/1278). - * Use the overloads that take a `TimeSpan precision` instead. + * Use the overloads that take a `TimeSpan precision` instead. * Aligned strings to be compared using `Ordinal[Ignorecase]` - [#1283](https://github.com/fluentassertions/fluentassertions/pull/1283). * Changed `AutoConversion` to convert using `CultureInfo.InvariantCulture` instead of `CultureInfo.CurrentCulture` - [#1283](https://github.com/fluentassertions/fluentassertions/pull/1283). * Renamed `StartWithEquivalent` and `EndWithEquivalent` to `StartWithEquivalentOf` and `EndWithEquivalentOf` to make the API for Equivalent methods consistent - [#1292](https://github.com/fluentassertions/fluentassertions/pull/1292). @@ -197,7 +186,7 @@ nav: "sidebar" ### Breaking Changes (Extensibility) * Removed parameterless constructors from: `CollectionAssertions`, `ReferenceTypeAssertions`, `MemberInfoAssertions`, `MethodBaseAssertions` and `MethodInfoAssertions` - [#1229](https://github.com/fluentassertions/fluentassertions/pull/1229). - * Use the constructors taking a `subject` instead. + * Use the constructors taking a `subject` instead. * Restrict generic constraints on `[Nullable]NumericAssertions` to `IComparable` - [#1266](https://github.com/fluentassertions/fluentassertions/pull/1266). * Changed return type of `[Nullable]NumericAssertions.Subject` from `IComparable` to `T?` and `T`, respectively - [#1266](https://github.com/fluentassertions/fluentassertions/pull/1266). * Removed `Succeeded` and `SourceSucceeded` from `Continuation` and `IAssertionScope` - [#1325](https://github.com/fluentassertions/fluentassertions/pull/1325) From 6e8e760dd79dffe653aea75167f8038576f82592 Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Tue, 4 Jan 2022 10:04:02 +0100 Subject: [PATCH 16/19] Remove implicitly covered tests --- .../HttpResponseMessageAssertionSpecs.cs | 365 +++++------------- 1 file changed, 97 insertions(+), 268 deletions(-) diff --git a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs index 846eb677a8..d0513cacc7 100644 --- a/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Primitives/HttpResponseMessageAssertionSpecs.cs @@ -20,55 +20,30 @@ public void Should_succeed_when_status_code_is_successful(HttpStatusCode statusC testee.Should().BeSuccessful(); } - [Fact] - public void Should_fail_when_status_code_error_is_successful() - { - // Arrange - var testee = new HttpResponseMessage(HttpStatusCode.Gone); - - // Act - Action action = () => testee.Should().BeSuccessful(); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_error_is_successful() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.Gone).Should().BeSuccessful("because we want to test the failure {0}", "message"); - - // Assert - action - .Should().Throw() - .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_when_asserting_success_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().BeSuccessful(); + Action action = () => new HttpResponseMessage(HttpStatusCode.Gone).Should() + .BeSuccessful("because we want to test the failure {0}", "message"); - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().BeSuccessful("because we want to test the failure {0}", "message"); + // Arrange + Action action = () => + ((HttpResponseMessage)null).Should().BeSuccessful("because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be successful (2xx) because we want to test the failure message, but HttpResponseMessage was ."); } [Theory] @@ -82,55 +57,30 @@ public void Should_succeed_when_status_code_is_redirect(HttpStatusCode statusCod testee.Should().BeRedirection(); } - [Fact] - public void Should_fail_when_status_code_error_is_redirection() - { - // Arrange - var testee = new HttpResponseMessage(HttpStatusCode.Gone); - - // Act - Action action = () => testee.Should().BeRedirection(); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_error_is_redirection() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.Gone).Should().BeRedirection("because we want to test the failure {0}", "message"); - - // Assert - action - .Should().Throw() - .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_when_asserting_redirect_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().BeRedirection(); + Action action = () => new HttpResponseMessage(HttpStatusCode.Gone).Should() + .BeRedirection("because we want to test the failure {0}", "message"); - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().BeRedirection("because we want to test the failure {0}", "message"); + // Arrange + Action action = () => + ((HttpResponseMessage)null).Should().BeRedirection("because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be redirection (3xx) because we want to test the failure message, but HttpResponseMessage was ."); } [Theory] @@ -145,55 +95,30 @@ public void Should_succeed_when_status_code_is_client_error(HttpStatusCode statu testee.Should().HaveClientError(); } - [Fact] - public void Should_fail_when_status_code_success_is_client_error() - { - // Arrange - var testee = new HttpResponseMessage(HttpStatusCode.OK); - - // Act - Action action = () => testee.Should().HaveClientError(); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_success_is_client_error() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveClientError("because we want to test the failure {0}", "message"); - - // Assert - action - .Should().Throw() - .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_when_asserting_client_error_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().HaveClientError(); + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should() + .HaveClientError("because we want to test the failure {0}", "message"); - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().HaveClientError("because we want to test the failure {0}", "message"); + // Arrange + Action action = () => + ((HttpResponseMessage)null).Should().HaveClientError("because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be client error (4xx) because we want to test the failure message, but HttpResponseMessage was ."); } [Theory] @@ -207,55 +132,30 @@ public void Should_succeed_when_status_code_is_server_error(HttpStatusCode statu testee.Should().HaveServerError(); } - [Fact] - public void Should_fail_when_status_code_success_is_server_error() - { - // Arrange - var testee = new HttpResponseMessage(HttpStatusCode.OK); - - // Act - Action action = () => testee.Should().HaveServerError(); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_success_is_server_error() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveServerError("because we want to test the failure {0}", "message"); - - // Assert - action - .Should().Throw() - .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_when_asserting_server_error_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().HaveServerError(); + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should() + .HaveServerError("because we want to test the failure {0}", "message"); - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().HaveServerError("because we want to test the failure {0}", "message"); + // Arrange + Action action = () => + ((HttpResponseMessage)null).Should().HaveServerError("because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be server error (5xx) because we want to test the failure message, but HttpResponseMessage was ."); } [Theory] @@ -270,173 +170,102 @@ public void Should_succeed_when_status_code_is_error(HttpStatusCode statusCodeOf testee.Should().HaveError(); } - [Fact] - public void Should_fail_when_status_code_success_is_error() - { - // Arrange - var testee = new HttpResponseMessage(HttpStatusCode.OK); - - // Act - Action action = () => testee.Should().HaveError(); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_success_is_error() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveError("because we want to test the failure {0}", "message"); - - // Assert - action - .Should().Throw() - .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_when_asserting_error_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should() + .HaveError("because we want to test the failure {0}", "message"); - // Act - Action action = () => testee.Should().HaveError(); - - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().HaveError("because we want to test the failure {0}", "message"); + // Arrange + Action action = () => + ((HttpResponseMessage)null).Should().HaveError("because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be an error because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be an error because we want to test the failure message, but HttpResponseMessage was ."); } [Fact] public void Should_succeed_when_status_code_to_be_equal_to_the_same_value() { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.OK); + // Arrange + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.OK); - // Assert + // Act / Assert action.Should().NotThrow(); } - [Fact] - public void Should_fail_when_status_code_to_be_equal_to_a_different_value() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_value_to_be_equal_to_a_different_value() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); - - // Assert - action.Should().Throw() - .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_when_asserting_certain_status_code_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; - - // Act - Action action = () => testee.Should().HaveStatusCode(HttpStatusCode.Gone); + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().HaveStatusCode(HttpStatusCode.Gone, + "because we want to test the failure {0}", "message"); - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); + // Arrange + Action action = () => ((HttpResponseMessage)null).Should() + .HaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); } [Fact] public void Should_succeed_when_status_code_value_not_to_be_equal_to_the_same_value() { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.Gone); + // Arrange + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.Gone); - // Assert + // Act / Assert action.Should().NotThrow(); } - [Fact] - public void Should_fail_when_status_code_value_not_to_be_equal_to_a_different_value() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK); - - // Assert - action.Should().Throw(); - } - [Fact] public void Should_fail_with_descriptive_message_when_status_code_value_not_to_be_equal_to_a_different_value() - { - // Act - Action action = () => - new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK, "because we want to test the failure {0}", "message"); - - // Assert - action.Should().Throw() - .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_when_asserting_against_certain_status_code_but_response_is_null() { // Arrange - HttpResponseMessage testee = null; + Action action = () => new HttpResponseMessage(HttpStatusCode.OK).Should().NotHaveStatusCode(HttpStatusCode.OK, + "because we want to test the failure {0}", "message"); - // Act - Action action = () => testee.Should().NotHaveStatusCode(HttpStatusCode.Gone); - - // Assert - action.Should().Throw(); + // Act / Assert + action.Should().Throw() + .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() { - // Act - Action action = () => ((HttpResponseMessage)null).Should().NotHaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); + // Arrange + Action action = () => ((HttpResponseMessage)null).Should() + .NotHaveStatusCode(HttpStatusCode.Gone, "because we want to test the failure {0}", "message"); - // Assert - action - .Should().Throw() - .WithMessage("Expected HttpStatusCode not to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); + // Act / Assert + action.Should().Throw() + .WithMessage( + "Expected HttpStatusCode not to be HttpStatusCode.Gone {value: 410} because we want to test the failure message, but HttpResponseMessage was ."); } } } From 44ad2450a09184709fdb3ba6062a585dba8014bf Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 10 Jan 2022 08:06:50 +0100 Subject: [PATCH 17/19] Update Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs Co-authored-by: Jonas Nyrup --- .../Primitives/HttpResponseMessageAssertions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index e8af420a2b..3e1708eefa 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -170,7 +170,7 @@ public AndConstraint HaveServerError(string because = "", params ob } /// - /// Asserts that the value is equal to the specified value. + /// Asserts that the is equal to the specified value. /// /// The expected value /// From 421f1f6c4ea1447ae46c9084faeeb25be923033f Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 10 Jan 2022 08:06:57 +0100 Subject: [PATCH 18/19] Update Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs Co-authored-by: Jonas Nyrup --- .../Primitives/HttpResponseMessageAssertions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs index 3e1708eefa..45010cb0ce 100644 --- a/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs +++ b/Src/FluentAssertions/Primitives/HttpResponseMessageAssertions.cs @@ -199,7 +199,7 @@ public AndConstraint HaveStatusCode(HttpStatusCode expected, string } /// - /// Asserts that the value is not equal to the specified value. + /// Asserts that the is not equal to the specified value. /// /// The unexpected value /// From 669f07d3942d413a6f4c5a805aa69a66a8808c9a Mon Sep 17 00:00:00 2001 From: mu88 <4560672+mu88@users.noreply.github.com> Date: Mon, 10 Jan 2022 08:07:10 +0100 Subject: [PATCH 19/19] Update docs/_pages/releases.md Co-authored-by: Jonas Nyrup --- docs/_pages/releases.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index e1df970d9b..48c7eb7249 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -11,7 +11,7 @@ sidebar: ### What's New * Adding `ThatAreAsync()` and `ThatAreNotAsync()` for filtering in method assertions - [#1725](https://github.com/fluentassertions/fluentassertions/pull/1725) -* Adding new assertions for the `HttpStatusCode` of a `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737) +* Adding new assertions for the `HttpStatusCode` of an `HttpResponseMessage` - [#1737](https://github.com/fluentassertions/fluentassertions/pull/1737) ### Fixes